Home | History | Annotate | Download | only in win 
      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