ash/magnifier/partial_magnification_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/magnifier/partial_magnification_controller.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/shell_window_ids.h"
   9 #include "ui/aura/root_window.h"
  10 #include "ui/views/corewm/compound_event_filter.h"
  11 #include "ui/aura/window.h"
  12 #include "ui/aura/window_property.h"
  13 #include "ui/gfx/screen.h"
  14 #include "ui/compositor/layer.h"
  15 #include "ui/views/layout/fill_layout.h"
  16 #include "ui/views/widget/widget.h"
  17 #include "ui/views/widget/widget_delegate.h"
  18
  19 namespace {
  20
  21 const float kMinPartialMagnifiedScaleThreshold = 1.1f;
  22
  23 // Number of pixels to make the border of the magnified area.
  24 const int kZoomInset = 16;
  25
  26 // Width of the magnified area.
  27 const int kMagnifierWidth = 200;
  28
  29 // Height of the magnified area.
  30 const int kMagnifierHeight = 200;
  31
  32 // Name of the magnifier window.
  33 const char kPartialMagniferWindowName[] = "PartialMagnifierWindow";
  34
  35 }  // namespace
  36
  37 namespace ash {
  38
  39 PartialMagnificationController::PartialMagnificationController()
  40     : is_on_zooming_(false),
  41       is_enabled_(false),
  42       scale_(kNonPartialMagnifiedScale),
  43       zoom_widget_(NULL) {
  44   Shell::GetInstance()->AddPreTargetHandler(this);
  45 }
  46
  47 PartialMagnificationController::~PartialMagnificationController() {
  48   CloseMagnifierWindow();
  49
  50   Shell::GetInstance()->RemovePreTargetHandler(this);
  51 }
  52
  53 void PartialMagnificationController::SetScale(float scale) {
  54   if (!is_enabled_)
  55     return;
  56
  57   scale_ = scale;
  58
  59   if (IsPartialMagnified()) {
  60     CreateMagnifierWindow();
  61   } else {
  62     CloseMagnifierWindow();
  63   }
  64 }
  65
  66 void PartialMagnificationController::SetEnabled(bool enabled) {
  67   if (enabled) {
  68     is_enabled_ = enabled;
  69     SetScale(kDefaultPartialMagnifiedScale);
  70   } else {
  71     SetScale(kNonPartialMagnifiedScale);
  72     is_enabled_ = enabled;
  73   }
  74 }
  75
  76 ////////////////////////////////////////////////////////////////////////////////
  77 // PartialMagnificationController: ui::EventHandler implementation
  78
  79 void PartialMagnificationController::OnMouseEvent(ui::MouseEvent* event) {
  80   if (IsPartialMagnified() && event->type() == ui::ET_MOUSE_MOVED) {
  81     aura::Window* target = static_cast<aura::Window*>(event->target());
  82     aura::RootWindow* current_root = target->GetRootWindow();
  83     // TODO(zork): Handle the case where the event is captured on a different
  84     // display, such as when a menu is opened.
  85     gfx::Rect root_bounds = current_root->bounds();
  86
  87     if (root_bounds.Contains(event->root_location())) {
  88       SwitchTargetRootWindow(current_root);
  89
  90       OnMouseMove(event->root_location());
  91     }
  92   }
  93 }
  94
  95 ////////////////////////////////////////////////////////////////////////////////
  96 // PartialMagnificationController: aura::WindowObserver implementation
  97
  98 void PartialMagnificationController::OnWindowDestroying(
  99     aura::Window* window) {
 100   CloseMagnifierWindow();
 101
 102   aura::RootWindow* new_root_window = GetCurrentRootWindow();
 103   if (new_root_window != window)
 104     SwitchTargetRootWindow(new_root_window);
 105 }
 106
 107 void PartialMagnificationController::OnWidgetClosing(
 108     views::Widget* widget) {
 109   DCHECK_EQ(widget, zoom_widget_);
 110   RemoveZoomWidgetObservers();
 111   zoom_widget_ = NULL;
 112 }
 113
 114 void PartialMagnificationController::OnMouseMove(
 115     const gfx::Point& location_in_root) {
 116   gfx::Point origin(location_in_root);
 117
 118   origin.Offset(-kMagnifierWidth / 2, -kMagnifierHeight / 2);
 119
 120   if (zoom_widget_) {
 121     zoom_widget_->SetBounds(gfx::Rect(origin.x(), origin.y(),
 122                                       kMagnifierWidth, kMagnifierHeight));
 123   }
 124 }
 125
 126 bool PartialMagnificationController::IsPartialMagnified() const {
 127   return scale_ >= kMinPartialMagnifiedScaleThreshold;
 128 }
 129
 130 void PartialMagnificationController::CreateMagnifierWindow() {
 131   if (zoom_widget_)
 132     return;
 133
 134   aura::RootWindow* root_window = GetCurrentRootWindow();
 135   if (!root_window)
 136     return;
 137
 138   root_window->AddObserver(this);
 139
 140   gfx::Point mouse(root_window->GetLastMouseLocationInRoot());
 141
 142   zoom_widget_ = new views::Widget;
 143   views::Widget::InitParams params(
 144       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 145   params.can_activate = false;
 146   params.accept_events = false;
 147   params.transparent = true;
 148   params.parent = root_window;
 149   zoom_widget_->Init(params);
 150   zoom_widget_->SetBounds(gfx::Rect(mouse.x() - kMagnifierWidth / 2,
 151                                     mouse.y() - kMagnifierHeight / 2,
 152                                     kMagnifierWidth, kMagnifierHeight));
 153   zoom_widget_->set_focus_on_creation(false);
 154   zoom_widget_->Show();
 155
 156   aura::Window* window = zoom_widget_->GetNativeView();
 157   window->SetName(kPartialMagniferWindowName);
 158
 159   zoom_widget_->GetNativeView()->layer()->SetBounds(
 160       gfx::Rect(0, 0,
 161                 kMagnifierWidth,
 162                 kMagnifierHeight));
 163   zoom_widget_->GetNativeView()->layer()->SetBackgroundZoom(
 164       (kMagnifierWidth - (kMagnifierWidth / scale_)) / 2,
 165       (kMagnifierHeight - (kMagnifierHeight / scale_)) / 2,
 166       scale_,
 167       kZoomInset);
 168
 169   zoom_widget_->AddObserver(this);
 170 }
 171
 172 void PartialMagnificationController::CloseMagnifierWindow() {
 173   if (zoom_widget_) {
 174     RemoveZoomWidgetObservers();
 175     zoom_widget_->Close();
 176     zoom_widget_ = NULL;
 177   }
 178 }
 179
 180 void PartialMagnificationController::RemoveZoomWidgetObservers() {
 181   DCHECK(zoom_widget_);
 182   zoom_widget_->RemoveObserver(this);
 183   aura::RootWindow* root_window =
 184       zoom_widget_->GetNativeView()->GetRootWindow();
 185   DCHECK(root_window);
 186   root_window->RemoveObserver(this);
 187 }
 188
 189 void PartialMagnificationController::SwitchTargetRootWindow(
 190     aura::RootWindow* new_root_window) {
 191   if (zoom_widget_ &&
 192       new_root_window == zoom_widget_->GetNativeView()->GetRootWindow())
 193     return;
 194
 195   CloseMagnifierWindow();
 196
 197   // Recreate the magnifier window by updating the scale factor.
 198   SetScale(GetScale());
 199 }
 200
 201 aura::RootWindow* PartialMagnificationController::GetCurrentRootWindow() {
 202   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 203   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
 204        iter != root_windows.end(); ++iter) {
 205     aura::RootWindow* root_window = *iter;
 206     if (root_window->ContainsPointInRoot(
 207             root_window->GetLastMouseLocationInRoot()))
 208       return root_window;
 209   }
 210   return NULL;
 211 }
 212
 213 }  // namespace ash