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 #ifndef UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_ 6 #define UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_ 7 8 #include <windows.h> 9 10 #include <set> 11 #include <vector> 12 13 #include "base/basictypes.h" 14 #include "base/compiler_specific.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/memory/weak_ptr.h" 17 #include "base/strings/string16.h" 18 #include "base/win/scoped_gdi_object.h" 19 #include "base/win/win_util.h" 20 #include "ui/accessibility/ax_enums.h" 21 #include "ui/base/ui_base_types.h" 22 #include "ui/base/win/window_event_target.h" 23 #include "ui/events/event.h" 24 #include "ui/gfx/rect.h" 25 #include "ui/gfx/sequential_id_generator.h" 26 #include "ui/gfx/win/window_impl.h" 27 #include "ui/views/ime/input_method_delegate.h" 28 #include "ui/views/views_export.h" 29 30 namespace gfx { 31 class Canvas; 32 class ImageSkia; 33 class Insets; 34 } 35 36 namespace ui { 37 class ViewProp; 38 } 39 40 namespace views { 41 42 class FullscreenHandler; 43 class HWNDMessageHandlerDelegate; 44 class InputMethod; 45 46 // These two messages aren't defined in winuser.h, but they are sent to windows 47 // with captions. They appear to paint the window caption and frame. 48 // Unfortunately if you override the standard non-client rendering as we do 49 // with CustomFrameWindow, sometimes Windows (not deterministically 50 // reproducibly but definitely frequently) will send these messages to the 51 // window and paint the standard caption/title over the top of the custom one. 52 // So we need to handle these messages in CustomFrameWindow to prevent this 53 // from happening. 54 const int WM_NCUAHDRAWCAPTION = 0xAE; 55 const int WM_NCUAHDRAWFRAME = 0xAF; 56 57 // IsMsgHandled() and BEGIN_SAFE_MSG_MAP_EX are a modified version of 58 // BEGIN_MSG_MAP_EX. The main difference is it adds a WeakPtrFactory member 59 // (|weak_factory_|) that is used in _ProcessWindowMessage() and changing 60 // IsMsgHandled() from a member function to a define that checks if the weak 61 // factory is still valid in addition to the member. Together these allow for 62 // |this| to be deleted during dispatch. 63 #define IsMsgHandled() !ref.get() || msg_handled_ 64 65 #define BEGIN_SAFE_MSG_MAP_EX(the_class) \ 66 private: \ 67 base::WeakPtrFactory<the_class> weak_factory_; \ 68 BOOL msg_handled_; \ 69 \ 70 public: \ 71 /* "handled" management for cracked handlers */ \ 72 void SetMsgHandled(BOOL handled) { \ 73 msg_handled_ = handled; \ 74 } \ 75 BOOL ProcessWindowMessage(HWND hwnd, \ 76 UINT msg, \ 77 WPARAM w_param, \ 78 LPARAM l_param, \ 79 LRESULT& l_result, \ 80 DWORD msg_map_id = 0) { \ 81 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); \ 82 BOOL old_msg_handled = msg_handled_; \ 83 BOOL ret = _ProcessWindowMessage(hwnd, msg, w_param, l_param, l_result, \ 84 msg_map_id); \ 85 if (ref.get()) \ 86 msg_handled_ = old_msg_handled; \ 87 return ret; \ 88 } \ 89 BOOL _ProcessWindowMessage(HWND hWnd, \ 90 UINT uMsg, \ 91 WPARAM wParam, \ 92 LPARAM lParam, \ 93 LRESULT& lResult, \ 94 DWORD dwMsgMapID) { \ 95 base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr()); \ 96 BOOL bHandled = TRUE; \ 97 hWnd; \ 98 uMsg; \ 99 wParam; \ 100 lParam; \ 101 lResult; \ 102 bHandled; \ 103 switch(dwMsgMapID) { \ 104 case 0: 105 106 // An object that handles messages for a HWND that implements the views 107 // "Custom Frame" look. The purpose of this class is to isolate the windows- 108 // specific message handling from the code that wraps it. It is intended to be 109 // used by both a views::NativeWidget and an aura::WindowTreeHost 110 // implementation. 111 // TODO(beng): This object should eventually *become* the WindowImpl. 112 class VIEWS_EXPORT HWNDMessageHandler : 113 public gfx::WindowImpl, 114 public internal::InputMethodDelegate, 115 public ui::WindowEventTarget { 116 public: 117 explicit HWNDMessageHandler(HWNDMessageHandlerDelegate* delegate); 118 ~HWNDMessageHandler(); 119 120 void Init(HWND parent, const gfx::Rect& bounds); 121 void InitModalType(ui::ModalType modal_type); 122 123 void Close(); 124 void CloseNow(); 125 126 gfx::Rect GetWindowBoundsInScreen() const; 127 gfx::Rect GetClientAreaBoundsInScreen() const; 128 gfx::Rect GetRestoredBounds() const; 129 // This accounts for the case where the widget size is the client size. 130 gfx::Rect GetClientAreaBounds() const; 131 132 void GetWindowPlacement(gfx::Rect* bounds, 133 ui::WindowShowState* show_state) const; 134 135 // Sets the bounds of the HWND to |bounds_in_pixels|. If the HWND size is not 136 // changed, |force_size_changed| determines if we should pretend it is. 137 void SetBounds(const gfx::Rect& bounds_in_pixels, bool force_size_changed); 138 139 void SetSize(const gfx::Size& size); 140 void CenterWindow(const gfx::Size& size); 141 142 void SetRegion(HRGN rgn); 143 144 void StackAbove(HWND other_hwnd); 145 void StackAtTop(); 146 147 void Show(); 148 void ShowWindowWithState(ui::WindowShowState show_state); 149 void ShowMaximizedWithBounds(const gfx::Rect& bounds); 150 void Hide(); 151 152 void Maximize(); 153 void Minimize(); 154 void Restore(); 155 156 void Activate(); 157 void Deactivate(); 158 159 void SetAlwaysOnTop(bool on_top); 160 161 bool IsVisible() const; 162 bool IsActive() const; 163 bool IsMinimized() const; 164 bool IsMaximized() const; 165 bool IsAlwaysOnTop() const; 166 167 bool RunMoveLoop(const gfx::Vector2d& drag_offset, bool hide_on_escape); 168 void EndMoveLoop(); 169 170 // Tells the HWND its client area has changed. 171 void SendFrameChanged(); 172 173 void FlashFrame(bool flash); 174 175 void ClearNativeFocus(); 176 177 void SetCapture(); 178 void ReleaseCapture(); 179 bool HasCapture() const; 180 181 FullscreenHandler* fullscreen_handler() { return fullscreen_handler_.get(); } 182 183 void SetVisibilityChangedAnimationsEnabled(bool enabled); 184 185 // Returns true if the title changed. 186 bool SetTitle(const base::string16& title); 187 188 void SetCursor(HCURSOR cursor); 189 190 void FrameTypeChanged(); 191 192 void SchedulePaintInRect(const gfx::Rect& rect); 193 void SetOpacity(BYTE opacity); 194 195 void SetWindowIcons(const gfx::ImageSkia& window_icon, 196 const gfx::ImageSkia& app_icon); 197 198 void set_remove_standard_frame(bool remove_standard_frame) { 199 remove_standard_frame_ = remove_standard_frame; 200 } 201 202 void set_use_system_default_icon(bool use_system_default_icon) { 203 use_system_default_icon_ = use_system_default_icon; 204 } 205 206 void SetFullscreen(bool fullscreen); 207 208 // Updates the window style to reflect whether it can be resized or maximized. 209 void SizeConstraintsChanged(); 210 211 private: 212 typedef std::set<DWORD> TouchIDs; 213 214 // Overridden from internal::InputMethodDelegate: 215 virtual void DispatchKeyEventPostIME(const ui::KeyEvent& key) OVERRIDE; 216 217 // Overridden from WindowImpl: 218 virtual HICON GetDefaultWindowIcon() const OVERRIDE; 219 virtual LRESULT OnWndProc(UINT message, 220 WPARAM w_param, 221 LPARAM l_param) OVERRIDE; 222 223 // Overridden from WindowEventTarget 224 virtual LRESULT HandleMouseMessage(unsigned int message, 225 WPARAM w_param, 226 LPARAM l_param, 227 bool* handled) OVERRIDE; 228 virtual LRESULT HandleKeyboardMessage(unsigned int message, 229 WPARAM w_param, 230 LPARAM l_param, 231 bool* handled) OVERRIDE; 232 virtual LRESULT HandleTouchMessage(unsigned int message, 233 WPARAM w_param, 234 LPARAM l_param, 235 bool* handled) OVERRIDE; 236 237 virtual LRESULT HandleScrollMessage(unsigned int message, 238 WPARAM w_param, 239 LPARAM l_param, 240 bool* handled) OVERRIDE; 241 242 virtual LRESULT HandleNcHitTestMessage(unsigned int message, 243 WPARAM w_param, 244 LPARAM l_param, 245 bool* handled) OVERRIDE; 246 247 // Returns the auto-hide edges of the appbar. See 248 // ViewsDelegate::GetAppbarAutohideEdges() for details. If the edges change, 249 // OnAppbarAutohideEdgesChanged() is called. 250 int GetAppbarAutohideEdges(HMONITOR monitor); 251 252 // Callback if the autohide edges have changed. See 253 // ViewsDelegate::GetAppbarAutohideEdges() for details. 254 void OnAppbarAutohideEdgesChanged(); 255 256 // Can be called after the delegate has had the opportunity to set focus and 257 // did not do so. 258 void SetInitialFocus(); 259 260 // Called after the WM_ACTIVATE message has been processed by the default 261 // windows procedure. 262 void PostProcessActivateMessage(int activation_state, bool minimized); 263 264 // Enables disabled owner windows that may have been disabled due to this 265 // window's modality. 266 void RestoreEnabledIfNecessary(); 267 268 // Executes the specified SC_command. 269 void ExecuteSystemMenuCommand(int command); 270 271 // Start tracking all mouse events so that this window gets sent mouse leave 272 // messages too. 273 void TrackMouseEvents(DWORD mouse_tracking_flags); 274 275 // Responds to the client area changing size, either at window creation time 276 // or subsequently. 277 void ClientAreaSizeChanged(); 278 279 // Returns the insets of the client area relative to the non-client area of 280 // the window. 281 bool GetClientAreaInsets(gfx::Insets* insets) const; 282 283 // Resets the window region for the current widget bounds if necessary. 284 // If |force| is true, the window region is reset to NULL even for native 285 // frame windows. 286 void ResetWindowRegion(bool force, bool redraw); 287 288 // Enables or disables rendering of the non-client (glass) area by DWM, 289 // under Vista and above, depending on whether the caller has requested a 290 // custom frame. 291 void UpdateDwmNcRenderingPolicy(); 292 293 // Calls DefWindowProc, safely wrapping the call in a ScopedRedrawLock to 294 // prevent frame flicker. DefWindowProc handling can otherwise render the 295 // classic-look window title bar directly. 296 LRESULT DefWindowProcWithRedrawLock(UINT message, 297 WPARAM w_param, 298 LPARAM l_param); 299 300 // Lock or unlock the window from being able to redraw itself in response to 301 // updates to its invalid region. 302 class ScopedRedrawLock; 303 void LockUpdates(bool force); 304 void UnlockUpdates(bool force); 305 306 // Stops ignoring SetWindowPos() requests (see below). 307 void StopIgnoringPosChanges() { ignore_window_pos_changes_ = false; } 308 309 // Synchronously updates the invalid contents of the Widget. Valid for 310 // layered windows only. 311 void RedrawLayeredWindowContents(); 312 313 // Attempts to force the window to be redrawn, ensuring that it gets 314 // onscreen. 315 void ForceRedrawWindow(int attempts); 316 317 // Message Handlers ---------------------------------------------------------- 318 319 BEGIN_SAFE_MSG_MAP_EX(HWNDMessageHandler) 320 // Range handlers must go first! 321 CR_MESSAGE_RANGE_HANDLER_EX(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseRange) 322 CR_MESSAGE_RANGE_HANDLER_EX(WM_NCMOUSEMOVE, 323 WM_NCXBUTTONDBLCLK, 324 OnMouseRange) 325 326 // CustomFrameWindow hacks 327 CR_MESSAGE_HANDLER_EX(WM_NCUAHDRAWCAPTION, OnNCUAHDrawCaption) 328 CR_MESSAGE_HANDLER_EX(WM_NCUAHDRAWFRAME, OnNCUAHDrawFrame) 329 330 // Vista and newer 331 CR_MESSAGE_HANDLER_EX(WM_DWMCOMPOSITIONCHANGED, OnDwmCompositionChanged) 332 333 // Non-atlcrack.h handlers 334 CR_MESSAGE_HANDLER_EX(WM_GETOBJECT, OnGetObject) 335 336 // Mouse events. 337 CR_MESSAGE_HANDLER_EX(WM_MOUSEACTIVATE, OnMouseActivate) 338 CR_MESSAGE_HANDLER_EX(WM_MOUSELEAVE, OnMouseRange) 339 CR_MESSAGE_HANDLER_EX(WM_NCMOUSELEAVE, OnMouseRange) 340 CR_MESSAGE_HANDLER_EX(WM_SETCURSOR, OnSetCursor); 341 342 // Key events. 343 CR_MESSAGE_HANDLER_EX(WM_KEYDOWN, OnKeyEvent) 344 CR_MESSAGE_HANDLER_EX(WM_KEYUP, OnKeyEvent) 345 CR_MESSAGE_HANDLER_EX(WM_SYSKEYDOWN, OnKeyEvent) 346 CR_MESSAGE_HANDLER_EX(WM_SYSKEYUP, OnKeyEvent) 347 348 // IME Events. 349 CR_MESSAGE_HANDLER_EX(WM_IME_SETCONTEXT, OnImeMessages) 350 CR_MESSAGE_HANDLER_EX(WM_IME_STARTCOMPOSITION, OnImeMessages) 351 CR_MESSAGE_HANDLER_EX(WM_IME_COMPOSITION, OnImeMessages) 352 CR_MESSAGE_HANDLER_EX(WM_IME_ENDCOMPOSITION, OnImeMessages) 353 CR_MESSAGE_HANDLER_EX(WM_IME_REQUEST, OnImeMessages) 354 CR_MESSAGE_HANDLER_EX(WM_IME_NOTIFY, OnImeMessages) 355 CR_MESSAGE_HANDLER_EX(WM_CHAR, OnImeMessages) 356 CR_MESSAGE_HANDLER_EX(WM_SYSCHAR, OnImeMessages) 357 358 // Scroll events 359 CR_MESSAGE_HANDLER_EX(WM_VSCROLL, OnScrollMessage) 360 CR_MESSAGE_HANDLER_EX(WM_HSCROLL, OnScrollMessage) 361 362 // Touch Events. 363 CR_MESSAGE_HANDLER_EX(WM_TOUCH, OnTouchEvent) 364 365 // Uses the general handler macro since the specific handler macro 366 // MSG_WM_NCACTIVATE would convert WPARAM type to BOOL type. The high 367 // word of WPARAM could be set when the window is minimized or restored. 368 CR_MESSAGE_HANDLER_EX(WM_NCACTIVATE, OnNCActivate) 369 370 // This list is in _ALPHABETICAL_ order! OR I WILL HURT YOU. 371 CR_MSG_WM_ACTIVATEAPP(OnActivateApp) 372 CR_MSG_WM_APPCOMMAND(OnAppCommand) 373 CR_MSG_WM_CANCELMODE(OnCancelMode) 374 CR_MSG_WM_CAPTURECHANGED(OnCaptureChanged) 375 CR_MSG_WM_CLOSE(OnClose) 376 CR_MSG_WM_COMMAND(OnCommand) 377 CR_MSG_WM_CREATE(OnCreate) 378 CR_MSG_WM_DESTROY(OnDestroy) 379 CR_MSG_WM_DISPLAYCHANGE(OnDisplayChange) 380 CR_MSG_WM_ENTERMENULOOP(OnEnterMenuLoop) 381 CR_MSG_WM_EXITMENULOOP(OnExitMenuLoop) 382 CR_MSG_WM_ENTERSIZEMOVE(OnEnterSizeMove) 383 CR_MSG_WM_ERASEBKGND(OnEraseBkgnd) 384 CR_MSG_WM_EXITSIZEMOVE(OnExitSizeMove) 385 CR_MSG_WM_GETMINMAXINFO(OnGetMinMaxInfo) 386 CR_MSG_WM_INITMENU(OnInitMenu) 387 CR_MSG_WM_INPUTLANGCHANGE(OnInputLangChange) 388 CR_MSG_WM_KILLFOCUS(OnKillFocus) 389 CR_MSG_WM_MOVE(OnMove) 390 CR_MSG_WM_MOVING(OnMoving) 391 CR_MSG_WM_NCCALCSIZE(OnNCCalcSize) 392 CR_MSG_WM_NCHITTEST(OnNCHitTest) 393 CR_MSG_WM_NCPAINT(OnNCPaint) 394 CR_MSG_WM_NOTIFY(OnNotify) 395 CR_MSG_WM_PAINT(OnPaint) 396 CR_MSG_WM_SETFOCUS(OnSetFocus) 397 CR_MSG_WM_SETICON(OnSetIcon) 398 CR_MSG_WM_SETTEXT(OnSetText) 399 CR_MSG_WM_SETTINGCHANGE(OnSettingChange) 400 CR_MSG_WM_SIZE(OnSize) 401 CR_MSG_WM_SYSCOMMAND(OnSysCommand) 402 CR_MSG_WM_THEMECHANGED(OnThemeChanged) 403 CR_MSG_WM_WINDOWPOSCHANGED(OnWindowPosChanged) 404 CR_MSG_WM_WINDOWPOSCHANGING(OnWindowPosChanging) 405 CR_MSG_WM_WTSSESSION_CHANGE(OnSessionChange) 406 CR_END_MSG_MAP() 407 408 // Message Handlers. 409 // This list is in _ALPHABETICAL_ order! 410 // TODO(beng): Once this object becomes the WindowImpl, these methods can 411 // be made private. 412 void OnActivateApp(BOOL active, DWORD thread_id); 413 // TODO(beng): return BOOL is temporary until this object becomes a 414 // WindowImpl. 415 BOOL OnAppCommand(HWND window, short command, WORD device, int keystate); 416 void OnCancelMode(); 417 void OnCaptureChanged(HWND window); 418 void OnClose(); 419 void OnCommand(UINT notification_code, int command, HWND window); 420 LRESULT OnCreate(CREATESTRUCT* create_struct); 421 void OnDestroy(); 422 void OnDisplayChange(UINT bits_per_pixel, const gfx::Size& screen_size); 423 LRESULT OnDwmCompositionChanged(UINT msg, WPARAM w_param, LPARAM l_param); 424 void OnEnterMenuLoop(BOOL from_track_popup_menu); 425 void OnEnterSizeMove(); 426 LRESULT OnEraseBkgnd(HDC dc); 427 void OnExitMenuLoop(BOOL is_shortcut_menu); 428 void OnExitSizeMove(); 429 void OnGetMinMaxInfo(MINMAXINFO* minmax_info); 430 LRESULT OnGetObject(UINT message, WPARAM w_param, LPARAM l_param); 431 LRESULT OnImeMessages(UINT message, WPARAM w_param, LPARAM l_param); 432 void OnInitMenu(HMENU menu); 433 void OnInputLangChange(DWORD character_set, HKL input_language_id); 434 LRESULT OnKeyEvent(UINT message, WPARAM w_param, LPARAM l_param); 435 void OnKillFocus(HWND focused_window); 436 LRESULT OnMouseActivate(UINT message, WPARAM w_param, LPARAM l_param); 437 LRESULT OnMouseRange(UINT message, WPARAM w_param, LPARAM l_param); 438 void OnMove(const gfx::Point& point); 439 void OnMoving(UINT param, const RECT* new_bounds); 440 LRESULT OnNCActivate(UINT message, WPARAM w_param, LPARAM l_param); 441 LRESULT OnNCCalcSize(BOOL mode, LPARAM l_param); 442 LRESULT OnNCHitTest(const gfx::Point& point); 443 void OnNCPaint(HRGN rgn); 444 LRESULT OnNCUAHDrawCaption(UINT message, WPARAM w_param, LPARAM l_param); 445 LRESULT OnNCUAHDrawFrame(UINT message, WPARAM w_param, LPARAM l_param); 446 LRESULT OnNotify(int w_param, NMHDR* l_param); 447 void OnPaint(HDC dc); 448 LRESULT OnReflectedMessage(UINT message, WPARAM w_param, LPARAM l_param); 449 LRESULT OnScrollMessage(UINT message, WPARAM w_param, LPARAM l_param); 450 void OnSessionChange(WPARAM status_code, PWTSSESSION_NOTIFICATION session_id); 451 LRESULT OnSetCursor(UINT message, WPARAM w_param, LPARAM l_param); 452 void OnSetFocus(HWND last_focused_window); 453 LRESULT OnSetIcon(UINT size_type, HICON new_icon); 454 LRESULT OnSetText(const wchar_t* text); 455 void OnSettingChange(UINT flags, const wchar_t* section); 456 void OnSize(UINT param, const gfx::Size& size); 457 void OnSysCommand(UINT notification_code, const gfx::Point& point); 458 void OnThemeChanged(); 459 LRESULT OnTouchEvent(UINT message, WPARAM w_param, LPARAM l_param); 460 void OnWindowPosChanging(WINDOWPOS* window_pos); 461 void OnWindowPosChanged(WINDOWPOS* window_pos); 462 463 typedef std::vector<ui::TouchEvent> TouchEvents; 464 // Helper to handle the list of touch events passed in. We need this because 465 // touch events on windows don't fire if we enter a modal loop in the context 466 // of a touch event. 467 void HandleTouchEvents(const TouchEvents& touch_events); 468 469 // Resets the flag which indicates that we are in the context of a touch down 470 // event. 471 void ResetTouchDownContext(); 472 473 // Helper to handle mouse events. 474 // The |message|, |w_param|, |l_param| parameters identify the Windows mouse 475 // message and its parameters respectively. 476 // The |track_mouse| parameter indicates if we should track the mouse. 477 LRESULT HandleMouseEventInternal(UINT message, 478 WPARAM w_param, 479 LPARAM l_param, 480 bool track_mouse); 481 482 // Returns true if the mouse message passed in is an OS synthesized mouse 483 // message. 484 // |message| identifies the mouse message. 485 // |message_time| is the time when the message occurred. 486 // |l_param| indicates the location of the mouse message. 487 bool IsSynthesizedMouseMessage(unsigned int message, 488 int message_time, 489 LPARAM l_param); 490 491 // Provides functionality to transition a frame to DWM. 492 void PerformDwmTransition(); 493 494 HWNDMessageHandlerDelegate* delegate_; 495 496 scoped_ptr<FullscreenHandler> fullscreen_handler_; 497 498 // Set to true in Close() and false is CloseNow(). 499 bool waiting_for_close_now_; 500 501 bool remove_standard_frame_; 502 503 bool use_system_default_icon_; 504 505 // Whether all ancestors have been enabled. This is only used if is_modal_ is 506 // true. 507 bool restored_enabled_; 508 509 // The current cursor. 510 HCURSOR current_cursor_; 511 512 // The last cursor that was active before the current one was selected. Saved 513 // so that we can restore it. 514 HCURSOR previous_cursor_; 515 516 // Event handling ------------------------------------------------------------ 517 518 // The flags currently being used with TrackMouseEvent to track mouse 519 // messages. 0 if there is no active tracking. The value of this member is 520 // used when tracking is canceled. 521 DWORD active_mouse_tracking_flags_; 522 523 // Set to true when the user presses the right mouse button on the caption 524 // area. We need this so we can correctly show the context menu on mouse-up. 525 bool is_right_mouse_pressed_on_caption_; 526 527 // The set of touch devices currently down. 528 TouchIDs touch_ids_; 529 530 // ScopedRedrawLock ---------------------------------------------------------- 531 532 // Represents the number of ScopedRedrawLocks active against this widget. 533 // If this is greater than zero, the widget should be locked against updates. 534 int lock_updates_count_; 535 536 // Window resizing ----------------------------------------------------------- 537 538 // When true, this flag makes us discard incoming SetWindowPos() requests that 539 // only change our position/size. (We still allow changes to Z-order, 540 // activation, etc.) 541 bool ignore_window_pos_changes_; 542 543 // The last-seen monitor containing us, and its rect and work area. These are 544 // used to catch updates to the rect and work area and react accordingly. 545 HMONITOR last_monitor_; 546 gfx::Rect last_monitor_rect_, last_work_area_; 547 548 // Layered windows ----------------------------------------------------------- 549 550 // Should we keep an off-screen buffer? This is false by default, set to true 551 // when WS_EX_LAYERED is specified before the native window is created. 552 // 553 // NOTE: this is intended to be used with a layered window (a window with an 554 // extended window style of WS_EX_LAYERED). If you are using a layered window 555 // and NOT changing the layered alpha or anything else, then leave this value 556 // alone. OTOH if you are invoking SetLayeredWindowAttributes then you'll 557 // most likely want to set this to false, or after changing the alpha toggle 558 // the extended style bit to false than back to true. See MSDN for more 559 // details. 560 bool use_layered_buffer_; 561 562 // The default alpha to be applied to the layered window. 563 BYTE layered_alpha_; 564 565 // A canvas that contains the window contents in the case of a layered 566 // window. 567 scoped_ptr<gfx::Canvas> layered_window_contents_; 568 569 // We must track the invalid rect ourselves, for two reasons: 570 // For layered windows, Windows will not do this properly with 571 // InvalidateRect()/GetUpdateRect(). (In fact, it'll return misleading 572 // information from GetUpdateRect()). 573 // We also need to keep track of the invalid rectangle for the RootView should 574 // we need to paint the non-client area. The data supplied to WM_NCPAINT seems 575 // to be insufficient. 576 gfx::Rect invalid_rect_; 577 578 // Set to true when waiting for RedrawLayeredWindowContents(). 579 bool waiting_for_redraw_layered_window_contents_; 580 581 // True the first time nccalc is called on a sizable widget 582 bool is_first_nccalc_; 583 584 // Copy of custom window region specified via SetRegion(), if any. 585 base::win::ScopedRegion custom_window_region_; 586 587 // If > 0 indicates a menu is running (we're showing a native menu). 588 int menu_depth_; 589 590 // A factory used to lookup appbar autohide edges. 591 base::WeakPtrFactory<HWNDMessageHandler> autohide_factory_; 592 593 // Generates touch-ids for touch-events. 594 ui::SequentialIDGenerator id_generator_; 595 596 // Indicates if the window needs the WS_VSCROLL and WS_HSCROLL styles. 597 bool needs_scroll_styles_; 598 599 // Set to true if we are in the context of a sizing operation. 600 bool in_size_loop_; 601 602 // Stores a pointer to the WindowEventTarget interface implemented by this 603 // class. Allows callers to retrieve the interface pointer. 604 scoped_ptr<ui::ViewProp> prop_window_target_; 605 606 // Number of active touch down contexts. This is incremented on touch down 607 // events and decremented later using a delayed task. 608 // We need this to ignore WM_MOUSEACTIVATE messages generated in response to 609 // touch input. This is fine because activation still works correctly via 610 // native SetFocus calls invoked in the views code. 611 int touch_down_contexts_; 612 613 // Time the last touch message was received. Used to flag mouse messages 614 // synthesized by Windows for touch which are not flagged by the OS as 615 // synthesized mouse messages. For more information please refer to 616 // the IsMouseEventFromTouch function. 617 static long last_touch_message_time_; 618 619 // Time the last WM_MOUSEHWHEEL message is received. Please refer to the 620 // HandleMouseEventInternal function as to why this is needed. 621 long last_mouse_hwheel_time_; 622 623 // On Windows Vista and beyond, if we are transitioning from custom frame 624 // to Aero(glass) we delay setting the DWM related properties in full 625 // screen mode as DWM is not supported in full screen windows. We perform 626 // the DWM related operations when the window comes out of fullscreen mode. 627 // This member variable is set to true if the window is transitioning to 628 // glass. Defaults to false. 629 bool dwm_transition_desired_; 630 631 DISALLOW_COPY_AND_ASSIGN(HWNDMessageHandler); 632 }; 633 634 } // namespace views 635 636 #endif // UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_ 637
