ash/wm_mode/wm_mode_controller.cc

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

#include "ash/wm_mode/wm_mode_controller.h"

#include <string_view>

#include "ash/capture_mode/capture_mode_util.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/public/cpp/window_finder.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/root_window_controller.h"
#include "ash/shell.h"
#include "ash/style/ash_color_id.h"
#include "ash/system/status_area_widget.h"
#include "ash/wm/desks/desk.h"
#include "ash/wm/desks/desks_animations.h"
#include "ash/wm/desks/desks_controller.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/overview/overview_item.h"
#include "ash/wm/overview/overview_session.h"
#include "ash/wm/window_dimmer.h"
#include "ash/wm_mode/pie_menu_view.h"
#include "ash/wm_mode/wm_mode_button_tray.h"
#include "base/auto_reset.h"
#include "base/check.h"
#include "base/check_op.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/aura/env.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/paint_recorder.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/color_palette.h"
#include "ui/wm/core/coordinate_conversion.h"

namespace ash {

namespace {

constexpr gfx::Size kPieMenuSize{300, 300};

WmModeController* g_instance = nullptr;

// The color used to highlight a selected window on hover or tap.
constexpr SkColor kSelectedWindowHighlightColor =
    SkColorSetA(gfx::kGoogleBlue800, 102);  // 40%

std::unique_ptr<WindowDimmer> CreateDimmerForRoot(aura::Window* root) {
  DCHECK(root);
  DCHECK(root->IsRootWindow());

  auto dimmer = std::make_unique<WindowDimmer>(
      root->GetChildById(kShellWindowId_MenuContainer), /*animate=*/false);
  dimmer->SetDimColor(kColorAshShieldAndBase40);
  dimmer->window()->Show();
  return dimmer;
}

gfx::Rect GetPieMenuScreenBounds(const gfx::Point& center_point_in_screen,
                                 aura::Window* current_root) {
  CHECK(current_root);

  gfx::Rect bounds(
      gfx::Point(center_point_in_screen.x() - kPieMenuSize.width() / 2,
                 center_point_in_screen.y() - kPieMenuSize.height() / 2),
      kPieMenuSize);
  bounds.AdjustToFit(current_root->GetBoundsInScreen());
  return bounds;
}

// Returns the bounds of the given `window` in screen coordinates, taking into
// account the transformed bounds of it when it's shown in overview.
gfx::Rect GetWindowTargetBoundsInScreen(aura::Window* window) {
  DCHECK(window);

  OverviewController* overview_controller = Shell::Get()->overview_controller();
  if (overview_controller->InOverviewSession()) {
    auto* overview_session = overview_controller->overview_session();
    if (auto* item = overview_session->GetOverviewItemForWindow(window)) {
      return gfx::ToRoundedRect(item->target_bounds());
    }
  }

  return window->GetBoundsInScreen();
}

// Returns the bounds in the root coordinates of the given `window` which should
// be used to highlight it when it's selected by WM Mode.
gfx::Rect GetWindowHighlightBounds(aura::Window* window) {
  gfx::Rect bounds = GetWindowTargetBoundsInScreen(window);
  wm::ConvertRectFromScreen(window->GetRootWindow(), &bounds);
  return bounds;
}

}  // namespace

WmModeController::WmModeController() {
  DCHECK(!g_instance);
  g_instance = this;
  Shell::Get()->AddShellObserver(this);
}

WmModeController::~WmModeController() {
  Shell::Get()->RemoveShellObserver(this);

  // If WM Mode is active, make sure to terminate it now, since it adds itself
  // as a pre-target handler to `aura::Env`, and there's only one instance
  // shared between all `ash_unittests` tests. Otherwise, old `WmModeController`
  // instances from previous tests will spill over to the next tests.
  if (is_active_)
    Toggle();

  DCHECK_EQ(g_instance, this);
  g_instance = nullptr;
}

// static
WmModeController* WmModeController::Get() {
  DCHECK(g_instance);
  return g_instance;
}

void WmModeController::Toggle() {
  is_active_ = !is_active_;

  UpdateTrayButtons();
  UpdateDimmers();

  if (is_active_) {
    aura::Env::GetInstance()->AddPreTargetHandler(
        this, ui::EventTarget::Priority::kSystem);
    CreateLayer();
    MaybeChangeRoot(capture_mode_util::GetPreferredRootWindow());
    BuildPieMenu();
    DesksController::Get()->AddObserver(this);
  } else {
    DesksController::Get()->RemoveObserver(this);
    SetSelectedWindow(nullptr);
    pie_menu_widget_.reset();
    pie_menu_view_ = nullptr;
    ReleaseLayer();
    DCHECK(!layer());
    current_root_ = nullptr;
    aura::Env::GetInstance()->RemovePreTargetHandler(this);
  }
}

void WmModeController::OnRootWindowAdded(aura::Window* root_window) {
  if (is_active_)
    dimmers_[root_window] = CreateDimmerForRoot(root_window);
}

void WmModeController::OnRootWindowWillShutdown(aura::Window* root_window) {
  dimmers_.erase(root_window);

  if (root_window == current_root_)
    MaybeChangeRoot(Shell::GetPrimaryRootWindow());
}

void WmModeController::OnMouseEvent(ui::MouseEvent* event) {
  OnLocatedEvent(event);
}

void WmModeController::OnTouchEvent(ui::TouchEvent* event) {
  OnLocatedEvent(event);
}

std::string_view WmModeController::GetLogContext() const {
  return "WmMode";
}

void WmModeController::OnPaintLayer(const ui::PaintContext& context) {
  ui::PaintRecorder recorder(context, layer()->size());
  gfx::Canvas* canvas = recorder.canvas();
  canvas->DrawColor(SK_ColorTRANSPARENT);

  if (selected_window_) {
    canvas->FillRect(GetWindowHighlightBounds(selected_window_),
                     kSelectedWindowHighlightColor);
  }
}

void WmModeController::OnWindowDestroying(aura::Window* window) {
  CHECK_EQ(window, selected_window_);
  SetSelectedWindow(nullptr);
}

void WmModeController::OnPieMenuButtonPressed(int button_id) {
  if (button_id >= kDeskButtonIdStart && button_id <= kDeskButtonIdEnd) {
    MoveSelectedWindowToDeskAtIndex(button_id - kDeskButtonIdStart);
  }
}

void WmModeController::OnDeskAdded(const Desk* desk, bool from_undo) {
  MaybeRebuildMoveToDeskSubMenu();
}

void WmModeController::OnDeskRemoved(const Desk* desk) {
  MaybeRebuildMoveToDeskSubMenu();

  // Desk removal can mean two desks have been merged, which may affect the
  // bounds of the selected window. Hence, we need to refresh the bounds of the
  // pie menu, and repaint the highlight.
  MaybeRefreshPieMenu();
  ScheduleRepaint();
}

void WmModeController::OnDeskReordered(int old_index, int new_index) {
  MaybeRebuildMoveToDeskSubMenu();
}

void WmModeController::OnDeskActivationChanged(const Desk* activated,
                                               const Desk* deactivated) {
  CHECK(is_active_);
  // The below toggle will turn off WM Mode in response to a desk change.
  Toggle();
}

void WmModeController::OnDeskNameChanged(const Desk* desk,
                                         const std::u16string& new_name) {
  auto* desks_controller = DesksController::Get();
  if (!pie_menu_view_) {
    return;
  }
  const int index = desks_controller->GetDeskIndex(desk);
  CHECK_GE(index, 0);
  pie_menu_view_->SetButtonLabelText(kDeskButtonIdStart + index, new_name);
}

void WmModeController::UpdateDimmers() {
  if (!is_active_) {
    dimmers_.clear();
    return;
  }

  for (aura::Window* root : Shell::GetAllRootWindows()) {
    dimmers_[root] = CreateDimmerForRoot(root);
  }
}

void WmModeController::UpdateTrayButtons() {
  for (auto* root_window_controller : Shell::GetAllRootWindowControllers()) {
    if (!root_window_controller->GetRootWindow()->is_destroying()) {
      root_window_controller->GetStatusAreaWidget()
          ->wm_mode_button_tray()
          ->UpdateButtonVisuals(is_active_);
    }
  }
}

void WmModeController::OnLocatedEvent(ui::LocatedEvent* event) {
  auto* target = static_cast<aura::Window*>(event->target());

  // Let events targeting the pie menu (if available) go through.
  if (IsTargetingPieMenu(target)) {
    return;
  }

  gfx::Point screen_location = event->root_location();
  wm::ConvertPointToScreen(target->GetRootWindow(), &screen_location);

  // Let events on the WM Mode tray button go through.
  auto* status_area_widget =
      StatusAreaWidget::ForWindow(target->GetRootWindow());
  if (status_area_widget->wm_mode_button_tray()->GetBoundsInScreen().Contains(
          screen_location)) {
    return;
  }

  event->StopPropagation();
  event->SetHandled();

  const bool is_release = event->type() == ui::ET_MOUSE_RELEASED ||
                          event->type() == ui::ET_TOUCH_RELEASED;
  if (!is_release) {
    return;
  }

  base::AutoReset<std::optional<gfx::Point>> reset_release_location(
      &last_release_event_screen_point_, screen_location);

  MaybeChangeRoot(capture_mode_util::GetPreferredRootWindow(screen_location));

  auto* top_most_window = GetTopMostWindowAtPoint(screen_location);
  SetSelectedWindow(top_most_window);
}

void WmModeController::CreateLayer() {
  DCHECK(is_active_);
  DCHECK(!layer());

  Reset(std::make_unique<ui::Layer>(ui::LAYER_TEXTURED));
  layer()->SetFillsBoundsOpaquely(false);
  layer()->set_delegate(this);
  layer()->SetName("WmModeLayer");
}

void WmModeController::MaybeChangeRoot(aura::Window* new_root) {
  DCHECK(is_active_);
  DCHECK(new_root);
  DCHECK(layer());

  if (new_root == current_root_)
    return;

  current_root_ = new_root;
  auto* parent = new_root->GetChildById(kShellWindowId_MenuContainer);
  parent->layer()->Add(layer());
  layer()->SetBounds(parent->bounds());

  SetSelectedWindow(nullptr);
}

void WmModeController::SetSelectedWindow(aura::Window* window) {
  if (selected_window_ != window) {
    if (selected_window_) {
      selected_window_->RemoveObserver(this);
    }

    selected_window_ = window;

    if (selected_window_) {
      selected_window_->AddObserver(this);
    }

    ScheduleRepaint();
  }

  MaybeRefreshPieMenu();
}

void WmModeController::ScheduleRepaint() {
  CHECK(layer());
  layer()->SchedulePaint(layer()->bounds());
}

void WmModeController::BuildPieMenu() {
  DCHECK(!pie_menu_widget_);
  DCHECK(current_root_);

  pie_menu_widget_ = std::make_unique<views::Widget>();
  views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
  params.opacity = views::Widget::InitParams::WindowOpacity::kTranslucent;
  params.parent = current_root_->GetChildById(kShellWindowId_MenuContainer);
  params.bounds = gfx::Rect(kPieMenuSize);
  params.name = "WmModePieMenuWidget";
  pie_menu_widget_->Init(std::move(params));
  pie_menu_view_ = pie_menu_widget_->SetContentsView(
      std::make_unique<PieMenuView>(/*delegate=*/this));

  // TODO(b/252558235): Localize once approved.
  pie_menu_view_->main_menu_container()->AddMenuButton(
      kSnapButtonId, u"Snap window", &kWmModeGestureSnapIcon);
  // TODO(b/296643766): Don't add this option for visible-on-all-desks windows.
  pie_menu_view_->main_menu_container()->AddMenuButton(
      kMoveToDeskButtonId, u"Move to desk", &kWmModeGestureMoveToDeskIcon);
  pie_menu_view_->main_menu_container()->AddMenuButton(
      kResizeButtonId, u"Resize window", &kWmModeGestureResizeIcon);

  MaybeRebuildMoveToDeskSubMenu();
}

void WmModeController::MaybeRebuildMoveToDeskSubMenu() {
  if (!pie_menu_view_) {
    return;
  }

  auto* move_to_desk_sub_menu =
      pie_menu_view_->GetOrAddSubMenuForButton(kMoveToDeskButtonId);
  move_to_desk_sub_menu->RemoveAllButtons();

  const auto& desks = DesksController::Get()->desks();
  const int desks_count = desks.size();
  for (int i = 0; i < desks_count; ++i) {
    const int desk_button_id = kDeskButtonIdStart + i;
    DCHECK_LE(desk_button_id, kDeskButtonIdEnd);
    auto* desk = desks[i].get();
    auto* button = move_to_desk_sub_menu->AddMenuButton(
        desk_button_id, desks[i]->name(), &kWmModeGestureMoveToDeskIcon);

    // The button that corresponds to the active desk is dimmed, since windows
    // in the current desk are already on it.
    button->SetEnabled(!desk->is_active());
  }

  pie_menu_view_->DeprecatedLayoutImmediately();
}

bool WmModeController::IsTargetingPieMenu(aura::Window* event_target) const {
  return pie_menu_widget_ && pie_menu_widget_->IsVisible() &&
         pie_menu_widget_->GetNativeWindow()->Contains(event_target);
}

aura::Window* WmModeController::GetTopMostWindowAtPoint(
    const gfx::Point& screen_location) const {
  // Ignore the pie menu if it's available.
  std::set<aura::Window*> windows_to_ignore;
  if (pie_menu_widget_) {
    windows_to_ignore.insert(pie_menu_widget_->GetNativeWindow());
  }
  auto* top_most_window =
      GetTopmostWindowAtPoint(screen_location, windows_to_ignore);
  // Only consider top-most desk windows (i.e. ignore always-on-top, PIP,
  // and Floated windows) for now.
  if (top_most_window &&
      !desks_util::GetDeskContainerForContext(top_most_window)) {
    top_most_window = nullptr;
  }
  return top_most_window;
}

void WmModeController::MaybeRefreshPieMenu() {
  if (!pie_menu_widget_) {
    return;
  }

  if (!selected_window_) {
    // Before we hide the pie menu, we must return to the main menu, so that the
    // next time we show it for a new selected window, it's already showing the
    // main menu.
    pie_menu_view_->ReturnToMainMenu();
    pie_menu_widget_->Hide();
    return;
  }

  pie_menu_widget_->SetBounds(GetPieMenuScreenBounds(
      last_release_event_screen_point_.value_or(
          GetWindowTargetBoundsInScreen(selected_window_).CenterPoint()),
      current_root_));
  pie_menu_widget_->Show();
}

void WmModeController::MoveSelectedWindowToDeskAtIndex(int index) {
  if (!selected_window_) {
    return;
  }

  auto* desks_controller = DesksController::Get();

  // The sideways move-window-to-desk animation is not allowed when overview is
  // active.
  auto* overview_controller = Shell::Get()->overview_controller();
  const bool in_overview_session = overview_controller->InOverviewSession();
  if (!in_overview_session) {
    const int cur_index = desks_controller->GetActiveDeskIndex();
    CHECK_NE(index, cur_index);
    const bool going_left = (index - cur_index) < 0;
    desks_animations::PerformWindowMoveToDeskAnimation(selected_window_,
                                                       going_left);
  }

  desks_controller->MoveWindowFromActiveDeskTo(
      selected_window_, desks_controller->desks()[index].get(),
      selected_window_->GetRootWindow(),
      DesksMoveWindowFromActiveDeskSource::kSendToDesk);

  SetSelectedWindow(nullptr);

  if (in_overview_session) {
    overview_controller->overview_session()->PositionWindows(/*animate=*/true);
  }
}

}  // namespace ash