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/views/win/hwnd_message_handler.h" 6 7 #include <dwmapi.h> 8 #include <oleacc.h> 9 #include <shellapi.h> 10 #include <wtsapi32.h> 11 #pragma comment(lib, "wtsapi32.lib") 12 13 #include "base/bind.h" 14 #include "base/debug/trace_event.h" 15 #include "base/win/win_util.h" 16 #include "base/win/windows_version.h" 17 #include "ui/base/touch/touch_enabled.h" 18 #include "ui/base/view_prop.h" 19 #include "ui/base/win/internal_constants.h" 20 #include "ui/base/win/lock_state.h" 21 #include "ui/base/win/mouse_wheel_util.h" 22 #include "ui/base/win/shell.h" 23 #include "ui/base/win/touch_input.h" 24 #include "ui/events/event.h" 25 #include "ui/events/event_utils.h" 26 #include "ui/events/keycodes/keyboard_code_conversion_win.h" 27 #include "ui/gfx/canvas.h" 28 #include "ui/gfx/canvas_skia_paint.h" 29 #include "ui/gfx/icon_util.h" 30 #include "ui/gfx/insets.h" 31 #include "ui/gfx/path.h" 32 #include "ui/gfx/path_win.h" 33 #include "ui/gfx/screen.h" 34 #include "ui/gfx/win/dpi.h" 35 #include "ui/gfx/win/hwnd_util.h" 36 #include "ui/native_theme/native_theme_win.h" 37 #include "ui/views/views_delegate.h" 38 #include "ui/views/widget/monitor_win.h" 39 #include "ui/views/widget/widget_hwnd_utils.h" 40 #include "ui/views/win/fullscreen_handler.h" 41 #include "ui/views/win/hwnd_message_handler_delegate.h" 42 #include "ui/views/win/scoped_fullscreen_visibility.h" 43 44 namespace views { 45 namespace { 46 47 // MoveLoopMouseWatcher is used to determine if the user canceled or completed a 48 // move. win32 doesn't appear to offer a way to determine the result of a move, 49 // so we install hooks to determine if we got a mouse up and assume the move 50 // completed. 51 class MoveLoopMouseWatcher { 52 public: 53 MoveLoopMouseWatcher(HWNDMessageHandler* host, bool hide_on_escape); 54 ~MoveLoopMouseWatcher(); 55 56 // Returns true if the mouse is up, or if we couldn't install the hook. 57 bool got_mouse_up() const { return got_mouse_up_; } 58 59 private: 60 // Instance that owns the hook. We only allow one instance to hook the mouse 61 // at a time. 62 static MoveLoopMouseWatcher* instance_; 63 64 // Key and mouse callbacks from the hook. 65 static LRESULT CALLBACK MouseHook(int n_code, WPARAM w_param, LPARAM l_param); 66 static LRESULT CALLBACK KeyHook(int n_code, WPARAM w_param, LPARAM l_param); 67 68 void Unhook(); 69 70 // HWNDMessageHandler that created us. 71 HWNDMessageHandler* host_; 72 73 // Should the window be hidden when escape is pressed? 74 const bool hide_on_escape_; 75 76 // Did we get a mouse up? 77 bool got_mouse_up_; 78 79 // Hook identifiers. 80 HHOOK mouse_hook_; 81 HHOOK key_hook_; 82 83 DISALLOW_COPY_AND_ASSIGN(MoveLoopMouseWatcher); 84 }; 85 86 // static 87 MoveLoopMouseWatcher* MoveLoopMouseWatcher::instance_ = NULL; 88 89 MoveLoopMouseWatcher::MoveLoopMouseWatcher(HWNDMessageHandler* host, 90 bool hide_on_escape) 91 : host_(host), 92 hide_on_escape_(hide_on_escape), 93 got_mouse_up_(false), 94 mouse_hook_(NULL), 95 key_hook_(NULL) { 96 // Only one instance can be active at a time. 97 if (instance_) 98 instance_->Unhook(); 99 100 mouse_hook_ = SetWindowsHookEx( 101 WH_MOUSE, &MouseHook, NULL, GetCurrentThreadId()); 102 if (mouse_hook_) { 103 instance_ = this; 104 // We don't care if setting the key hook succeeded. 105 key_hook_ = SetWindowsHookEx( 106 WH_KEYBOARD, &KeyHook, NULL, GetCurrentThreadId()); 107 } 108 if (instance_ != this) { 109 // Failed installation. Assume we got a mouse up in this case, otherwise 110 // we'll think all drags were canceled. 111 got_mouse_up_ = true; 112 } 113 } 114 115 MoveLoopMouseWatcher::~MoveLoopMouseWatcher() { 116 Unhook(); 117 } 118 119 void MoveLoopMouseWatcher::Unhook() { 120 if (instance_ != this) 121 return; 122 123 DCHECK(mouse_hook_); 124 UnhookWindowsHookEx(mouse_hook_); 125 if (key_hook_) 126 UnhookWindowsHookEx(key_hook_); 127 key_hook_ = NULL; 128 mouse_hook_ = NULL; 129 instance_ = NULL; 130 } 131 132 // static 133 LRESULT CALLBACK MoveLoopMouseWatcher::MouseHook(int n_code, 134 WPARAM w_param, 135 LPARAM l_param) { 136 DCHECK(instance_); 137 if (n_code == HC_ACTION && w_param == WM_LBUTTONUP) 138 instance_->got_mouse_up_ = true; 139 return CallNextHookEx(instance_->mouse_hook_, n_code, w_param, l_param); 140 } 141 142 // static 143 LRESULT CALLBACK MoveLoopMouseWatcher::KeyHook(int n_code, 144 WPARAM w_param, 145 LPARAM l_param) { 146 if (n_code == HC_ACTION && w_param == VK_ESCAPE) { 147 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { 148 int value = TRUE; 149 HRESULT result = DwmSetWindowAttribute( 150 instance_->host_->hwnd(), 151 DWMWA_TRANSITIONS_FORCEDISABLED, 152 &value, 153 sizeof(value)); 154 } 155 if (instance_->hide_on_escape_) 156 instance_->host_->Hide(); 157 } 158 return CallNextHookEx(instance_->key_hook_, n_code, w_param, l_param); 159 } 160 161 // Called from OnNCActivate. 162 BOOL CALLBACK EnumChildWindowsForRedraw(HWND hwnd, LPARAM lparam) { 163 DWORD process_id; 164 GetWindowThreadProcessId(hwnd, &process_id); 165 int flags = RDW_INVALIDATE | RDW_NOCHILDREN | RDW_FRAME; 166 if (process_id == GetCurrentProcessId()) 167 flags |= RDW_UPDATENOW; 168 RedrawWindow(hwnd, NULL, NULL, flags); 169 return TRUE; 170 } 171 172 bool GetMonitorAndRects(const RECT& rect, 173 HMONITOR* monitor, 174 gfx::Rect* monitor_rect, 175 gfx::Rect* work_area) { 176 DCHECK(monitor); 177 DCHECK(monitor_rect); 178 DCHECK(work_area); 179 *monitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONULL); 180 if (!*monitor) 181 return false; 182 MONITORINFO monitor_info = { 0 }; 183 monitor_info.cbSize = sizeof(monitor_info); 184 GetMonitorInfo(*monitor, &monitor_info); 185 *monitor_rect = gfx::Rect(monitor_info.rcMonitor); 186 *work_area = gfx::Rect(monitor_info.rcWork); 187 return true; 188 } 189 190 struct FindOwnedWindowsData { 191 HWND window; 192 std::vector<Widget*> owned_widgets; 193 }; 194 195 // Enables or disables the menu item for the specified command and menu. 196 void EnableMenuItemByCommand(HMENU menu, UINT command, bool enabled) { 197 UINT flags = MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED); 198 EnableMenuItem(menu, command, flags); 199 } 200 201 // Callback used to notify child windows that the top level window received a 202 // DWMCompositionChanged message. 203 BOOL CALLBACK SendDwmCompositionChanged(HWND window, LPARAM param) { 204 SendMessage(window, WM_DWMCOMPOSITIONCHANGED, 0, 0); 205 return TRUE; 206 } 207 208 // See comments in OnNCPaint() for details of this struct. 209 struct ClipState { 210 // The window being painted. 211 HWND parent; 212 213 // DC painting to. 214 HDC dc; 215 216 // Origin of the window in terms of the screen. 217 int x; 218 int y; 219 }; 220 221 // See comments in OnNCPaint() for details of this function. 222 static BOOL CALLBACK ClipDCToChild(HWND window, LPARAM param) { 223 ClipState* clip_state = reinterpret_cast<ClipState*>(param); 224 if (GetParent(window) == clip_state->parent && IsWindowVisible(window)) { 225 RECT bounds; 226 GetWindowRect(window, &bounds); 227 ExcludeClipRect(clip_state->dc, 228 bounds.left - clip_state->x, 229 bounds.top - clip_state->y, 230 bounds.right - clip_state->x, 231 bounds.bottom - clip_state->y); 232 } 233 return TRUE; 234 } 235 236 // The thickness of an auto-hide taskbar in pixels. 237 const int kAutoHideTaskbarThicknessPx = 2; 238 239 bool IsTopLevelWindow(HWND window) { 240 long style = ::GetWindowLong(window, GWL_STYLE); 241 if (!(style & WS_CHILD)) 242 return true; 243 HWND parent = ::GetParent(window); 244 return !parent || (parent == ::GetDesktopWindow()); 245 } 246 247 void AddScrollStylesToWindow(HWND window) { 248 if (::IsWindow(window)) { 249 long current_style = ::GetWindowLong(window, GWL_STYLE); 250 ::SetWindowLong(window, GWL_STYLE, 251 current_style | WS_VSCROLL | WS_HSCROLL); 252 } 253 } 254 255 const int kTouchDownContextResetTimeout = 500; 256 257 // Windows does not flag synthesized mouse messages from touch in all cases. 258 // This causes us grief as we don't want to process touch and mouse messages 259 // concurrently. Hack as per msdn is to check if the time difference between 260 // the touch message and the mouse move is within 500 ms and at the same 261 // location as the cursor. 262 const int kSynthesizedMouseTouchMessagesTimeDifference = 500; 263 264 } // namespace 265 266 // A scoping class that prevents a window from being able to redraw in response 267 // to invalidations that may occur within it for the lifetime of the object. 268 // 269 // Why would we want such a thing? Well, it turns out Windows has some 270 // "unorthodox" behavior when it comes to painting its non-client areas. 271 // Occasionally, Windows will paint portions of the default non-client area 272 // right over the top of the custom frame. This is not simply fixed by handling 273 // WM_NCPAINT/WM_PAINT, with some investigation it turns out that this 274 // rendering is being done *inside* the default implementation of some message 275 // handlers and functions: 276 // . WM_SETTEXT 277 // . WM_SETICON 278 // . WM_NCLBUTTONDOWN 279 // . EnableMenuItem, called from our WM_INITMENU handler 280 // The solution is to handle these messages and call DefWindowProc ourselves, 281 // but prevent the window from being able to update itself for the duration of 282 // the call. We do this with this class, which automatically calls its 283 // associated Window's lock and unlock functions as it is created and destroyed. 284 // See documentation in those methods for the technique used. 285 // 286 // The lock only has an effect if the window was visible upon lock creation, as 287 // it doesn't guard against direct visiblility changes, and multiple locks may 288 // exist simultaneously to handle certain nested Windows messages. 289 // 290 // IMPORTANT: Do not use this scoping object for large scopes or periods of 291 // time! IT WILL PREVENT THE WINDOW FROM BEING REDRAWN! (duh). 292 // 293 // I would love to hear Raymond Chen's explanation for all this. And maybe a 294 // list of other messages that this applies to ;-) 295 class HWNDMessageHandler::ScopedRedrawLock { 296 public: 297 explicit ScopedRedrawLock(HWNDMessageHandler* owner) 298 : owner_(owner), 299 hwnd_(owner_->hwnd()), 300 was_visible_(owner_->IsVisible()), 301 cancel_unlock_(false), 302 force_(!(GetWindowLong(hwnd_, GWL_STYLE) & WS_CAPTION)) { 303 if (was_visible_ && ::IsWindow(hwnd_)) 304 owner_->LockUpdates(force_); 305 } 306 307 ~ScopedRedrawLock() { 308 if (!cancel_unlock_ && was_visible_ && ::IsWindow(hwnd_)) 309 owner_->UnlockUpdates(force_); 310 } 311 312 // Cancel the unlock operation, call this if the Widget is being destroyed. 313 void CancelUnlockOperation() { cancel_unlock_ = true; } 314 315 private: 316 // The owner having its style changed. 317 HWNDMessageHandler* owner_; 318 // The owner's HWND, cached to avoid action after window destruction. 319 HWND hwnd_; 320 // Records the HWND visibility at the time of creation. 321 bool was_visible_; 322 // A flag indicating that the unlock operation was canceled. 323 bool cancel_unlock_; 324 // If true, perform the redraw lock regardless of Aero state. 325 bool force_; 326 327 DISALLOW_COPY_AND_ASSIGN(ScopedRedrawLock); 328 }; 329 330 //////////////////////////////////////////////////////////////////////////////// 331 // HWNDMessageHandler, public: 332 333 long HWNDMessageHandler::last_touch_message_time_ = 0; 334 335 HWNDMessageHandler::HWNDMessageHandler(HWNDMessageHandlerDelegate* delegate) 336 : delegate_(delegate), 337 fullscreen_handler_(new FullscreenHandler), 338 weak_factory_(this), 339 waiting_for_close_now_(false), 340 remove_standard_frame_(false), 341 use_system_default_icon_(false), 342 restored_enabled_(false), 343 current_cursor_(NULL), 344 previous_cursor_(NULL), 345 active_mouse_tracking_flags_(0), 346 is_right_mouse_pressed_on_caption_(false), 347 lock_updates_count_(0), 348 ignore_window_pos_changes_(false), 349 last_monitor_(NULL), 350 use_layered_buffer_(false), 351 layered_alpha_(255), 352 waiting_for_redraw_layered_window_contents_(false), 353 is_first_nccalc_(true), 354 menu_depth_(0), 355 autohide_factory_(this), 356 id_generator_(0), 357 needs_scroll_styles_(false), 358 in_size_loop_(false), 359 touch_down_contexts_(0), 360 last_mouse_hwheel_time_(0), 361 msg_handled_(FALSE), 362 dwm_transition_desired_(false) { 363 } 364 365 HWNDMessageHandler::~HWNDMessageHandler() { 366 delegate_ = NULL; 367 // Prevent calls back into this class via WNDPROC now that we've been 368 // destroyed. 369 ClearUserData(); 370 } 371 372 void HWNDMessageHandler::Init(HWND parent, const gfx::Rect& bounds) { 373 TRACE_EVENT0("views", "HWNDMessageHandler::Init"); 374 GetMonitorAndRects(bounds.ToRECT(), &last_monitor_, &last_monitor_rect_, 375 &last_work_area_); 376 377 // Create the window. 378 WindowImpl::Init(parent, bounds); 379 // TODO(ananta) 380 // Remove the scrolling hack code once we have scrolling working well. 381 #if defined(ENABLE_SCROLL_HACK) 382 // Certain trackpad drivers on Windows have bugs where in they don't generate 383 // WM_MOUSEWHEEL messages for the trackpoint and trackpad scrolling gestures 384 // unless there is an entry for Chrome with the class name of the Window. 385 // These drivers check if the window under the trackpoint has the WS_VSCROLL/ 386 // WS_HSCROLL style and if yes they generate the legacy WM_VSCROLL/WM_HSCROLL 387 // messages. We add these styles to ensure that trackpad/trackpoint scrolling 388 // work. 389 // TODO(ananta) 390 // Look into moving the WS_VSCROLL and WS_HSCROLL style setting logic to the 391 // CalculateWindowStylesFromInitParams function. Doing it there seems to 392 // cause some interactive tests to fail. Investigation needed. 393 if (IsTopLevelWindow(hwnd())) { 394 long current_style = ::GetWindowLong(hwnd(), GWL_STYLE); 395 if (!(current_style & WS_POPUP)) { 396 AddScrollStylesToWindow(hwnd()); 397 needs_scroll_styles_ = true; 398 } 399 } 400 #endif 401 402 prop_window_target_.reset(new ui::ViewProp(hwnd(), 403 ui::WindowEventTarget::kWin32InputEventTarget, 404 static_cast<ui::WindowEventTarget*>(this))); 405 } 406 407 void HWNDMessageHandler::InitModalType(ui::ModalType modal_type) { 408 if (modal_type == ui::MODAL_TYPE_NONE) 409 return; 410 // We implement modality by crawling up the hierarchy of windows starting 411 // at the owner, disabling all of them so that they don't receive input 412 // messages. 413 HWND start = ::GetWindow(hwnd(), GW_OWNER); 414 while (start) { 415 ::EnableWindow(start, FALSE); 416 start = ::GetParent(start); 417 } 418 } 419 420 void HWNDMessageHandler::Close() { 421 if (!IsWindow(hwnd())) 422 return; // No need to do anything. 423 424 // Let's hide ourselves right away. 425 Hide(); 426 427 // Modal dialog windows disable their owner windows; re-enable them now so 428 // they can activate as foreground windows upon this window's destruction. 429 RestoreEnabledIfNecessary(); 430 431 if (!waiting_for_close_now_) { 432 // And we delay the close so that if we are called from an ATL callback, 433 // we don't destroy the window before the callback returned (as the caller 434 // may delete ourselves on destroy and the ATL callback would still 435 // dereference us when the callback returns). 436 waiting_for_close_now_ = true; 437 base::MessageLoop::current()->PostTask( 438 FROM_HERE, 439 base::Bind(&HWNDMessageHandler::CloseNow, weak_factory_.GetWeakPtr())); 440 } 441 } 442 443 void HWNDMessageHandler::CloseNow() { 444 // We may already have been destroyed if the selection resulted in a tab 445 // switch which will have reactivated the browser window and closed us, so 446 // we need to check to see if we're still a window before trying to destroy 447 // ourself. 448 waiting_for_close_now_ = false; 449 if (IsWindow(hwnd())) 450 DestroyWindow(hwnd()); 451 } 452 453 gfx::Rect HWNDMessageHandler::GetWindowBoundsInScreen() const { 454 RECT r; 455 GetWindowRect(hwnd(), &r); 456 return gfx::Rect(r); 457 } 458 459 gfx::Rect HWNDMessageHandler::GetClientAreaBoundsInScreen() const { 460 RECT r; 461 GetClientRect(hwnd(), &r); 462 POINT point = { r.left, r.top }; 463 ClientToScreen(hwnd(), &point); 464 return gfx::Rect(point.x, point.y, r.right - r.left, r.bottom - r.top); 465 } 466 467 gfx::Rect HWNDMessageHandler::GetRestoredBounds() const { 468 // If we're in fullscreen mode, we've changed the normal bounds to the monitor 469 // rect, so return the saved bounds instead. 470 if (fullscreen_handler_->fullscreen()) 471 return fullscreen_handler_->GetRestoreBounds(); 472 473 gfx::Rect bounds; 474 GetWindowPlacement(&bounds, NULL); 475 return bounds; 476 } 477 478 gfx::Rect HWNDMessageHandler::GetClientAreaBounds() const { 479 if (IsMinimized()) 480 return gfx::Rect(); 481 if (delegate_->WidgetSizeIsClientSize()) 482 return GetClientAreaBoundsInScreen(); 483 return GetWindowBoundsInScreen(); 484 } 485 486 void HWNDMessageHandler::GetWindowPlacement( 487 gfx::Rect* bounds, 488 ui::WindowShowState* show_state) const { 489 WINDOWPLACEMENT wp; 490 wp.length = sizeof(wp); 491 const bool succeeded = !!::GetWindowPlacement(hwnd(), &wp); 492 DCHECK(succeeded); 493 494 if (bounds != NULL) { 495 if (wp.showCmd == SW_SHOWNORMAL) { 496 // GetWindowPlacement can return misleading position if a normalized 497 // window was resized using Aero Snap feature (see comment 9 in bug 498 // 36421). As a workaround, using GetWindowRect for normalized windows. 499 const bool succeeded = GetWindowRect(hwnd(), &wp.rcNormalPosition) != 0; 500 DCHECK(succeeded); 501 502 *bounds = gfx::Rect(wp.rcNormalPosition); 503 } else { 504 MONITORINFO mi; 505 mi.cbSize = sizeof(mi); 506 const bool succeeded = GetMonitorInfo( 507 MonitorFromWindow(hwnd(), MONITOR_DEFAULTTONEAREST), &mi) != 0; 508 DCHECK(succeeded); 509 510 *bounds = gfx::Rect(wp.rcNormalPosition); 511 // Convert normal position from workarea coordinates to screen 512 // coordinates. 513 bounds->Offset(mi.rcWork.left - mi.rcMonitor.left, 514 mi.rcWork.top - mi.rcMonitor.top); 515 } 516 } 517 518 if (show_state) { 519 if (wp.showCmd == SW_SHOWMAXIMIZED) 520 *show_state = ui::SHOW_STATE_MAXIMIZED; 521 else if (wp.showCmd == SW_SHOWMINIMIZED) 522 *show_state = ui::SHOW_STATE_MINIMIZED; 523 else 524 *show_state = ui::SHOW_STATE_NORMAL; 525 } 526 } 527 528 void HWNDMessageHandler::SetBounds(const gfx::Rect& bounds_in_pixels, 529 bool force_size_changed) { 530 LONG style = GetWindowLong(hwnd(), GWL_STYLE); 531 if (style & WS_MAXIMIZE) 532 SetWindowLong(hwnd(), GWL_STYLE, style & ~WS_MAXIMIZE); 533 534 gfx::Size old_size = GetClientAreaBounds().size(); 535 SetWindowPos(hwnd(), NULL, bounds_in_pixels.x(), bounds_in_pixels.y(), 536 bounds_in_pixels.width(), bounds_in_pixels.height(), 537 SWP_NOACTIVATE | SWP_NOZORDER); 538 539 // If HWND size is not changed, we will not receive standard size change 540 // notifications. If |force_size_changed| is |true|, we should pretend size is 541 // changed. 542 if (old_size == bounds_in_pixels.size() && force_size_changed) { 543 delegate_->HandleClientSizeChanged(GetClientAreaBounds().size()); 544 ResetWindowRegion(false, true); 545 } 546 } 547 548 void HWNDMessageHandler::SetSize(const gfx::Size& size) { 549 SetWindowPos(hwnd(), NULL, 0, 0, size.width(), size.height(), 550 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE); 551 } 552 553 void HWNDMessageHandler::CenterWindow(const gfx::Size& size) { 554 HWND parent = GetParent(hwnd()); 555 if (!IsWindow(hwnd())) 556 parent = ::GetWindow(hwnd(), GW_OWNER); 557 gfx::CenterAndSizeWindow(parent, hwnd(), size); 558 } 559 560 void HWNDMessageHandler::SetRegion(HRGN region) { 561 custom_window_region_.Set(region); 562 ResetWindowRegion(false, true); 563 UpdateDwmNcRenderingPolicy(); 564 } 565 566 void HWNDMessageHandler::StackAbove(HWND other_hwnd) { 567 SetWindowPos(hwnd(), other_hwnd, 0, 0, 0, 0, 568 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); 569 } 570 571 void HWNDMessageHandler::StackAtTop() { 572 SetWindowPos(hwnd(), HWND_TOP, 0, 0, 0, 0, 573 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); 574 } 575 576 void HWNDMessageHandler::Show() { 577 if (IsWindow(hwnd())) { 578 if (!(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_TRANSPARENT) && 579 !(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_NOACTIVATE)) { 580 ShowWindowWithState(ui::SHOW_STATE_NORMAL); 581 } else { 582 ShowWindowWithState(ui::SHOW_STATE_INACTIVE); 583 } 584 } 585 } 586 587 void HWNDMessageHandler::ShowWindowWithState(ui::WindowShowState show_state) { 588 TRACE_EVENT0("views", "HWNDMessageHandler::ShowWindowWithState"); 589 DWORD native_show_state; 590 switch (show_state) { 591 case ui::SHOW_STATE_INACTIVE: 592 native_show_state = SW_SHOWNOACTIVATE; 593 break; 594 case ui::SHOW_STATE_MAXIMIZED: 595 native_show_state = SW_SHOWMAXIMIZED; 596 break; 597 case ui::SHOW_STATE_MINIMIZED: 598 native_show_state = SW_SHOWMINIMIZED; 599 break; 600 default: 601 native_show_state = delegate_->GetInitialShowState(); 602 break; 603 } 604 605 ShowWindow(hwnd(), native_show_state); 606 // When launched from certain programs like bash and Windows Live Messenger, 607 // show_state is set to SW_HIDE, so we need to correct that condition. We 608 // don't just change show_state to SW_SHOWNORMAL because MSDN says we must 609 // always first call ShowWindow with the specified value from STARTUPINFO, 610 // otherwise all future ShowWindow calls will be ignored (!!#@@#!). Instead, 611 // we call ShowWindow again in this case. 612 if (native_show_state == SW_HIDE) { 613 native_show_state = SW_SHOWNORMAL; 614 ShowWindow(hwnd(), native_show_state); 615 } 616 617 // We need to explicitly activate the window if we've been shown with a state 618 // that should activate, because if we're opened from a desktop shortcut while 619 // an existing window is already running it doesn't seem to be enough to use 620 // one of these flags to activate the window. 621 if (native_show_state == SW_SHOWNORMAL || 622 native_show_state == SW_SHOWMAXIMIZED) 623 Activate(); 624 625 if (!delegate_->HandleInitialFocus(show_state)) 626 SetInitialFocus(); 627 } 628 629 void HWNDMessageHandler::ShowMaximizedWithBounds(const gfx::Rect& bounds) { 630 WINDOWPLACEMENT placement = { 0 }; 631 placement.length = sizeof(WINDOWPLACEMENT); 632 placement.showCmd = SW_SHOWMAXIMIZED; 633 placement.rcNormalPosition = bounds.ToRECT(); 634 SetWindowPlacement(hwnd(), &placement); 635 } 636 637 void HWNDMessageHandler::Hide() { 638 if (IsWindow(hwnd())) { 639 // NOTE: Be careful not to activate any windows here (for example, calling 640 // ShowWindow(SW_HIDE) will automatically activate another window). This 641 // code can be called while a window is being deactivated, and activating 642 // another window will screw up the activation that is already in progress. 643 SetWindowPos(hwnd(), NULL, 0, 0, 0, 0, 644 SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOMOVE | 645 SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER); 646 } 647 } 648 649 void HWNDMessageHandler::Maximize() { 650 ExecuteSystemMenuCommand(SC_MAXIMIZE); 651 } 652 653 void HWNDMessageHandler::Minimize() { 654 ExecuteSystemMenuCommand(SC_MINIMIZE); 655 delegate_->HandleNativeBlur(NULL); 656 } 657 658 void HWNDMessageHandler::Restore() { 659 ExecuteSystemMenuCommand(SC_RESTORE); 660 } 661 662 void HWNDMessageHandler::Activate() { 663 if (IsMinimized()) 664 ::ShowWindow(hwnd(), SW_RESTORE); 665 ::SetWindowPos(hwnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE); 666 SetForegroundWindow(hwnd()); 667 } 668 669 void HWNDMessageHandler::Deactivate() { 670 HWND next_hwnd = ::GetNextWindow(hwnd(), GW_HWNDNEXT); 671 while (next_hwnd) { 672 if (::IsWindowVisible(next_hwnd)) { 673 ::SetForegroundWindow(next_hwnd); 674 return; 675 } 676 next_hwnd = ::GetNextWindow(next_hwnd, GW_HWNDNEXT); 677 } 678 } 679 680 void HWNDMessageHandler::SetAlwaysOnTop(bool on_top) { 681 ::SetWindowPos(hwnd(), on_top ? HWND_TOPMOST : HWND_NOTOPMOST, 682 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); 683 } 684 685 bool HWNDMessageHandler::IsVisible() const { 686 return !!::IsWindowVisible(hwnd()); 687 } 688 689 bool HWNDMessageHandler::IsActive() const { 690 return GetActiveWindow() == hwnd(); 691 } 692 693 bool HWNDMessageHandler::IsMinimized() const { 694 return !!::IsIconic(hwnd()); 695 } 696 697 bool HWNDMessageHandler::IsMaximized() const { 698 return !!::IsZoomed(hwnd()); 699 } 700 701 bool HWNDMessageHandler::IsAlwaysOnTop() const { 702 return (GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_TOPMOST) != 0; 703 } 704 705 bool HWNDMessageHandler::RunMoveLoop(const gfx::Vector2d& drag_offset, 706 bool hide_on_escape) { 707 ReleaseCapture(); 708 MoveLoopMouseWatcher watcher(this, hide_on_escape); 709 // In Aura, we handle touch events asynchronously. So we need to allow nested 710 // tasks while in windows move loop. 711 base::MessageLoop::ScopedNestableTaskAllower allow_nested( 712 base::MessageLoop::current()); 713 714 SendMessage(hwnd(), WM_SYSCOMMAND, SC_MOVE | 0x0002, GetMessagePos()); 715 // Windows doesn't appear to offer a way to determine whether the user 716 // canceled the move or not. We assume if the user released the mouse it was 717 // successful. 718 return watcher.got_mouse_up(); 719 } 720 721 void HWNDMessageHandler::EndMoveLoop() { 722 SendMessage(hwnd(), WM_CANCELMODE, 0, 0); 723 } 724 725 void HWNDMessageHandler::SendFrameChanged() { 726 SetWindowPos(hwnd(), NULL, 0, 0, 0, 0, 727 SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOCOPYBITS | 728 SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREPOSITION | 729 SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER); 730 } 731 732 void HWNDMessageHandler::FlashFrame(bool flash) { 733 FLASHWINFO fwi; 734 fwi.cbSize = sizeof(fwi); 735 fwi.hwnd = hwnd(); 736 if (flash) { 737 fwi.dwFlags = FLASHW_ALL; 738 fwi.uCount = 4; 739 fwi.dwTimeout = 0; 740 } else { 741 fwi.dwFlags = FLASHW_STOP; 742 } 743 FlashWindowEx(&fwi); 744 } 745 746 void HWNDMessageHandler::ClearNativeFocus() { 747 ::SetFocus(hwnd()); 748 } 749 750 void HWNDMessageHandler::SetCapture() { 751 DCHECK(!HasCapture()); 752 ::SetCapture(hwnd()); 753 } 754 755 void HWNDMessageHandler::ReleaseCapture() { 756 if (HasCapture()) 757 ::ReleaseCapture(); 758 } 759 760 bool HWNDMessageHandler::HasCapture() const { 761 return ::GetCapture() == hwnd(); 762 } 763 764 void HWNDMessageHandler::SetVisibilityChangedAnimationsEnabled(bool enabled) { 765 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { 766 int dwm_value = enabled ? FALSE : TRUE; 767 DwmSetWindowAttribute( 768 hwnd(), DWMWA_TRANSITIONS_FORCEDISABLED, &dwm_value, sizeof(dwm_value)); 769 } 770 } 771 772 bool HWNDMessageHandler::SetTitle(const base::string16& title) { 773 base::string16 current_title; 774 size_t len_with_null = GetWindowTextLength(hwnd()) + 1; 775 if (len_with_null == 1 && title.length() == 0) 776 return false; 777 if (len_with_null - 1 == title.length() && 778 GetWindowText( 779 hwnd(), WriteInto(¤t_title, len_with_null), len_with_null) && 780 current_title == title) 781 return false; 782 SetWindowText(hwnd(), title.c_str()); 783 return true; 784 } 785 786 void HWNDMessageHandler::SetCursor(HCURSOR cursor) { 787 if (cursor) { 788 previous_cursor_ = ::SetCursor(cursor); 789 current_cursor_ = cursor; 790 } else if (previous_cursor_) { 791 ::SetCursor(previous_cursor_); 792 previous_cursor_ = NULL; 793 } 794 } 795 796 void HWNDMessageHandler::FrameTypeChanged() { 797 if (base::win::GetVersion() < base::win::VERSION_VISTA) { 798 // Don't redraw the window here, because we invalidate the window later. 799 ResetWindowRegion(true, false); 800 // The non-client view needs to update too. 801 delegate_->HandleFrameChanged(); 802 InvalidateRect(hwnd(), NULL, FALSE); 803 } else { 804 if (!custom_window_region_ && !delegate_->IsUsingCustomFrame()) 805 dwm_transition_desired_ = true; 806 if (!dwm_transition_desired_ || !fullscreen_handler_->fullscreen()) 807 PerformDwmTransition(); 808 } 809 } 810 811 void HWNDMessageHandler::SchedulePaintInRect(const gfx::Rect& rect) { 812 if (use_layered_buffer_) { 813 // We must update the back-buffer immediately, since Windows' handling of 814 // invalid rects is somewhat mysterious. 815 invalid_rect_.Union(rect); 816 817 // In some situations, such as drag and drop, when Windows itself runs a 818 // nested message loop our message loop appears to be starved and we don't 819 // receive calls to DidProcessMessage(). This only seems to affect layered 820 // windows, so we schedule a redraw manually using a task, since those never 821 // seem to be starved. Also, wtf. 822 if (!waiting_for_redraw_layered_window_contents_) { 823 waiting_for_redraw_layered_window_contents_ = true; 824 base::MessageLoop::current()->PostTask( 825 FROM_HERE, 826 base::Bind(&HWNDMessageHandler::RedrawLayeredWindowContents, 827 weak_factory_.GetWeakPtr())); 828 } 829 } else { 830 // InvalidateRect() expects client coordinates. 831 RECT r = rect.ToRECT(); 832 InvalidateRect(hwnd(), &r, FALSE); 833 } 834 } 835 836 void HWNDMessageHandler::SetOpacity(BYTE opacity) { 837 layered_alpha_ = opacity; 838 } 839 840 void HWNDMessageHandler::SetWindowIcons(const gfx::ImageSkia& window_icon, 841 const gfx::ImageSkia& app_icon) { 842 if (!window_icon.isNull()) { 843 HICON windows_icon = IconUtil::CreateHICONFromSkBitmap( 844 *window_icon.bitmap()); 845 // We need to make sure to destroy the previous icon, otherwise we'll leak 846 // these GDI objects until we crash! 847 HICON old_icon = reinterpret_cast<HICON>( 848 SendMessage(hwnd(), WM_SETICON, ICON_SMALL, 849 reinterpret_cast<LPARAM>(windows_icon))); 850 if (old_icon) 851 DestroyIcon(old_icon); 852 } 853 if (!app_icon.isNull()) { 854 HICON windows_icon = IconUtil::CreateHICONFromSkBitmap(*app_icon.bitmap()); 855 HICON old_icon = reinterpret_cast<HICON>( 856 SendMessage(hwnd(), WM_SETICON, ICON_BIG, 857 reinterpret_cast<LPARAM>(windows_icon))); 858 if (old_icon) 859 DestroyIcon(old_icon); 860 } 861 } 862 863 void HWNDMessageHandler::SetFullscreen(bool fullscreen) { 864 fullscreen_handler()->SetFullscreen(fullscreen); 865 // If we are out of fullscreen and there was a pending DWM transition for the 866 // window, then go ahead and do it now. 867 if (!fullscreen && dwm_transition_desired_) 868 PerformDwmTransition(); 869 } 870 871 void HWNDMessageHandler::SizeConstraintsChanged() { 872 LONG style = GetWindowLong(hwnd(), GWL_STYLE); 873 // Ignore if this is not a standard window. 874 if (!(style & WS_OVERLAPPED)) 875 return; 876 877 if (delegate_->CanResize()) { 878 style |= WS_THICKFRAME | WS_MAXIMIZEBOX; 879 if (!delegate_->CanMaximize()) 880 style &= ~WS_MAXIMIZEBOX; 881 } else { 882 style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX); 883 } 884 if (delegate_->CanMinimize()) { 885 style |= WS_MINIMIZEBOX; 886 } else { 887 style &= ~WS_MINIMIZEBOX; 888 } 889 SetWindowLong(hwnd(), GWL_STYLE, style); 890 } 891 892 //////////////////////////////////////////////////////////////////////////////// 893 // HWNDMessageHandler, InputMethodDelegate implementation: 894 895 void HWNDMessageHandler::DispatchKeyEventPostIME(const ui::KeyEvent& key) { 896 SetMsgHandled(delegate_->HandleKeyEvent(key)); 897 } 898 899 //////////////////////////////////////////////////////////////////////////////// 900 // HWNDMessageHandler, gfx::WindowImpl overrides: 901 902 HICON HWNDMessageHandler::GetDefaultWindowIcon() const { 903 if (use_system_default_icon_) 904 return NULL; 905 return ViewsDelegate::views_delegate ? 906 ViewsDelegate::views_delegate->GetDefaultWindowIcon() : NULL; 907 } 908 909 LRESULT HWNDMessageHandler::OnWndProc(UINT message, 910 WPARAM w_param, 911 LPARAM l_param) { 912 HWND window = hwnd(); 913 LRESULT result = 0; 914 915 if (delegate_ && delegate_->PreHandleMSG(message, w_param, l_param, &result)) 916 return result; 917 918 // Otherwise we handle everything else. 919 // NOTE: We inline ProcessWindowMessage() as 'this' may be destroyed during 920 // dispatch and ProcessWindowMessage() doesn't deal with that well. 921 const BOOL old_msg_handled = msg_handled_; 922 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 923 const BOOL processed = 924 _ProcessWindowMessage(window, message, w_param, l_param, result, 0); 925 if (!ref) 926 return 0; 927 msg_handled_ = old_msg_handled; 928 929 if (!processed) { 930 result = DefWindowProc(window, message, w_param, l_param); 931 // DefWindowProc() may have destroyed the window and/or us in a nested 932 // message loop. 933 if (!ref || !::IsWindow(window)) 934 return result; 935 } 936 937 if (delegate_) { 938 delegate_->PostHandleMSG(message, w_param, l_param); 939 if (message == WM_NCDESTROY) 940 delegate_->HandleDestroyed(); 941 } 942 943 if (message == WM_ACTIVATE && IsTopLevelWindow(window)) 944 PostProcessActivateMessage(LOWORD(w_param), !!HIWORD(w_param)); 945 return result; 946 } 947 948 LRESULT HWNDMessageHandler::HandleMouseMessage(unsigned int message, 949 WPARAM w_param, 950 LPARAM l_param, 951 bool* handled) { 952 // Don't track forwarded mouse messages. We expect the caller to track the 953 // mouse. 954 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 955 LRESULT ret = HandleMouseEventInternal(message, w_param, l_param, false); 956 *handled = IsMsgHandled(); 957 return ret; 958 } 959 960 LRESULT HWNDMessageHandler::HandleKeyboardMessage(unsigned int message, 961 WPARAM w_param, 962 LPARAM l_param, 963 bool* handled) { 964 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 965 LRESULT ret = OnKeyEvent(message, w_param, l_param); 966 *handled = IsMsgHandled(); 967 return ret; 968 } 969 970 LRESULT HWNDMessageHandler::HandleTouchMessage(unsigned int message, 971 WPARAM w_param, 972 LPARAM l_param, 973 bool* handled) { 974 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 975 LRESULT ret = OnTouchEvent(message, w_param, l_param); 976 *handled = IsMsgHandled(); 977 return ret; 978 } 979 980 LRESULT HWNDMessageHandler::HandleScrollMessage(unsigned int message, 981 WPARAM w_param, 982 LPARAM l_param, 983 bool* handled) { 984 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 985 LRESULT ret = OnScrollMessage(message, w_param, l_param); 986 *handled = IsMsgHandled(); 987 return ret; 988 } 989 990 LRESULT HWNDMessageHandler::HandleNcHitTestMessage(unsigned int message, 991 WPARAM w_param, 992 LPARAM l_param, 993 bool* handled) { 994 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 995 LRESULT ret = OnNCHitTest( 996 gfx::Point(CR_GET_X_LPARAM(l_param), CR_GET_Y_LPARAM(l_param))); 997 *handled = IsMsgHandled(); 998 return ret; 999 } 1000 1001 //////////////////////////////////////////////////////////////////////////////// 1002 // HWNDMessageHandler, private: 1003 1004 int HWNDMessageHandler::GetAppbarAutohideEdges(HMONITOR monitor) { 1005 autohide_factory_.InvalidateWeakPtrs(); 1006 return ViewsDelegate::views_delegate ? 1007 ViewsDelegate::views_delegate->GetAppbarAutohideEdges( 1008 monitor, 1009 base::Bind(&HWNDMessageHandler::OnAppbarAutohideEdgesChanged, 1010 autohide_factory_.GetWeakPtr())) : 1011 ViewsDelegate::EDGE_BOTTOM; 1012 } 1013 1014 void HWNDMessageHandler::OnAppbarAutohideEdgesChanged() { 1015 // This triggers querying WM_NCCALCSIZE again. 1016 RECT client; 1017 GetWindowRect(hwnd(), &client); 1018 SetWindowPos(hwnd(), NULL, client.left, client.top, 1019 client.right - client.left, client.bottom - client.top, 1020 SWP_FRAMECHANGED); 1021 } 1022 1023 void HWNDMessageHandler::SetInitialFocus() { 1024 if (!(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_TRANSPARENT) && 1025 !(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_NOACTIVATE)) { 1026 // The window does not get keyboard messages unless we focus it. 1027 SetFocus(hwnd()); 1028 } 1029 } 1030 1031 void HWNDMessageHandler::PostProcessActivateMessage(int activation_state, 1032 bool minimized) { 1033 DCHECK(IsTopLevelWindow(hwnd())); 1034 const bool active = activation_state != WA_INACTIVE && !minimized; 1035 if (delegate_->CanActivate()) 1036 delegate_->HandleActivationChanged(active); 1037 } 1038 1039 void HWNDMessageHandler::RestoreEnabledIfNecessary() { 1040 if (delegate_->IsModal() && !restored_enabled_) { 1041 restored_enabled_ = true; 1042 // If we were run modally, we need to undo the disabled-ness we inflicted on 1043 // the owner's parent hierarchy. 1044 HWND start = ::GetWindow(hwnd(), GW_OWNER); 1045 while (start) { 1046 ::EnableWindow(start, TRUE); 1047 start = ::GetParent(start); 1048 } 1049 } 1050 } 1051 1052 void HWNDMessageHandler::ExecuteSystemMenuCommand(int command) { 1053 if (command) 1054 SendMessage(hwnd(), WM_SYSCOMMAND, command, 0); 1055 } 1056 1057 void HWNDMessageHandler::TrackMouseEvents(DWORD mouse_tracking_flags) { 1058 // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE 1059 // when the user moves the mouse outside this HWND's bounds. 1060 if (active_mouse_tracking_flags_ == 0 || mouse_tracking_flags & TME_CANCEL) { 1061 if (mouse_tracking_flags & TME_CANCEL) { 1062 // We're about to cancel active mouse tracking, so empty out the stored 1063 // state. 1064 active_mouse_tracking_flags_ = 0; 1065 } else { 1066 active_mouse_tracking_flags_ = mouse_tracking_flags; 1067 } 1068 1069 TRACKMOUSEEVENT tme; 1070 tme.cbSize = sizeof(tme); 1071 tme.dwFlags = mouse_tracking_flags; 1072 tme.hwndTrack = hwnd(); 1073 tme.dwHoverTime = 0; 1074 TrackMouseEvent(&tme); 1075 } else if (mouse_tracking_flags != active_mouse_tracking_flags_) { 1076 TrackMouseEvents(active_mouse_tracking_flags_ | TME_CANCEL); 1077 TrackMouseEvents(mouse_tracking_flags); 1078 } 1079 } 1080 1081 void HWNDMessageHandler::ClientAreaSizeChanged() { 1082 gfx::Size s = GetClientAreaBounds().size(); 1083 delegate_->HandleClientSizeChanged(s); 1084 if (use_layered_buffer_) 1085 layered_window_contents_.reset(new gfx::Canvas(s, 1.0f, false)); 1086 } 1087 1088 bool HWNDMessageHandler::GetClientAreaInsets(gfx::Insets* insets) const { 1089 if (delegate_->GetClientAreaInsets(insets)) 1090 return true; 1091 DCHECK(insets->empty()); 1092 1093 // Returning false causes the default handling in OnNCCalcSize() to 1094 // be invoked. 1095 if (!delegate_->IsWidgetWindow() || 1096 (!delegate_->IsUsingCustomFrame() && !remove_standard_frame_)) { 1097 return false; 1098 } 1099 1100 if (IsMaximized()) { 1101 // Windows automatically adds a standard width border to all sides when a 1102 // window is maximized. 1103 int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME); 1104 if (remove_standard_frame_) 1105 border_thickness -= 1; 1106 *insets = gfx::Insets( 1107 border_thickness, border_thickness, border_thickness, border_thickness); 1108 return true; 1109 } 1110 1111 *insets = gfx::Insets(); 1112 return true; 1113 } 1114 1115 void HWNDMessageHandler::ResetWindowRegion(bool force, bool redraw) { 1116 // A native frame uses the native window region, and we don't want to mess 1117 // with it. 1118 // WS_EX_COMPOSITED is used instead of WS_EX_LAYERED under aura. WS_EX_LAYERED 1119 // automatically makes clicks on transparent pixels fall through, that isn't 1120 // the case with WS_EX_COMPOSITED. So, we route WS_EX_COMPOSITED through to 1121 // the delegate to allow for a custom hit mask. 1122 if ((window_ex_style() & WS_EX_COMPOSITED) == 0 && !custom_window_region_ && 1123 (!delegate_->IsUsingCustomFrame() || !delegate_->IsWidgetWindow())) { 1124 if (force) 1125 SetWindowRgn(hwnd(), NULL, redraw); 1126 return; 1127 } 1128 1129 // Changing the window region is going to force a paint. Only change the 1130 // window region if the region really differs. 1131 HRGN current_rgn = CreateRectRgn(0, 0, 0, 0); 1132 int current_rgn_result = GetWindowRgn(hwnd(), current_rgn); 1133 1134 RECT window_rect; 1135 GetWindowRect(hwnd(), &window_rect); 1136 HRGN new_region; 1137 if (custom_window_region_) { 1138 new_region = ::CreateRectRgn(0, 0, 0, 0); 1139 ::CombineRgn(new_region, custom_window_region_.Get(), NULL, RGN_COPY); 1140 } else if (IsMaximized()) { 1141 HMONITOR monitor = MonitorFromWindow(hwnd(), MONITOR_DEFAULTTONEAREST); 1142 MONITORINFO mi; 1143 mi.cbSize = sizeof mi; 1144 GetMonitorInfo(monitor, &mi); 1145 RECT work_rect = mi.rcWork; 1146 OffsetRect(&work_rect, -window_rect.left, -window_rect.top); 1147 new_region = CreateRectRgnIndirect(&work_rect); 1148 } else { 1149 gfx::Path window_mask; 1150 delegate_->GetWindowMask(gfx::Size(window_rect.right - window_rect.left, 1151 window_rect.bottom - window_rect.top), 1152 &window_mask); 1153 new_region = gfx::CreateHRGNFromSkPath(window_mask); 1154 } 1155 1156 if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) { 1157 // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion. 1158 SetWindowRgn(hwnd(), new_region, redraw); 1159 } else { 1160 DeleteObject(new_region); 1161 } 1162 1163 DeleteObject(current_rgn); 1164 } 1165 1166 void HWNDMessageHandler::UpdateDwmNcRenderingPolicy() { 1167 if (base::win::GetVersion() < base::win::VERSION_VISTA) 1168 return; 1169 1170 if (fullscreen_handler_->fullscreen()) 1171 return; 1172 1173 DWMNCRENDERINGPOLICY policy = 1174 custom_window_region_ || delegate_->IsUsingCustomFrame() ? 1175 DWMNCRP_DISABLED : DWMNCRP_ENABLED; 1176 1177 DwmSetWindowAttribute(hwnd(), DWMWA_NCRENDERING_POLICY, 1178 &policy, sizeof(DWMNCRENDERINGPOLICY)); 1179 } 1180 1181 LRESULT HWNDMessageHandler::DefWindowProcWithRedrawLock(UINT message, 1182 WPARAM w_param, 1183 LPARAM l_param) { 1184 ScopedRedrawLock lock(this); 1185 // The Widget and HWND can be destroyed in the call to DefWindowProc, so use 1186 // the WeakPtrFactory to avoid unlocking (and crashing) after destruction. 1187 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 1188 LRESULT result = DefWindowProc(hwnd(), message, w_param, l_param); 1189 if (!ref) 1190 lock.CancelUnlockOperation(); 1191 return result; 1192 } 1193 1194 void HWNDMessageHandler::LockUpdates(bool force) { 1195 // We skip locked updates when Aero is on for two reasons: 1196 // 1. Because it isn't necessary 1197 // 2. Because toggling the WS_VISIBLE flag may occur while the GPU process is 1198 // attempting to present a child window's backbuffer onscreen. When these 1199 // two actions race with one another, the child window will either flicker 1200 // or will simply stop updating entirely. 1201 if ((force || !ui::win::IsAeroGlassEnabled()) && ++lock_updates_count_ == 1) { 1202 SetWindowLong(hwnd(), GWL_STYLE, 1203 GetWindowLong(hwnd(), GWL_STYLE) & ~WS_VISIBLE); 1204 } 1205 } 1206 1207 void HWNDMessageHandler::UnlockUpdates(bool force) { 1208 if ((force || !ui::win::IsAeroGlassEnabled()) && --lock_updates_count_ <= 0) { 1209 SetWindowLong(hwnd(), GWL_STYLE, 1210 GetWindowLong(hwnd(), GWL_STYLE) | WS_VISIBLE); 1211 lock_updates_count_ = 0; 1212 } 1213 } 1214 1215 void HWNDMessageHandler::RedrawLayeredWindowContents() { 1216 waiting_for_redraw_layered_window_contents_ = false; 1217 if (invalid_rect_.IsEmpty()) 1218 return; 1219 1220 // We need to clip to the dirty rect ourselves. 1221 layered_window_contents_->sk_canvas()->save(); 1222 double scale = gfx::win::GetDeviceScaleFactor(); 1223 layered_window_contents_->sk_canvas()->scale( 1224 SkScalar(scale),SkScalar(scale)); 1225 layered_window_contents_->ClipRect(invalid_rect_); 1226 delegate_->PaintLayeredWindow(layered_window_contents_.get()); 1227 layered_window_contents_->sk_canvas()->scale( 1228 SkScalar(1.0/scale),SkScalar(1.0/scale)); 1229 layered_window_contents_->sk_canvas()->restore(); 1230 1231 RECT wr; 1232 GetWindowRect(hwnd(), &wr); 1233 SIZE size = {wr.right - wr.left, wr.bottom - wr.top}; 1234 POINT position = {wr.left, wr.top}; 1235 HDC dib_dc = skia::BeginPlatformPaint(layered_window_contents_->sk_canvas()); 1236 POINT zero = {0, 0}; 1237 BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA}; 1238 UpdateLayeredWindow(hwnd(), NULL, &position, &size, dib_dc, &zero, 1239 RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA); 1240 invalid_rect_.SetRect(0, 0, 0, 0); 1241 skia::EndPlatformPaint(layered_window_contents_->sk_canvas()); 1242 } 1243 1244 void HWNDMessageHandler::ForceRedrawWindow(int attempts) { 1245 if (ui::IsWorkstationLocked()) { 1246 // Presents will continue to fail as long as the input desktop is 1247 // unavailable. 1248 if (--attempts <= 0) 1249 return; 1250 base::MessageLoop::current()->PostDelayedTask( 1251 FROM_HERE, 1252 base::Bind(&HWNDMessageHandler::ForceRedrawWindow, 1253 weak_factory_.GetWeakPtr(), 1254 attempts), 1255 base::TimeDelta::FromMilliseconds(500)); 1256 return; 1257 } 1258 InvalidateRect(hwnd(), NULL, FALSE); 1259 } 1260 1261 // Message handlers ------------------------------------------------------------ 1262 1263 void HWNDMessageHandler::OnActivateApp(BOOL active, DWORD thread_id) { 1264 if (delegate_->IsWidgetWindow() && !active && 1265 thread_id != GetCurrentThreadId()) { 1266 delegate_->HandleAppDeactivated(); 1267 // Also update the native frame if it is rendering the non-client area. 1268 if (!remove_standard_frame_ && !delegate_->IsUsingCustomFrame()) 1269 DefWindowProcWithRedrawLock(WM_NCACTIVATE, FALSE, 0); 1270 } 1271 } 1272 1273 BOOL HWNDMessageHandler::OnAppCommand(HWND window, 1274 short command, 1275 WORD device, 1276 int keystate) { 1277 BOOL handled = !!delegate_->HandleAppCommand(command); 1278 SetMsgHandled(handled); 1279 // Make sure to return TRUE if the event was handled or in some cases the 1280 // system will execute the default handler which can cause bugs like going 1281 // forward or back two pages instead of one. 1282 return handled; 1283 } 1284 1285 void HWNDMessageHandler::OnCancelMode() { 1286 delegate_->HandleCancelMode(); 1287 // Need default handling, otherwise capture and other things aren't canceled. 1288 SetMsgHandled(FALSE); 1289 } 1290 1291 void HWNDMessageHandler::OnCaptureChanged(HWND window) { 1292 delegate_->HandleCaptureLost(); 1293 } 1294 1295 void HWNDMessageHandler::OnClose() { 1296 delegate_->HandleClose(); 1297 } 1298 1299 void HWNDMessageHandler::OnCommand(UINT notification_code, 1300 int command, 1301 HWND window) { 1302 // If the notification code is > 1 it means it is control specific and we 1303 // should ignore it. 1304 if (notification_code > 1 || delegate_->HandleAppCommand(command)) 1305 SetMsgHandled(FALSE); 1306 } 1307 1308 LRESULT HWNDMessageHandler::OnCreate(CREATESTRUCT* create_struct) { 1309 use_layered_buffer_ = !!(window_ex_style() & WS_EX_LAYERED); 1310 1311 if (window_ex_style() & WS_EX_COMPOSITED) { 1312 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { 1313 // This is part of the magic to emulate layered windows with Aura 1314 // see the explanation elsewere when we set WS_EX_COMPOSITED style. 1315 MARGINS margins = {-1,-1,-1,-1}; 1316 DwmExtendFrameIntoClientArea(hwnd(), &margins); 1317 } 1318 } 1319 1320 fullscreen_handler_->set_hwnd(hwnd()); 1321 1322 // This message initializes the window so that focus border are shown for 1323 // windows. 1324 SendMessage(hwnd(), 1325 WM_CHANGEUISTATE, 1326 MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 1327 0); 1328 1329 if (remove_standard_frame_) { 1330 SetWindowLong(hwnd(), GWL_STYLE, 1331 GetWindowLong(hwnd(), GWL_STYLE) & ~WS_CAPTION); 1332 SendFrameChanged(); 1333 } 1334 1335 // Get access to a modifiable copy of the system menu. 1336 GetSystemMenu(hwnd(), false); 1337 1338 if (base::win::GetVersion() >= base::win::VERSION_WIN7 && 1339 ui::AreTouchEventsEnabled()) 1340 RegisterTouchWindow(hwnd(), TWF_WANTPALM); 1341 1342 // We need to allow the delegate to size its contents since the window may not 1343 // receive a size notification when its initial bounds are specified at window 1344 // creation time. 1345 ClientAreaSizeChanged(); 1346 1347 delegate_->HandleCreate(); 1348 1349 WTSRegisterSessionNotification(hwnd(), NOTIFY_FOR_THIS_SESSION); 1350 1351 // TODO(beng): move more of NWW::OnCreate here. 1352 return 0; 1353 } 1354 1355 void HWNDMessageHandler::OnDestroy() { 1356 WTSUnRegisterSessionNotification(hwnd()); 1357 delegate_->HandleDestroying(); 1358 } 1359 1360 void HWNDMessageHandler::OnDisplayChange(UINT bits_per_pixel, 1361 const gfx::Size& screen_size) { 1362 delegate_->HandleDisplayChange(); 1363 } 1364 1365 LRESULT HWNDMessageHandler::OnDwmCompositionChanged(UINT msg, 1366 WPARAM w_param, 1367 LPARAM l_param) { 1368 if (!delegate_->IsWidgetWindow()) { 1369 SetMsgHandled(FALSE); 1370 return 0; 1371 } 1372 1373 FrameTypeChanged(); 1374 return 0; 1375 } 1376 1377 void HWNDMessageHandler::OnEnterMenuLoop(BOOL from_track_popup_menu) { 1378 if (menu_depth_++ == 0) 1379 delegate_->HandleMenuLoop(true); 1380 } 1381 1382 void HWNDMessageHandler::OnEnterSizeMove() { 1383 // Please refer to the comments in the OnSize function about the scrollbar 1384 // hack. 1385 // Hide the Windows scrollbar if the scroll styles are present to ensure 1386 // that a paint flicker does not occur while sizing. 1387 if (in_size_loop_ && needs_scroll_styles_) 1388 ShowScrollBar(hwnd(), SB_BOTH, FALSE); 1389 1390 delegate_->HandleBeginWMSizeMove(); 1391 SetMsgHandled(FALSE); 1392 } 1393 1394 LRESULT HWNDMessageHandler::OnEraseBkgnd(HDC dc) { 1395 // Needed to prevent resize flicker. 1396 return 1; 1397 } 1398 1399 void HWNDMessageHandler::OnExitMenuLoop(BOOL is_shortcut_menu) { 1400 if (--menu_depth_ == 0) 1401 delegate_->HandleMenuLoop(false); 1402 DCHECK_GE(0, menu_depth_); 1403 } 1404 1405 void HWNDMessageHandler::OnExitSizeMove() { 1406 delegate_->HandleEndWMSizeMove(); 1407 SetMsgHandled(FALSE); 1408 // Please refer to the notes in the OnSize function for information about 1409 // the scrolling hack. 1410 // We hide the Windows scrollbar in the OnEnterSizeMove function. We need 1411 // to add the scroll styles back to ensure that scrolling works in legacy 1412 // trackpoint drivers. 1413 if (in_size_loop_ && needs_scroll_styles_) 1414 AddScrollStylesToWindow(hwnd()); 1415 } 1416 1417 void HWNDMessageHandler::OnGetMinMaxInfo(MINMAXINFO* minmax_info) { 1418 gfx::Size min_window_size; 1419 gfx::Size max_window_size; 1420 delegate_->GetMinMaxSize(&min_window_size, &max_window_size); 1421 min_window_size = gfx::win::DIPToScreenSize(min_window_size); 1422 max_window_size = gfx::win::DIPToScreenSize(max_window_size); 1423 1424 1425 // Add the native frame border size to the minimum and maximum size if the 1426 // view reports its size as the client size. 1427 if (delegate_->WidgetSizeIsClientSize()) { 1428 RECT client_rect, window_rect; 1429 GetClientRect(hwnd(), &client_rect); 1430 GetWindowRect(hwnd(), &window_rect); 1431 CR_DEFLATE_RECT(&window_rect, &client_rect); 1432 min_window_size.Enlarge(window_rect.right - window_rect.left, 1433 window_rect.bottom - window_rect.top); 1434 if (!max_window_size.IsEmpty()) { 1435 max_window_size.Enlarge(window_rect.right - window_rect.left, 1436 window_rect.bottom - window_rect.top); 1437 } 1438 } 1439 minmax_info->ptMinTrackSize.x = min_window_size.width(); 1440 minmax_info->ptMinTrackSize.y = min_window_size.height(); 1441 if (max_window_size.width() || max_window_size.height()) { 1442 if (!max_window_size.width()) 1443 max_window_size.set_width(GetSystemMetrics(SM_CXMAXTRACK)); 1444 if (!max_window_size.height()) 1445 max_window_size.set_height(GetSystemMetrics(SM_CYMAXTRACK)); 1446 minmax_info->ptMaxTrackSize.x = max_window_size.width(); 1447 minmax_info->ptMaxTrackSize.y = max_window_size.height(); 1448 } 1449 SetMsgHandled(FALSE); 1450 } 1451 1452 LRESULT HWNDMessageHandler::OnGetObject(UINT message, 1453 WPARAM w_param, 1454 LPARAM l_param) { 1455 LRESULT reference_result = static_cast<LRESULT>(0L); 1456 1457 // Only the lower 32 bits of l_param are valid when checking the object id 1458 // because it sometimes gets sign-extended incorrectly (but not always). 1459 DWORD obj_id = static_cast<DWORD>(static_cast<DWORD_PTR>(l_param)); 1460 1461 // Accessibility readers will send an OBJID_CLIENT message 1462 if (OBJID_CLIENT == obj_id) { 1463 // Retrieve MSAA dispatch object for the root view. 1464 base::win::ScopedComPtr<IAccessible> root( 1465 delegate_->GetNativeViewAccessible()); 1466 1467 // Create a reference that MSAA will marshall to the client. 1468 reference_result = LresultFromObject(IID_IAccessible, w_param, 1469 static_cast<IAccessible*>(root.Detach())); 1470 } 1471 1472 return reference_result; 1473 } 1474 1475 LRESULT HWNDMessageHandler::OnImeMessages(UINT message, 1476 WPARAM w_param, 1477 LPARAM l_param) { 1478 LRESULT result = 0; 1479 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 1480 const bool msg_handled = 1481 delegate_->HandleIMEMessage(message, w_param, l_param, &result); 1482 if (ref.get()) 1483 SetMsgHandled(msg_handled); 1484 return result; 1485 } 1486 1487 void HWNDMessageHandler::OnInitMenu(HMENU menu) { 1488 bool is_fullscreen = fullscreen_handler_->fullscreen(); 1489 bool is_minimized = IsMinimized(); 1490 bool is_maximized = IsMaximized(); 1491 bool is_restored = !is_fullscreen && !is_minimized && !is_maximized; 1492 1493 ScopedRedrawLock lock(this); 1494 EnableMenuItemByCommand(menu, SC_RESTORE, delegate_->CanResize() && 1495 (is_minimized || is_maximized)); 1496 EnableMenuItemByCommand(menu, SC_MOVE, is_restored); 1497 EnableMenuItemByCommand(menu, SC_SIZE, delegate_->CanResize() && is_restored); 1498 EnableMenuItemByCommand(menu, SC_MAXIMIZE, delegate_->CanMaximize() && 1499 !is_fullscreen && !is_maximized); 1500 EnableMenuItemByCommand(menu, SC_MINIMIZE, delegate_->CanMinimize() && 1501 !is_minimized); 1502 1503 if (is_maximized && delegate_->CanResize()) 1504 ::SetMenuDefaultItem(menu, SC_RESTORE, FALSE); 1505 else if (!is_maximized && delegate_->CanMaximize()) 1506 ::SetMenuDefaultItem(menu, SC_MAXIMIZE, FALSE); 1507 } 1508 1509 void HWNDMessageHandler::OnInputLangChange(DWORD character_set, 1510 HKL input_language_id) { 1511 delegate_->HandleInputLanguageChange(character_set, input_language_id); 1512 } 1513 1514 LRESULT HWNDMessageHandler::OnKeyEvent(UINT message, 1515 WPARAM w_param, 1516 LPARAM l_param) { 1517 MSG msg = { hwnd(), message, w_param, l_param, GetMessageTime() }; 1518 ui::KeyEvent key(msg); 1519 if (!delegate_->HandleUntranslatedKeyEvent(key)) 1520 DispatchKeyEventPostIME(key); 1521 return 0; 1522 } 1523 1524 void HWNDMessageHandler::OnKillFocus(HWND focused_window) { 1525 delegate_->HandleNativeBlur(focused_window); 1526 SetMsgHandled(FALSE); 1527 } 1528 1529 LRESULT HWNDMessageHandler::OnMouseActivate(UINT message, 1530 WPARAM w_param, 1531 LPARAM l_param) { 1532 // Please refer to the comments in the header for the touch_down_contexts_ 1533 // member for the if statement below. 1534 if (touch_down_contexts_) 1535 return MA_NOACTIVATE; 1536 1537 // On Windows, if we select the menu item by touch and if the window at the 1538 // location is another window on the same thread, that window gets a 1539 // WM_MOUSEACTIVATE message and ends up activating itself, which is not 1540 // correct. We workaround this by setting a property on the window at the 1541 // current cursor location. We check for this property in our 1542 // WM_MOUSEACTIVATE handler and don't activate the window if the property is 1543 // set. 1544 if (::GetProp(hwnd(), ui::kIgnoreTouchMouseActivateForWindow)) { 1545 ::RemoveProp(hwnd(), ui::kIgnoreTouchMouseActivateForWindow); 1546 return MA_NOACTIVATE; 1547 } 1548 // A child window activation should be treated as if we lost activation. 1549 POINT cursor_pos = {0}; 1550 ::GetCursorPos(&cursor_pos); 1551 ::ScreenToClient(hwnd(), &cursor_pos); 1552 HWND child = ::RealChildWindowFromPoint(hwnd(), cursor_pos); 1553 if (::IsWindow(child) && child != hwnd() && ::IsWindowVisible(child)) 1554 PostProcessActivateMessage(WA_INACTIVE, false); 1555 1556 // TODO(beng): resolve this with the GetWindowLong() check on the subsequent 1557 // line. 1558 if (delegate_->IsWidgetWindow()) 1559 return delegate_->CanActivate() ? MA_ACTIVATE : MA_NOACTIVATEANDEAT; 1560 if (GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_NOACTIVATE) 1561 return MA_NOACTIVATE; 1562 SetMsgHandled(FALSE); 1563 return MA_ACTIVATE; 1564 } 1565 1566 LRESULT HWNDMessageHandler::OnMouseRange(UINT message, 1567 WPARAM w_param, 1568 LPARAM l_param) { 1569 return HandleMouseEventInternal(message, w_param, l_param, true); 1570 } 1571 1572 void HWNDMessageHandler::OnMove(const gfx::Point& point) { 1573 delegate_->HandleMove(); 1574 SetMsgHandled(FALSE); 1575 } 1576 1577 void HWNDMessageHandler::OnMoving(UINT param, const RECT* new_bounds) { 1578 delegate_->HandleMove(); 1579 } 1580 1581 LRESULT HWNDMessageHandler::OnNCActivate(UINT message, 1582 WPARAM w_param, 1583 LPARAM l_param) { 1584 // Per MSDN, w_param is either TRUE or FALSE. However, MSDN also hints that: 1585 // "If the window is minimized when this message is received, the application 1586 // should pass the message to the DefWindowProc function." 1587 // It is found out that the high word of w_param might be set when the window 1588 // is minimized or restored. To handle this, w_param's high word should be 1589 // cleared before it is converted to BOOL. 1590 BOOL active = static_cast<BOOL>(LOWORD(w_param)); 1591 1592 bool inactive_rendering_disabled = delegate_->IsInactiveRenderingDisabled(); 1593 1594 if (!delegate_->IsWidgetWindow()) { 1595 SetMsgHandled(FALSE); 1596 return 0; 1597 } 1598 1599 if (!delegate_->CanActivate()) 1600 return TRUE; 1601 1602 // On activation, lift any prior restriction against rendering as inactive. 1603 if (active && inactive_rendering_disabled) 1604 delegate_->EnableInactiveRendering(); 1605 1606 if (delegate_->IsUsingCustomFrame()) { 1607 // TODO(beng, et al): Hack to redraw this window and child windows 1608 // synchronously upon activation. Not all child windows are redrawing 1609 // themselves leading to issues like http://crbug.com/74604 1610 // We redraw out-of-process HWNDs asynchronously to avoid hanging the 1611 // whole app if a child HWND belonging to a hung plugin is encountered. 1612 RedrawWindow(hwnd(), NULL, NULL, 1613 RDW_NOCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW); 1614 EnumChildWindows(hwnd(), EnumChildWindowsForRedraw, NULL); 1615 } 1616 1617 // The frame may need to redraw as a result of the activation change. 1618 // We can get WM_NCACTIVATE before we're actually visible. If we're not 1619 // visible, no need to paint. 1620 if (IsVisible()) 1621 delegate_->SchedulePaint(); 1622 1623 // Avoid DefWindowProc non-client rendering over our custom frame on newer 1624 // Windows versions only (breaks taskbar activation indication on XP/Vista). 1625 if (delegate_->IsUsingCustomFrame() && 1626 base::win::GetVersion() > base::win::VERSION_VISTA) { 1627 SetMsgHandled(TRUE); 1628 return TRUE; 1629 } 1630 1631 return DefWindowProcWithRedrawLock( 1632 WM_NCACTIVATE, inactive_rendering_disabled || active, 0); 1633 } 1634 1635 LRESULT HWNDMessageHandler::OnNCCalcSize(BOOL mode, LPARAM l_param) { 1636 // We only override the default handling if we need to specify a custom 1637 // non-client edge width. Note that in most cases "no insets" means no 1638 // custom width, but in fullscreen mode or when the NonClientFrameView 1639 // requests it, we want a custom width of 0. 1640 1641 // Let User32 handle the first nccalcsize for captioned windows 1642 // so it updates its internal structures (specifically caption-present) 1643 // Without this Tile & Cascade windows won't work. 1644 // See http://code.google.com/p/chromium/issues/detail?id=900 1645 if (is_first_nccalc_) { 1646 is_first_nccalc_ = false; 1647 if (GetWindowLong(hwnd(), GWL_STYLE) & WS_CAPTION) { 1648 SetMsgHandled(FALSE); 1649 return 0; 1650 } 1651 } 1652 1653 gfx::Insets insets; 1654 bool got_insets = GetClientAreaInsets(&insets); 1655 if (!got_insets && !fullscreen_handler_->fullscreen() && 1656 !(mode && remove_standard_frame_)) { 1657 SetMsgHandled(FALSE); 1658 return 0; 1659 } 1660 1661 RECT* client_rect = mode ? 1662 &(reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param)->rgrc[0]) : 1663 reinterpret_cast<RECT*>(l_param); 1664 client_rect->left += insets.left(); 1665 client_rect->top += insets.top(); 1666 client_rect->bottom -= insets.bottom(); 1667 client_rect->right -= insets.right(); 1668 if (IsMaximized()) { 1669 // Find all auto-hide taskbars along the screen edges and adjust in by the 1670 // thickness of the auto-hide taskbar on each such edge, so the window isn't 1671 // treated as a "fullscreen app", which would cause the taskbars to 1672 // disappear. 1673 HMONITOR monitor = MonitorFromWindow(hwnd(), MONITOR_DEFAULTTONULL); 1674 if (!monitor) { 1675 // We might end up here if the window was previously minimized and the 1676 // user clicks on the taskbar button to restore it in the previously 1677 // maximized position. In that case WM_NCCALCSIZE is sent before the 1678 // window coordinates are restored to their previous values, so our 1679 // (left,top) would probably be (-32000,-32000) like all minimized 1680 // windows. So the above MonitorFromWindow call fails, but if we check 1681 // the window rect given with WM_NCCALCSIZE (which is our previous 1682 // restored window position) we will get the correct monitor handle. 1683 monitor = MonitorFromRect(client_rect, MONITOR_DEFAULTTONULL); 1684 if (!monitor) { 1685 // This is probably an extreme case that we won't hit, but if we don't 1686 // intersect any monitor, let us not adjust the client rect since our 1687 // window will not be visible anyway. 1688 return 0; 1689 } 1690 } 1691 const int autohide_edges = GetAppbarAutohideEdges(monitor); 1692 if (autohide_edges & ViewsDelegate::EDGE_LEFT) 1693 client_rect->left += kAutoHideTaskbarThicknessPx; 1694 if (autohide_edges & ViewsDelegate::EDGE_TOP) { 1695 if (!delegate_->IsUsingCustomFrame()) { 1696 // Tricky bit. Due to a bug in DwmDefWindowProc()'s handling of 1697 // WM_NCHITTEST, having any nonclient area atop the window causes the 1698 // caption buttons to draw onscreen but not respond to mouse 1699 // hover/clicks. 1700 // So for a taskbar at the screen top, we can't push the 1701 // client_rect->top down; instead, we move the bottom up by one pixel, 1702 // which is the smallest change we can make and still get a client area 1703 // less than the screen size. This is visibly ugly, but there seems to 1704 // be no better solution. 1705 --client_rect->bottom; 1706 } else { 1707 client_rect->top += kAutoHideTaskbarThicknessPx; 1708 } 1709 } 1710 if (autohide_edges & ViewsDelegate::EDGE_RIGHT) 1711 client_rect->right -= kAutoHideTaskbarThicknessPx; 1712 if (autohide_edges & ViewsDelegate::EDGE_BOTTOM) 1713 client_rect->bottom -= kAutoHideTaskbarThicknessPx; 1714 1715 // We cannot return WVR_REDRAW when there is nonclient area, or Windows 1716 // exhibits bugs where client pixels and child HWNDs are mispositioned by 1717 // the width/height of the upper-left nonclient area. 1718 return 0; 1719 } 1720 1721 // If the window bounds change, we're going to relayout and repaint anyway. 1722 // Returning WVR_REDRAW avoids an extra paint before that of the old client 1723 // pixels in the (now wrong) location, and thus makes actions like resizing a 1724 // window from the left edge look slightly less broken. 1725 // We special case when left or top insets are 0, since these conditions 1726 // actually require another repaint to correct the layout after glass gets 1727 // turned on and off. 1728 if (insets.left() == 0 || insets.top() == 0) 1729 return 0; 1730 return mode ? WVR_REDRAW : 0; 1731 } 1732 1733 LRESULT HWNDMessageHandler::OnNCHitTest(const gfx::Point& point) { 1734 if (!delegate_->IsWidgetWindow()) { 1735 SetMsgHandled(FALSE); 1736 return 0; 1737 } 1738 1739 // If the DWM is rendering the window controls, we need to give the DWM's 1740 // default window procedure first chance to handle hit testing. 1741 if (!remove_standard_frame_ && !delegate_->IsUsingCustomFrame()) { 1742 LRESULT result; 1743 if (DwmDefWindowProc(hwnd(), WM_NCHITTEST, 0, 1744 MAKELPARAM(point.x(), point.y()), &result)) { 1745 return result; 1746 } 1747 } 1748 1749 // First, give the NonClientView a chance to test the point to see if it 1750 // provides any of the non-client area. 1751 POINT temp = { point.x(), point.y() }; 1752 MapWindowPoints(HWND_DESKTOP, hwnd(), &temp, 1); 1753 int component = delegate_->GetNonClientComponent(gfx::Point(temp)); 1754 if (component != HTNOWHERE) 1755 return component; 1756 1757 // Otherwise, we let Windows do all the native frame non-client handling for 1758 // us. 1759 LRESULT hit_test_code = DefWindowProc(hwnd(), WM_NCHITTEST, 0, 1760 MAKELPARAM(point.x(), point.y())); 1761 if (needs_scroll_styles_) { 1762 switch (hit_test_code) { 1763 // If we faked the WS_VSCROLL and WS_HSCROLL styles for this window, then 1764 // Windows returns the HTVSCROLL or HTHSCROLL hit test codes if we hover 1765 // or click on the non client portions of the window where the OS 1766 // scrollbars would be drawn. These hittest codes are returned even when 1767 // the scrollbars are hidden, which is the case in Aura. We fake the 1768 // hittest code as HTCLIENT in this case to ensure that we receive client 1769 // mouse messages as opposed to non client mouse messages. 1770 case HTVSCROLL: 1771 case HTHSCROLL: 1772 hit_test_code = HTCLIENT; 1773 break; 1774 1775 case HTBOTTOMRIGHT: { 1776 // Normally the HTBOTTOMRIGHT hittest code is received when we hover 1777 // near the bottom right of the window. However due to our fake scroll 1778 // styles, we get this code even when we hover around the area where 1779 // the vertical scrollar down arrow would be drawn. 1780 // We check if the hittest coordinates lie in this region and if yes 1781 // we return HTCLIENT. 1782 int border_width = ::GetSystemMetrics(SM_CXSIZEFRAME); 1783 int border_height = ::GetSystemMetrics(SM_CYSIZEFRAME); 1784 int scroll_width = ::GetSystemMetrics(SM_CXVSCROLL); 1785 int scroll_height = ::GetSystemMetrics(SM_CYVSCROLL); 1786 RECT window_rect; 1787 ::GetWindowRect(hwnd(), &window_rect); 1788 window_rect.bottom -= border_height; 1789 window_rect.right -= border_width; 1790 window_rect.left = window_rect.right - scroll_width; 1791 window_rect.top = window_rect.bottom - scroll_height; 1792 POINT pt; 1793 pt.x = point.x(); 1794 pt.y = point.y(); 1795 if (::PtInRect(&window_rect, pt)) 1796 hit_test_code = HTCLIENT; 1797 break; 1798 } 1799 1800 default: 1801 break; 1802 } 1803 } 1804 return hit_test_code; 1805 } 1806 1807 void HWNDMessageHandler::OnNCPaint(HRGN rgn) { 1808 // We only do non-client painting if we're not using the native frame. 1809 // It's required to avoid some native painting artifacts from appearing when 1810 // the window is resized. 1811 if (!delegate_->IsWidgetWindow() || !delegate_->IsUsingCustomFrame()) { 1812 SetMsgHandled(FALSE); 1813 return; 1814 } 1815 1816 // We have an NC region and need to paint it. We expand the NC region to 1817 // include the dirty region of the root view. This is done to minimize 1818 // paints. 1819 RECT window_rect; 1820 GetWindowRect(hwnd(), &window_rect); 1821 1822 gfx::Size root_view_size = delegate_->GetRootViewSize(); 1823 if (gfx::Size(window_rect.right - window_rect.left, 1824 window_rect.bottom - window_rect.top) != root_view_size) { 1825 // If the size of the window differs from the size of the root view it 1826 // means we're being asked to paint before we've gotten a WM_SIZE. This can 1827 // happen when the user is interactively resizing the window. To avoid 1828 // mass flickering we don't do anything here. Once we get the WM_SIZE we'll 1829 // reset the region of the window which triggers another WM_NCPAINT and 1830 // all is well. 1831 return; 1832 } 1833 1834 RECT dirty_region; 1835 // A value of 1 indicates paint all. 1836 if (!rgn || rgn == reinterpret_cast<HRGN>(1)) { 1837 dirty_region.left = 0; 1838 dirty_region.top = 0; 1839 dirty_region.right = window_rect.right - window_rect.left; 1840 dirty_region.bottom = window_rect.bottom - window_rect.top; 1841 } else { 1842 RECT rgn_bounding_box; 1843 GetRgnBox(rgn, &rgn_bounding_box); 1844 if (!IntersectRect(&dirty_region, &rgn_bounding_box, &window_rect)) 1845 return; // Dirty region doesn't intersect window bounds, bale. 1846 1847 // rgn_bounding_box is in screen coordinates. Map it to window coordinates. 1848 OffsetRect(&dirty_region, -window_rect.left, -window_rect.top); 1849 } 1850 1851 // In theory GetDCEx should do what we want, but I couldn't get it to work. 1852 // In particular the docs mentiond DCX_CLIPCHILDREN, but as far as I can tell 1853 // it doesn't work at all. So, instead we get the DC for the window then 1854 // manually clip out the children. 1855 HDC dc = GetWindowDC(hwnd()); 1856 ClipState clip_state; 1857 clip_state.x = window_rect.left; 1858 clip_state.y = window_rect.top; 1859 clip_state.parent = hwnd(); 1860 clip_state.dc = dc; 1861 EnumChildWindows(hwnd(), &ClipDCToChild, 1862 reinterpret_cast<LPARAM>(&clip_state)); 1863 1864 gfx::Rect old_paint_region = invalid_rect_; 1865 if (!old_paint_region.IsEmpty()) { 1866 // The root view has a region that needs to be painted. Include it in the 1867 // region we're going to paint. 1868 1869 RECT old_paint_region_crect = old_paint_region.ToRECT(); 1870 RECT tmp = dirty_region; 1871 UnionRect(&dirty_region, &tmp, &old_paint_region_crect); 1872 } 1873 1874 SchedulePaintInRect(gfx::Rect(dirty_region)); 1875 1876 // gfx::CanvasSkiaPaint's destructor does the actual painting. As such, wrap 1877 // the following in a block to force paint to occur so that we can release 1878 // the dc. 1879 if (!delegate_->HandlePaintAccelerated(gfx::Rect(dirty_region))) { 1880 gfx::CanvasSkiaPaint canvas(dc, 1881 true, 1882 dirty_region.left, 1883 dirty_region.top, 1884 dirty_region.right - dirty_region.left, 1885 dirty_region.bottom - dirty_region.top); 1886 delegate_->HandlePaint(&canvas); 1887 } 1888 1889 ReleaseDC(hwnd(), dc); 1890 // When using a custom frame, we want to avoid calling DefWindowProc() since 1891 // that may render artifacts. 1892 SetMsgHandled(delegate_->IsUsingCustomFrame()); 1893 } 1894 1895 LRESULT HWNDMessageHandler::OnNCUAHDrawCaption(UINT message, 1896 WPARAM w_param, 1897 LPARAM l_param) { 1898 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for 1899 // an explanation about why we need to handle this message. 1900 SetMsgHandled(delegate_->IsUsingCustomFrame()); 1901 return 0; 1902 } 1903 1904 LRESULT HWNDMessageHandler::OnNCUAHDrawFrame(UINT message, 1905 WPARAM w_param, 1906 LPARAM l_param) { 1907 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for 1908 // an explanation about why we need to handle this message. 1909 SetMsgHandled(delegate_->IsUsingCustomFrame()); 1910 return 0; 1911 } 1912 1913 LRESULT HWNDMessageHandler::OnNotify(int w_param, NMHDR* l_param) { 1914 LRESULT l_result = 0; 1915 SetMsgHandled(delegate_->HandleTooltipNotify(w_param, l_param, &l_result)); 1916 return l_result; 1917 } 1918 1919 void HWNDMessageHandler::OnPaint(HDC dc) { 1920 // Call BeginPaint()/EndPaint() around the paint handling, as that seems 1921 // to do more to actually validate the window's drawing region. This only 1922 // appears to matter for Windows that have the WS_EX_COMPOSITED style set 1923 // but will be valid in general too. 1924 PAINTSTRUCT ps; 1925 HDC display_dc = BeginPaint(hwnd(), &ps); 1926 CHECK(display_dc); 1927 1928 // Try to paint accelerated first. 1929 if (!IsRectEmpty(&ps.rcPaint) && 1930 !delegate_->HandlePaintAccelerated(gfx::Rect(ps.rcPaint))) { 1931 delegate_->HandlePaint(NULL); 1932 } 1933 1934 EndPaint(hwnd(), &ps); 1935 } 1936 1937 LRESULT HWNDMessageHandler::OnReflectedMessage(UINT message, 1938 WPARAM w_param, 1939 LPARAM l_param) { 1940 SetMsgHandled(FALSE); 1941 return 0; 1942 } 1943 1944 LRESULT HWNDMessageHandler::OnScrollMessage(UINT message, 1945 WPARAM w_param, 1946 LPARAM l_param) { 1947 MSG msg = { hwnd(), message, w_param, l_param, GetMessageTime() }; 1948 ui::ScrollEvent event(msg); 1949 delegate_->HandleScrollEvent(event); 1950 return 0; 1951 } 1952 1953 void HWNDMessageHandler::OnSessionChange(WPARAM status_code, 1954 PWTSSESSION_NOTIFICATION session_id) { 1955 // Direct3D presents are ignored while the screen is locked, so force the 1956 // window to be redrawn on unlock. 1957 if (status_code == WTS_SESSION_UNLOCK) 1958 ForceRedrawWindow(10); 1959 1960 SetMsgHandled(FALSE); 1961 } 1962 1963 LRESULT HWNDMessageHandler::OnSetCursor(UINT message, 1964 WPARAM w_param, 1965 LPARAM l_param) { 1966 // Reimplement the necessary default behavior here. Calling DefWindowProc can 1967 // trigger weird non-client painting for non-glass windows with custom frames. 1968 // Using a ScopedRedrawLock to prevent caption rendering artifacts may allow 1969 // content behind this window to incorrectly paint in front of this window. 1970 // Invalidating the window to paint over either set of artifacts is not ideal. 1971 wchar_t* cursor = IDC_ARROW; 1972 switch (LOWORD(l_param)) { 1973 case HTSIZE: 1974 cursor = IDC_SIZENWSE; 1975 break; 1976 case HTLEFT: 1977 case HTRIGHT: 1978 cursor = IDC_SIZEWE; 1979 break; 1980 case HTTOP: 1981 case HTBOTTOM: 1982 cursor = IDC_SIZENS; 1983 break; 1984 case HTTOPLEFT: 1985 case HTBOTTOMRIGHT: 1986 cursor = IDC_SIZENWSE; 1987 break; 1988 case HTTOPRIGHT: 1989 case HTBOTTOMLEFT: 1990 cursor = IDC_SIZENESW; 1991 break; 1992 case HTCLIENT: 1993 SetCursor(current_cursor_); 1994 return 1; 1995 case LOWORD(HTERROR): // Use HTERROR's LOWORD value for valid comparison. 1996 SetMsgHandled(FALSE); 1997 break; 1998 default: 1999 // Use the default value, IDC_ARROW. 2000 break; 2001 } 2002 ::SetCursor(LoadCursor(NULL, cursor)); 2003 return 1; 2004 } 2005 2006 void HWNDMessageHandler::OnSetFocus(HWND last_focused_window) { 2007 delegate_->HandleNativeFocus(last_focused_window); 2008 SetMsgHandled(FALSE); 2009 } 2010 2011 LRESULT HWNDMessageHandler::OnSetIcon(UINT size_type, HICON new_icon) { 2012 // Use a ScopedRedrawLock to avoid weird non-client painting. 2013 return DefWindowProcWithRedrawLock(WM_SETICON, size_type, 2014 reinterpret_cast<LPARAM>(new_icon)); 2015 } 2016 2017 LRESULT HWNDMessageHandler::OnSetText(const wchar_t* text) { 2018 // Use a ScopedRedrawLock to avoid weird non-client painting. 2019 return DefWindowProcWithRedrawLock(WM_SETTEXT, NULL, 2020 reinterpret_cast<LPARAM>(text)); 2021 } 2022 2023 void HWNDMessageHandler::OnSettingChange(UINT flags, const wchar_t* section) { 2024 if (!GetParent(hwnd()) && (flags == SPI_SETWORKAREA) && 2025 !delegate_->WillProcessWorkAreaChange()) { 2026 // Fire a dummy SetWindowPos() call, so we'll trip the code in 2027 // OnWindowPosChanging() below that notices work area changes. 2028 ::SetWindowPos(hwnd(), 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | 2029 SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOOWNERZORDER); 2030 SetMsgHandled(TRUE); 2031 } else { 2032 if (flags == SPI_SETWORKAREA) 2033 delegate_->HandleWorkAreaChanged(); 2034 SetMsgHandled(FALSE); 2035 } 2036 } 2037 2038 void HWNDMessageHandler::OnSize(UINT param, const gfx::Size& size) { 2039 RedrawWindow(hwnd(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN); 2040 // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've 2041 // invoked OnSize we ensure the RootView has been laid out. 2042 ResetWindowRegion(false, true); 2043 2044 // We add the WS_VSCROLL and WS_HSCROLL styles to top level windows to ensure 2045 // that legacy trackpad/trackpoint drivers generate the WM_VSCROLL and 2046 // WM_HSCROLL messages and scrolling works. 2047 // We want the scroll styles to be present on the window. However we don't 2048 // want Windows to draw the scrollbars. To achieve this we hide the scroll 2049 // bars and readd them to the window style in a posted task to ensure that we 2050 // don't get nested WM_SIZE messages. 2051 if (needs_scroll_styles_ && !in_size_loop_) { 2052 ShowScrollBar(hwnd(), SB_BOTH, FALSE); 2053 base::MessageLoop::current()->PostTask( 2054 FROM_HERE, base::Bind(&AddScrollStylesToWindow, hwnd())); 2055 } 2056 } 2057 2058 void HWNDMessageHandler::OnSysCommand(UINT notification_code, 2059 const gfx::Point& point) { 2060 if (!delegate_->ShouldHandleSystemCommands()) 2061 return; 2062 2063 // Windows uses the 4 lower order bits of |notification_code| for type- 2064 // specific information so we must exclude this when comparing. 2065 static const int sc_mask = 0xFFF0; 2066 // Ignore size/move/maximize in fullscreen mode. 2067 if (fullscreen_handler_->fullscreen() && 2068 (((notification_code & sc_mask) == SC_SIZE) || 2069 ((notification_code & sc_mask) == SC_MOVE) || 2070 ((notification_code & sc_mask) == SC_MAXIMIZE))) 2071 return; 2072 if (delegate_->IsUsingCustomFrame()) { 2073 if ((notification_code & sc_mask) == SC_MINIMIZE || 2074 (notification_code & sc_mask) == SC_MAXIMIZE || 2075 (notification_code & sc_mask) == SC_RESTORE) { 2076 delegate_->ResetWindowControls(); 2077 } else if ((notification_code & sc_mask) == SC_MOVE || 2078 (notification_code & sc_mask) == SC_SIZE) { 2079 if (!IsVisible()) { 2080 // Circumvent ScopedRedrawLocks and force visibility before entering a 2081 // resize or move modal loop to get continuous sizing/moving feedback. 2082 SetWindowLong(hwnd(), GWL_STYLE, 2083 GetWindowLong(hwnd(), GWL_STYLE) | WS_VISIBLE); 2084 } 2085 } 2086 } 2087 2088 // Handle SC_KEYMENU, which means that the user has pressed the ALT 2089 // key and released it, so we should focus the menu bar. 2090 if ((notification_code & sc_mask) == SC_KEYMENU && point.x() == 0) { 2091 int modifiers = ui::EF_NONE; 2092 if (base::win::IsShiftPressed()) 2093 modifiers |= ui::EF_SHIFT_DOWN; 2094 if (base::win::IsCtrlPressed()) 2095 modifiers |= ui::EF_CONTROL_DOWN; 2096 // Retrieve the status of shift and control keys to prevent consuming 2097 // shift+alt keys, which are used by Windows to change input languages. 2098 ui::Accelerator accelerator(ui::KeyboardCodeForWindowsKeyCode(VK_MENU), 2099 modifiers); 2100 delegate_->HandleAccelerator(accelerator); 2101 return; 2102 } 2103 2104 // If the delegate can't handle it, the system implementation will be called. 2105 if (!delegate_->HandleCommand(notification_code)) { 2106 // If the window is being resized by dragging the borders of the window 2107 // with the mouse/touch/keyboard, we flag as being in a size loop. 2108 if ((notification_code & sc_mask) == SC_SIZE) 2109 in_size_loop_ = true; 2110 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 2111 DefWindowProc(hwnd(), WM_SYSCOMMAND, notification_code, 2112 MAKELPARAM(point.x(), point.y())); 2113 if (!ref.get()) 2114 return; 2115 in_size_loop_ = false; 2116 } 2117 } 2118 2119 void HWNDMessageHandler::OnThemeChanged() { 2120 ui::NativeThemeWin::instance()->CloseHandles(); 2121 } 2122 2123 LRESULT HWNDMessageHandler::OnTouchEvent(UINT message, 2124 WPARAM w_param, 2125 LPARAM l_param) { 2126 // Handle touch events only on Aura for now. 2127 int num_points = LOWORD(w_param); 2128 scoped_ptr<TOUCHINPUT[]> input(new TOUCHINPUT[num_points]); 2129 if (ui::GetTouchInputInfoWrapper(reinterpret_cast<HTOUCHINPUT>(l_param), 2130 num_points, input.get(), 2131 sizeof(TOUCHINPUT))) { 2132 int flags = ui::GetModifiersFromKeyState(); 2133 TouchEvents touch_events; 2134 for (int i = 0; i < num_points; ++i) { 2135 POINT point; 2136 point.x = TOUCH_COORD_TO_PIXEL(input[i].x); 2137 point.y = TOUCH_COORD_TO_PIXEL(input[i].y); 2138 2139 if (base::win::GetVersion() == base::win::VERSION_WIN7) { 2140 // Windows 7 sends touch events for touches in the non-client area, 2141 // whereas Windows 8 does not. In order to unify the behaviour, always 2142 // ignore touch events in the non-client area. 2143 LPARAM l_param_ht = MAKELPARAM(point.x, point.y); 2144 LRESULT hittest = SendMessage(hwnd(), WM_NCHITTEST, 0, l_param_ht); 2145 2146 if (hittest != HTCLIENT) 2147 return 0; 2148 } 2149 2150 ScreenToClient(hwnd(), &point); 2151 2152 last_touch_message_time_ = ::GetMessageTime(); 2153 2154 ui::EventType touch_event_type = ui::ET_UNKNOWN; 2155 2156 if (input[i].dwFlags & TOUCHEVENTF_DOWN) { 2157 touch_ids_.insert(input[i].dwID); 2158 touch_event_type = ui::ET_TOUCH_PRESSED; 2159 touch_down_contexts_++; 2160 base::MessageLoop::current()->PostDelayedTask( 2161 FROM_HERE, 2162 base::Bind(&HWNDMessageHandler::ResetTouchDownContext, 2163 weak_factory_.GetWeakPtr()), 2164 base::TimeDelta::FromMilliseconds(kTouchDownContextResetTimeout)); 2165 } else if (input[i].dwFlags & TOUCHEVENTF_UP) { 2166 touch_ids_.erase(input[i].dwID); 2167 touch_event_type = ui::ET_TOUCH_RELEASED; 2168 } else if (input[i].dwFlags & TOUCHEVENTF_MOVE) { 2169 touch_event_type = ui::ET_TOUCH_MOVED; 2170 } 2171 if (touch_event_type != ui::ET_UNKNOWN) { 2172 base::TimeTicks now; 2173 // input[i].dwTime doesn't necessarily relate to the system time at all, 2174 // so use base::TimeTicks::HighResNow() if possible, or 2175 // base::TimeTicks::Now() otherwise. 2176 if (base::TimeTicks::IsHighResNowFastAndReliable()) 2177 now = base::TimeTicks::HighResNow(); 2178 else 2179 now = base::TimeTicks::Now(); 2180 ui::TouchEvent event(touch_event_type, 2181 gfx::Point(point.x, point.y), 2182 id_generator_.GetGeneratedID(input[i].dwID), 2183 now - base::TimeTicks()); 2184 event.set_flags(flags); 2185 event.latency()->AddLatencyNumberWithTimestamp( 2186 ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 2187 0, 2188 0, 2189 base::TimeTicks::FromInternalValue( 2190 event.time_stamp().ToInternalValue()), 2191 1); 2192 2193 touch_events.push_back(event); 2194 if (touch_event_type == ui::ET_TOUCH_RELEASED) 2195 id_generator_.ReleaseNumber(input[i].dwID); 2196 } 2197 } 2198 // Handle the touch events asynchronously. We need this because touch 2199 // events on windows don't fire if we enter a modal loop in the context of 2200 // a touch event. 2201 base::MessageLoop::current()->PostTask( 2202 FROM_HERE, 2203 base::Bind(&HWNDMessageHandler::HandleTouchEvents, 2204 weak_factory_.GetWeakPtr(), touch_events)); 2205 } 2206 CloseTouchInputHandle(reinterpret_cast<HTOUCHINPUT>(l_param)); 2207 SetMsgHandled(FALSE); 2208 return 0; 2209 } 2210 2211 void HWNDMessageHandler::OnWindowPosChanging(WINDOWPOS* window_pos) { 2212 if (ignore_window_pos_changes_) { 2213 // If somebody's trying to toggle our visibility, change the nonclient area, 2214 // change our Z-order, or activate us, we should probably let it go through. 2215 if (!(window_pos->flags & ((IsVisible() ? SWP_HIDEWINDOW : SWP_SHOWWINDOW) | 2216 SWP_FRAMECHANGED)) && 2217 (window_pos->flags & (SWP_NOZORDER | SWP_NOACTIVATE))) { 2218 // Just sizing/moving the window; ignore. 2219 window_pos->flags |= SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW; 2220 window_pos->flags &= ~(SWP_SHOWWINDOW | SWP_HIDEWINDOW); 2221 } 2222 } else if (!GetParent(hwnd())) { 2223 RECT window_rect; 2224 HMONITOR monitor; 2225 gfx::Rect monitor_rect, work_area; 2226 if (GetWindowRect(hwnd(), &window_rect) && 2227 GetMonitorAndRects(window_rect, &monitor, &monitor_rect, &work_area)) { 2228 bool work_area_changed = (monitor_rect == last_monitor_rect_) && 2229 (work_area != last_work_area_); 2230 if (monitor && (monitor == last_monitor_) && 2231 ((fullscreen_handler_->fullscreen() && 2232 !fullscreen_handler_->metro_snap()) || 2233 work_area_changed)) { 2234 // A rect for the monitor we're on changed. Normally Windows notifies 2235 // us about this (and thus we're reaching here due to the SetWindowPos() 2236 // call in OnSettingChange() above), but with some software (e.g. 2237 // nVidia's nView desktop manager) the work area can change asynchronous 2238 // to any notification, and we're just sent a SetWindowPos() call with a 2239 // new (frequently incorrect) position/size. In either case, the best 2240 // response is to throw away the existing position/size information in 2241 // |window_pos| and recalculate it based on the new work rect. 2242 gfx::Rect new_window_rect; 2243 if (fullscreen_handler_->fullscreen()) { 2244 new_window_rect = monitor_rect; 2245 } else if (IsMaximized()) { 2246 new_window_rect = work_area; 2247 int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME); 2248 new_window_rect.Inset(-border_thickness, -border_thickness); 2249 } else { 2250 new_window_rect = gfx::Rect(window_rect); 2251 new_window_rect.AdjustToFit(work_area); 2252 } 2253 window_pos->x = new_window_rect.x(); 2254 window_pos->y = new_window_rect.y(); 2255 window_pos->cx = new_window_rect.width(); 2256 window_pos->cy = new_window_rect.height(); 2257 // WARNING! Don't set SWP_FRAMECHANGED here, it breaks moving the child 2258 // HWNDs for some reason. 2259 window_pos->flags &= ~(SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW); 2260 window_pos->flags |= SWP_NOCOPYBITS; 2261 2262 // Now ignore all immediately-following SetWindowPos() changes. Windows 2263 // likes to (incorrectly) recalculate what our position/size should be 2264 // and send us further updates. 2265 ignore_window_pos_changes_ = true; 2266 base::MessageLoop::current()->PostTask( 2267 FROM_HERE, 2268 base::Bind(&HWNDMessageHandler::StopIgnoringPosChanges, 2269 weak_factory_.GetWeakPtr())); 2270 } 2271 last_monitor_ = monitor; 2272 last_monitor_rect_ = monitor_rect; 2273 last_work_area_ = work_area; 2274 } 2275 } 2276 2277 if (DidClientAreaSizeChange(window_pos)) 2278 delegate_->HandleWindowSizeChanging(); 2279 2280 if (ScopedFullscreenVisibility::IsHiddenForFullscreen(hwnd())) { 2281 // Prevent the window from being made visible if we've been asked to do so. 2282 // See comment in header as to why we might want this. 2283 window_pos->flags &= ~SWP_SHOWWINDOW; 2284 } 2285 2286 if (window_pos->flags & SWP_SHOWWINDOW) 2287 delegate_->HandleVisibilityChanging(true); 2288 else if (window_pos->flags & SWP_HIDEWINDOW) 2289 delegate_->HandleVisibilityChanging(false); 2290 2291 SetMsgHandled(FALSE); 2292 } 2293 2294 void HWNDMessageHandler::OnWindowPosChanged(WINDOWPOS* window_pos) { 2295 if (DidClientAreaSizeChange(window_pos)) 2296 ClientAreaSizeChanged(); 2297 if (remove_standard_frame_ && window_pos->flags & SWP_FRAMECHANGED && 2298 ui::win::IsAeroGlassEnabled() && 2299 (window_ex_style() & WS_EX_COMPOSITED) == 0) { 2300 MARGINS m = {10, 10, 10, 10}; 2301 DwmExtendFrameIntoClientArea(hwnd(), &m); 2302 } 2303 if (window_pos->flags & SWP_SHOWWINDOW) 2304 delegate_->HandleVisibilityChanged(true); 2305 else if (window_pos->flags & SWP_HIDEWINDOW) 2306 delegate_->HandleVisibilityChanged(false); 2307 SetMsgHandled(FALSE); 2308 } 2309 2310 void HWNDMessageHandler::HandleTouchEvents(const TouchEvents& touch_events) { 2311 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 2312 for (size_t i = 0; i < touch_events.size() && ref; ++i) 2313 delegate_->HandleTouchEvent(touch_events[i]); 2314 } 2315 2316 void HWNDMessageHandler::ResetTouchDownContext() { 2317 touch_down_contexts_--; 2318 } 2319 2320 LRESULT HWNDMessageHandler::HandleMouseEventInternal(UINT message, 2321 WPARAM w_param, 2322 LPARAM l_param, 2323 bool track_mouse) { 2324 if (!touch_ids_.empty()) 2325 return 0; 2326 // We handle touch events on Windows Aura. Windows generates synthesized 2327 // mouse messages in response to touch which we should ignore. However touch 2328 // messages are only received for the client area. We need to ignore the 2329 // synthesized mouse messages for all points in the client area and places 2330 // which return HTNOWHERE. 2331 if (ui::IsMouseEventFromTouch(message)) { 2332 LPARAM l_param_ht = l_param; 2333 // For mouse events (except wheel events), location is in window coordinates 2334 // and should be converted to screen coordinates for WM_NCHITTEST. 2335 if (message != WM_MOUSEWHEEL && message != WM_MOUSEHWHEEL) { 2336 POINT screen_point = CR_POINT_INITIALIZER_FROM_LPARAM(l_param_ht); 2337 MapWindowPoints(hwnd(), HWND_DESKTOP, &screen_point, 1); 2338 l_param_ht = MAKELPARAM(screen_point.x, screen_point.y); 2339 } 2340 LRESULT hittest = SendMessage(hwnd(), WM_NCHITTEST, 0, l_param_ht); 2341 if (hittest == HTCLIENT || hittest == HTNOWHERE) 2342 return 0; 2343 } 2344 2345 // Certain logitech drivers send the WM_MOUSEHWHEEL message to the parent 2346 // followed by WM_MOUSEWHEEL messages to the child window causing a vertical 2347 // scroll. We treat these WM_MOUSEWHEEL messages as WM_MOUSEHWHEEL 2348 // messages. 2349 if (message == WM_MOUSEHWHEEL) 2350 last_mouse_hwheel_time_ = ::GetMessageTime(); 2351 2352 if (message == WM_MOUSEWHEEL && 2353 ::GetMessageTime() == last_mouse_hwheel_time_) { 2354 message = WM_MOUSEHWHEEL; 2355 } 2356 2357 if (message == WM_RBUTTONUP && is_right_mouse_pressed_on_caption_) { 2358 is_right_mouse_pressed_on_caption_ = false; 2359 ReleaseCapture(); 2360 // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu() 2361 // expect screen coordinates. 2362 POINT screen_point = CR_POINT_INITIALIZER_FROM_LPARAM(l_param); 2363 MapWindowPoints(hwnd(), HWND_DESKTOP, &screen_point, 1); 2364 w_param = SendMessage(hwnd(), WM_NCHITTEST, 0, 2365 MAKELPARAM(screen_point.x, screen_point.y)); 2366 if (w_param == HTCAPTION || w_param == HTSYSMENU) { 2367 gfx::ShowSystemMenuAtPoint(hwnd(), gfx::Point(screen_point)); 2368 return 0; 2369 } 2370 } else if (message == WM_NCLBUTTONDOWN && delegate_->IsUsingCustomFrame()) { 2371 switch (w_param) { 2372 case HTCLOSE: 2373 case HTMINBUTTON: 2374 case HTMAXBUTTON: { 2375 // When the mouse is pressed down in these specific non-client areas, 2376 // we need to tell the RootView to send the mouse pressed event (which 2377 // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_ 2378 // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be 2379 // sent by the applicable button's ButtonListener. We _have_ to do this 2380 // way rather than letting Windows just send the syscommand itself (as 2381 // would happen if we never did this dance) because for some insane 2382 // reason DefWindowProc for WM_NCLBUTTONDOWN also renders the pressed 2383 // window control button appearance, in the Windows classic style, over 2384 // our view! Ick! By handling this message we prevent Windows from 2385 // doing this undesirable thing, but that means we need to roll the 2386 // sys-command handling ourselves. 2387 // Combine |w_param| with common key state message flags. 2388 w_param |= base::win::IsCtrlPressed() ? MK_CONTROL : 0; 2389 w_param |= base::win::IsShiftPressed() ? MK_SHIFT : 0; 2390 } 2391 } 2392 } else if (message == WM_NCRBUTTONDOWN && 2393 (w_param == HTCAPTION || w_param == HTSYSMENU)) { 2394 is_right_mouse_pressed_on_caption_ = true; 2395 // We SetCapture() to ensure we only show the menu when the button 2396 // down and up are both on the caption. Note: this causes the button up to 2397 // be WM_RBUTTONUP instead of WM_NCRBUTTONUP. 2398 SetCapture(); 2399 } 2400 long message_time = GetMessageTime(); 2401 MSG msg = { hwnd(), message, w_param, l_param, message_time, 2402 { CR_GET_X_LPARAM(l_param), CR_GET_Y_LPARAM(l_param) } }; 2403 ui::MouseEvent event(msg); 2404 if (IsSynthesizedMouseMessage(message, message_time, l_param)) 2405 event.set_flags(event.flags() | ui::EF_FROM_TOUCH); 2406 2407 if (event.type() == ui::ET_MOUSE_MOVED && !HasCapture() && track_mouse) { 2408 // Windows only fires WM_MOUSELEAVE events if the application begins 2409 // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events. 2410 // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE. 2411 TrackMouseEvents((message == WM_NCMOUSEMOVE) ? 2412 TME_NONCLIENT | TME_LEAVE : TME_LEAVE); 2413 } else if (event.type() == ui::ET_MOUSE_EXITED) { 2414 // Reset our tracking flags so future mouse movement over this 2415 // NativeWidget results in a new tracking session. Fall through for 2416 // OnMouseEvent. 2417 active_mouse_tracking_flags_ = 0; 2418 } else if (event.type() == ui::ET_MOUSEWHEEL) { 2419 // Reroute the mouse wheel to the window under the pointer if applicable. 2420 return (ui::RerouteMouseWheel(hwnd(), w_param, l_param) || 2421 delegate_->HandleMouseEvent(ui::MouseWheelEvent(msg))) ? 0 : 1; 2422 } 2423 2424 // There are cases where the code handling the message destroys the window, 2425 // so use the weak ptr to check if destruction occured or not. 2426 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); 2427 bool handled = delegate_->HandleMouseEvent(event); 2428 if (!ref.get()) 2429 return 0; 2430 if (!handled && message == WM_NCLBUTTONDOWN && w_param != HTSYSMENU && 2431 delegate_->IsUsingCustomFrame()) { 2432 // TODO(msw): Eliminate undesired painting, or re-evaluate this workaround. 2433 // DefWindowProc for WM_NCLBUTTONDOWN does weird non-client painting, so we 2434 // need to call it inside a ScopedRedrawLock. This may cause other negative 2435 // side-effects (ex/ stifling non-client mouse releases). 2436 DefWindowProcWithRedrawLock(message, w_param, l_param); 2437 handled = true; 2438 } 2439 2440 if (ref.get()) 2441 SetMsgHandled(handled); 2442 return 0; 2443 } 2444 2445 bool HWNDMessageHandler::IsSynthesizedMouseMessage(unsigned int message, 2446 int message_time, 2447 LPARAM l_param) { 2448 if (ui::IsMouseEventFromTouch(message)) 2449 return true; 2450 // Ignore mouse messages which occur at the same location as the current 2451 // cursor position and within a time difference of 500 ms from the last 2452 // touch message. 2453 if (last_touch_message_time_ && message_time >= last_touch_message_time_ && 2454 ((message_time - last_touch_message_time_) <= 2455 kSynthesizedMouseTouchMessagesTimeDifference)) { 2456 POINT mouse_location = CR_POINT_INITIALIZER_FROM_LPARAM(l_param); 2457 ::ClientToScreen(hwnd(), &mouse_location); 2458 POINT cursor_pos = {0}; 2459 ::GetCursorPos(&cursor_pos); 2460 if (memcmp(&cursor_pos, &mouse_location, sizeof(POINT))) 2461 return false; 2462 return true; 2463 } 2464 return false; 2465 } 2466 2467 void HWNDMessageHandler::PerformDwmTransition() { 2468 dwm_transition_desired_ = false; 2469 2470 UpdateDwmNcRenderingPolicy(); 2471 // Don't redraw the window here, because we need to hide and show the window 2472 // which will also trigger a redraw. 2473 ResetWindowRegion(true, false); 2474 // The non-client view needs to update too. 2475 delegate_->HandleFrameChanged(); 2476 2477 if (IsVisible() && !delegate_->IsUsingCustomFrame()) { 2478 // For some reason, we need to hide the window after we change from a custom 2479 // frame to a native frame. If we don't, the client area will be filled 2480 // with black. This seems to be related to an interaction between DWM and 2481 // SetWindowRgn, but the details aren't clear. Additionally, we need to 2482 // specify SWP_NOZORDER here, otherwise if you have multiple chrome windows 2483 // open they will re-appear with a non-deterministic Z-order. 2484 UINT flags = SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER; 2485 SetWindowPos(hwnd(), NULL, 0, 0, 0, 0, flags | SWP_HIDEWINDOW); 2486 SetWindowPos(hwnd(), NULL, 0, 0, 0, 0, flags | SWP_SHOWWINDOW); 2487 } 2488 // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want 2489 // to notify our children too, since we can have MDI child windows who need to 2490 // update their appearance. 2491 EnumChildWindows(hwnd(), &SendDwmCompositionChanged, NULL); 2492 } 2493 2494 } // namespace views 2495