| OLD | NEW |
|---|
| (Empty) |
| 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_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
