ui/aura/root_window_host_win.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 "ui/aura/root_window_host_win.h"
   6
   7 #include <windows.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/message_loop/message_loop.h"
  12 #include "ui/aura/client/cursor_client.h"
  13 #include "ui/aura/root_window.h"
  14 #include "ui/base/cursor/cursor_loader_win.h"
  15 #include "ui/events/event.h"
  16 #include "ui/base/view_prop.h"
  17 #include "ui/gfx/display.h"
  18 #include "ui/gfx/insets.h"
  19 #include "ui/gfx/screen.h"
  20
  21 using std::max;
  22 using std::min;
  23
  24 namespace aura {
  25 namespace {
  26
  27 bool use_popup_as_root_window_for_test = false;
  28
  29 }  // namespace
  30
  31 // static
  32 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
  33   return new RootWindowHostWin(bounds);
  34 }
  35
  36 // static
  37 gfx::Size RootWindowHost::GetNativeScreenSize() {
  38   return gfx::Size(GetSystemMetrics(SM_CXSCREEN),
  39                    GetSystemMetrics(SM_CYSCREEN));
  40 }
  41
  42 RootWindowHostWin::RootWindowHostWin(const gfx::Rect& bounds)
  43     : fullscreen_(false),
  44       has_capture_(false),
  45       saved_window_style_(0),
  46       saved_window_ex_style_(0) {
  47   if (use_popup_as_root_window_for_test)
  48     set_window_style(WS_POPUP);
  49   Init(NULL, bounds);
  50   SetWindowText(hwnd(), L"aura::RootWindow!");
  51 }
  52
  53 RootWindowHostWin::~RootWindowHostWin() {
  54   DestroyWindow(hwnd());
  55 }
  56
  57 RootWindow* RootWindowHostWin::GetRootWindow() {
  58   return delegate_->AsRootWindow();
  59 }
  60
  61 gfx::AcceleratedWidget RootWindowHostWin::GetAcceleratedWidget() {
  62   return hwnd();
  63 }
  64
  65 void RootWindowHostWin::Show() {
  66   ShowWindow(hwnd(), SW_SHOWNORMAL);
  67 }
  68
  69 void RootWindowHostWin::Hide() {
  70   NOTIMPLEMENTED();
  71 }
  72
  73 void RootWindowHostWin::ToggleFullScreen() {
  74   gfx::Rect target_rect;
  75   if (!fullscreen_) {
  76     fullscreen_ = true;
  77     saved_window_style_ = GetWindowLong(hwnd(), GWL_STYLE);
  78     saved_window_ex_style_ = GetWindowLong(hwnd(), GWL_EXSTYLE);
  79     GetWindowRect(hwnd(), &saved_window_rect_);
  80     SetWindowLong(hwnd(), GWL_STYLE,
  81                   saved_window_style_ & ~(WS_CAPTION | WS_THICKFRAME));
  82     SetWindowLong(hwnd(), GWL_EXSTYLE,
  83                   saved_window_ex_style_ & ~(WS_EX_DLGMODALFRAME |
  84                       WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
  85
  86     MONITORINFO mi;
  87     mi.cbSize = sizeof(mi);
  88     GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTONEAREST), &mi);
  89     target_rect = gfx::Rect(mi.rcMonitor);
  90   } else {
  91     fullscreen_ = false;
  92     SetWindowLong(hwnd(), GWL_STYLE, saved_window_style_);
  93     SetWindowLong(hwnd(), GWL_EXSTYLE, saved_window_ex_style_);
  94     target_rect = gfx::Rect(saved_window_rect_);
  95   }
  96   SetWindowPos(hwnd(),
  97                NULL,
  98                target_rect.x(),
  99                target_rect.y(),
 100                target_rect.width(),
 101                target_rect.height(),
 102                SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
 103 }
 104
 105 gfx::Rect RootWindowHostWin::GetBounds() const {
 106   RECT r;
 107   GetClientRect(hwnd(), &r);
 108   return gfx::Rect(r);
 109 }
 110
 111 void RootWindowHostWin::SetBounds(const gfx::Rect& bounds) {
 112   if (fullscreen_) {
 113     saved_window_rect_.right = saved_window_rect_.left + bounds.width();
 114     saved_window_rect_.bottom = saved_window_rect_.top + bounds.height();
 115     return;
 116   }
 117   RECT window_rect;
 118   window_rect.left = bounds.x();
 119   window_rect.top = bounds.y();
 120   window_rect.right = bounds.right() ;
 121   window_rect.bottom = bounds.bottom();
 122   AdjustWindowRectEx(&window_rect,
 123                      GetWindowLong(hwnd(), GWL_STYLE),
 124                      FALSE,
 125                      GetWindowLong(hwnd(), GWL_EXSTYLE));
 126   SetWindowPos(
 127       hwnd(),
 128       NULL,
 129       window_rect.left,
 130       window_rect.top,
 131       window_rect.right - window_rect.left,
 132       window_rect.bottom - window_rect.top,
 133       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOREPOSITION);
 134
 135   // Explicity call OnHostResized when the scale has changed because
 136   // the window size may not have changed.
 137   float current_scale = delegate_->GetDeviceScaleFactor();
 138   float new_scale = gfx::Screen::GetScreenFor(
 139       delegate_->AsRootWindow()->window())->GetDisplayNearestWindow(
 140           delegate_->AsRootWindow()->window()).device_scale_factor();
 141   if (current_scale != new_scale)
 142     delegate_->OnHostResized(bounds.size());
 143 }
 144
 145 gfx::Insets RootWindowHostWin::GetInsets() const {
 146   return gfx::Insets();
 147 }
 148
 149 void RootWindowHostWin::SetInsets(const gfx::Insets& insets) {
 150 }
 151
 152 gfx::Point RootWindowHostWin::GetLocationOnNativeScreen() const {
 153   RECT r;
 154   GetClientRect(hwnd(), &r);
 155   return gfx::Point(r.left, r.top);
 156 }
 157
 158
 159 void RootWindowHostWin::SetCursor(gfx::NativeCursor native_cursor) {
 160   // Custom web cursors are handled directly.
 161   if (native_cursor == ui::kCursorCustom)
 162     return;
 163
 164   ui::CursorLoaderWin cursor_loader;
 165   cursor_loader.SetPlatformCursor(&native_cursor);
 166   ::SetCursor(native_cursor.platform());
 167 }
 168
 169 void RootWindowHostWin::SetCapture() {
 170   if (!has_capture_) {
 171     has_capture_ = true;
 172     ::SetCapture(hwnd());
 173   }
 174 }
 175
 176 void RootWindowHostWin::ReleaseCapture() {
 177   if (has_capture_) {
 178     has_capture_ = false;
 179     ::ReleaseCapture();
 180   }
 181 }
 182
 183 bool RootWindowHostWin::QueryMouseLocation(gfx::Point* location_return) {
 184   client::CursorClient* cursor_client =
 185       client::GetCursorClient(GetRootWindow()->window());
 186   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
 187     *location_return = gfx::Point(0, 0);
 188     return false;
 189   }
 190
 191   POINT pt;
 192   GetCursorPos(&pt);
 193   ScreenToClient(hwnd(), &pt);
 194   const gfx::Size size = GetBounds().size();
 195   *location_return =
 196       gfx::Point(max(0, min(size.width(), static_cast<int>(pt.x))),
 197                  max(0, min(size.height(), static_cast<int>(pt.y))));
 198   return (pt.x >= 0 && static_cast<int>(pt.x) < size.width() &&
 199           pt.y >= 0 && static_cast<int>(pt.y) < size.height());
 200 }
 201
 202 bool RootWindowHostWin::ConfineCursorToRootWindow() {
 203   RECT window_rect;
 204   GetWindowRect(hwnd(), &window_rect);
 205   return ClipCursor(&window_rect) != 0;
 206 }
 207
 208 void RootWindowHostWin::UnConfineCursor() {
 209   ClipCursor(NULL);
 210 }
 211
 212 void RootWindowHostWin::OnCursorVisibilityChanged(bool show) {
 213   NOTIMPLEMENTED();
 214 }
 215
 216 void RootWindowHostWin::MoveCursorTo(const gfx::Point& location) {
 217   // Deliberately not implemented.
 218 }
 219
 220 void RootWindowHostWin::PostNativeEvent(const base::NativeEvent& native_event) {
 221   ::PostMessage(
 222       hwnd(), native_event.message, native_event.wParam, native_event.lParam);
 223 }
 224
 225 void RootWindowHostWin::OnDeviceScaleFactorChanged(
 226     float device_scale_factor) {
 227   NOTIMPLEMENTED();
 228 }
 229
 230 void RootWindowHostWin::PrepareForShutdown() {
 231   NOTIMPLEMENTED();
 232 }
 233
 234 void RootWindowHostWin::OnClose() {
 235   // TODO: this obviously shouldn't be here.
 236   base::MessageLoopForUI::current()->Quit();
 237 }
 238
 239 LRESULT RootWindowHostWin::OnKeyEvent(UINT message,
 240                                       WPARAM w_param,
 241                                       LPARAM l_param) {
 242   MSG msg = { hwnd(), message, w_param, l_param };
 243   ui::KeyEvent keyev(msg, message == WM_CHAR);
 244   SetMsgHandled(delegate_->OnHostKeyEvent(&keyev));
 245   return 0;
 246 }
 247
 248 LRESULT RootWindowHostWin::OnMouseRange(UINT message,
 249                                         WPARAM w_param,
 250                                         LPARAM l_param) {
 251   MSG msg = { hwnd(), message, w_param, l_param, 0,
 252               { GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param) } };
 253   ui::MouseEvent event(msg);
 254   bool handled = false;
 255   if (!(event.flags() & ui::EF_IS_NON_CLIENT))
 256     handled = delegate_->OnHostMouseEvent(&event);
 257   SetMsgHandled(handled);
 258   return 0;
 259 }
 260
 261 LRESULT RootWindowHostWin::OnCaptureChanged(UINT message,
 262                                             WPARAM w_param,
 263                                             LPARAM l_param) {
 264   if (has_capture_) {
 265     has_capture_ = false;
 266     delegate_->OnHostLostWindowCapture();
 267   }
 268   return 0;
 269 }
 270
 271 LRESULT RootWindowHostWin::OnNCActivate(UINT message,
 272                                         WPARAM w_param,
 273                                         LPARAM l_param) {
 274   if (!!w_param)
 275     delegate_->OnHostActivated();
 276   return DefWindowProc(hwnd(), message, w_param, l_param);
 277 }
 278
 279 void RootWindowHostWin::OnMove(const CPoint& point) {
 280   if (delegate_)
 281     delegate_->OnHostMoved(gfx::Point(point.x, point.y));
 282 }
 283
 284 void RootWindowHostWin::OnPaint(HDC dc) {
 285   gfx::Rect damage_rect;
 286   RECT update_rect = {0};
 287   if (GetUpdateRect(hwnd(), &update_rect, FALSE))
 288     damage_rect = gfx::Rect(update_rect);
 289   delegate_->OnHostPaint(damage_rect);
 290   ValidateRect(hwnd(), NULL);
 291 }
 292
 293 void RootWindowHostWin::OnSize(UINT param, const CSize& size) {
 294   // Minimizing resizes the window to 0x0 which causes our layout to go all
 295   // screwy, so we just ignore it.
 296   if (delegate_ && param != SIZE_MINIMIZED)
 297     delegate_->OnHostResized(gfx::Size(size.cx, size.cy));
 298 }
 299
 300 namespace test {
 301
 302 // static
 303 void SetUsePopupAsRootWindowForTest(bool use) {
 304   use_popup_as_root_window_for_test = use;
 305 }
 306
 307 }  // namespace test
 308
 309 }  // namespace aura