athena/screen/modal_window_controller.cc

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "athena/screen/modal_window_controller.h"

#include "athena/screen/public/screen_manager.h"
#include "base/message_loop/message_loop.h"
#include "ui/aura/window.h"
#include "ui/aura/window_property.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/wm/core/window_animations.h"

namespace athena {
namespace {

DEFINE_OWNED_WINDOW_PROPERTY_KEY(ModalWindowController,
                                 kModalWindowControllerKey,
                                 nullptr);

}  // namespace

// static
ModalWindowController* ModalWindowController::Get(aura::Window* container) {
  ModalWindowController* controller =
      container->GetProperty(kModalWindowControllerKey);
  CHECK(controller);
  return controller;
}

ModalWindowController::ModalWindowController(int priority)
    : modal_container_(nullptr),
      dimmer_window_(new aura::Window(nullptr)),
      dimmed_(false) {
  ScreenManager::ContainerParams params("ModalContainer", priority);
  params.can_activate_children = true;
  params.block_events = true;
  modal_container_ = ScreenManager::Get()->CreateContainer(params);
  modal_container_->SetProperty(kModalWindowControllerKey, this);

  dimmer_window_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
  dimmer_window_->Init(aura::WINDOW_LAYER_SOLID_COLOR);
  dimmer_window_->layer()->SetColor(SK_ColorBLACK);
  dimmer_window_->layer()->SetOpacity(0.0f);
  dimmer_window_->Show();

  modal_container_->AddChild(dimmer_window_);
  modal_container_->AddObserver(this);

  UpdateDimmerWindowBounds();
}

ModalWindowController::~ModalWindowController() {
  if (modal_container_)
    modal_container_->RemoveObserver(this);
}

void ModalWindowController::OnWindowAdded(aura::Window* child) {
  DCHECK_NE(child, dimmer_window_);
  if (IsChildWindow(child)) {
    child->AddObserver(this);
    UpdateDimming(nullptr);
  }
}

void ModalWindowController::OnWindowVisibilityChanged(aura::Window* window,
                                                      bool visible) {
  if (IsChildWindow(window))
    UpdateDimming(nullptr);
}

void ModalWindowController::OnWindowBoundsChanged(aura::Window* window,
                                                  const gfx::Rect& old_bounds,
                                                  const gfx::Rect& new_bounds) {
  if (window == modal_container_)
    UpdateDimmerWindowBounds();
}

void ModalWindowController::OnWindowDestroyed(aura::Window* window) {
  UpdateDimming(window);
}

bool ModalWindowController::IsChildWindow(aura::Window* child) const {
  return child->parent() == modal_container_ && child != dimmer_window_;
}

void ModalWindowController::UpdateDimmerWindowBounds() {
  gfx::Rect bounds(modal_container_->bounds().size());
  dimmer_window_->SetBounds(bounds);
}

void ModalWindowController::UpdateDimming(aura::Window* ignore) {
  if (!modal_container_ || !dimmer_window_)
    return;
  bool should_delete = true;
  for (aura::Window* window : modal_container_->children()) {
    if (window == dimmer_window_ || window == ignore)
      continue;
    should_delete = false;
    if (window->TargetVisibility()) {
      SetDimmed(true);
      return;
    }
  }
  SetDimmed(false);

  if (should_delete) {
    // Remove the container from root so that the container becomes
    // invisible, but don't delete it until next event execution
    // because the call stack may still have and use the pointer.
    modal_container_->RemoveObserver(this);

    // Hide the window before removing it, so the focus manager which will run
    // in RemoveChild handler can know that this container is no longer
    // available.
    modal_container_->Hide();

    modal_container_->parent()->RemoveChild(modal_container_);
    base::MessageLoopForUI::current()->DeleteSoon(FROM_HERE, modal_container_);
    modal_container_ = nullptr;
    dimmer_window_ = nullptr;
  }
}

void ModalWindowController::SetDimmed(bool dimmed) {
  const float kDimmedOpacity = 0.4f;

  if (!dimmer_window_ || dimmed_ == dimmed)
    return;
  dimmed_ = dimmed;

  const int kDimmAnimationDurationMs = 500;
  if (dimmed) {
    ui::ScopedLayerAnimationSettings settings(
        dimmer_window_->layer()->GetAnimator());
    settings.SetTransitionDuration(
        base::TimeDelta::FromMilliseconds(kDimmAnimationDurationMs));
    dimmer_window_->layer()->SetOpacity(kDimmedOpacity);
  } else {
    // ScopedHidingAnimationSettings will detach the animating and
    // recreate layers for the container so that animation can continue
    // even if the container is removed immediately.
    wm::ScopedHidingAnimationSettings settings(modal_container_);
    settings.layer_animation_settings()->SetTransitionDuration(
        base::TimeDelta::FromMilliseconds(kDimmAnimationDurationMs));
    modal_container_->layer()->SetOpacity(0.0f);
  }
}

}  // namespace athena