Use proper format in wxGTK clipboard selection handler.

[wxWidgets.git] / include / wx / msw / window.h

diff --git a/include/wx/msw/window.h b/include/wx/msw/window.h
index 1ae0efd35c37552e0cb0f62d4daf3dad859f0de2..b465d05814e35d226364759208f0b42c7cb1a6b3 100644 (file)
--- a/include/wx/msw/window.h
+++ b/include/wx/msw/window.h
@@ -1,74 +1,57 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        window.h
-// Purpose:     wxWindow class
+// Name:        wx/msw/window.h
+// Purpose:     wxWindowMSW class

 // Author:      Julian Smart
 // Author:      Julian Smart

-// Modified by:
+// Modified by: Vadim Zeitlin on 13.05.99: complete refont of message handling,
+//              elimination of Default(), ...

 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Created:     01/02/97
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
+// Copyright:   (c) Julian Smart

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 

-// ---------------------------------------------------------------------------
-// headers
-// ---------------------------------------------------------------------------
+#include "wx/settings.h"        // solely for wxSystemColour

 
 

-#ifdef __GNUG__
-    #pragma interface "window.h"
+// if this is set to 1, we use deferred window sizing to reduce flicker when
+// resizing complicated window hierarchies, but this can in theory result in
+// different behaviour than the old code so we keep the possibility to use it
+// by setting this to 0 (in the future this should be removed completely)
+#ifdef __WXWINCE__
+    #define wxUSE_DEFERRED_SIZING 0
+#else
+    #define wxUSE_DEFERRED_SIZING 1

 #endif
 
 #endif
 

-// #include "wx/msw/winundef.h"
-
-// VZ: apparently some version of Windows send extra mouse move messages after
-//     a mouse click. My tests under NT 4.0 and 95 didn't show it so I'm
-//     tempted to think that it was just an effect of a poor mouse and so the
-//     code to work around this is currently disabled - just define this as 1
-//     to reenable it
-#define wxUSE_MOUSEEVENT_HACK 0
-
-// ---------------------------------------------------------------------------
-// forward declarations
-// ---------------------------------------------------------------------------
-
-class WXDLLEXPORT wxButton;
-
-// ---------------------------------------------------------------------------
-// constants
-// ---------------------------------------------------------------------------
-
-// FIXME does anybody use those? they're unused by wxWindows...
-enum
-{
-    wxKEY_SHIFT = 1,
-    wxKEY_CTRL  = 2
-};
-

 // ---------------------------------------------------------------------------
 // wxWindow declaration for MSW
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // wxWindow declaration for MSW
 // ---------------------------------------------------------------------------
 

-class WXDLLEXPORT wxWindow : public wxWindowBase
+class WXDLLIMPEXP_CORE wxWindowMSW : public wxWindowBase

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxWindow);
-
+    friend class wxSpinCtrl;
+    friend class wxSlider;
+    friend class wxRadioBox;
+#if defined __VISUALC__ && __VISUALC__ <= 1200
+    friend class wxWindowMSW;
+#endif

 public:
 public:

-    wxWindow() { Init(); }
-
-    wxWindow(wxWindow *parent,
-             wxWindowID id,
-             const wxPoint& pos = wxDefaultPosition,
-             const wxSize& size = wxDefaultSize,
-             long style = 0,
-             const wxString& name = wxPanelNameStr)
+    wxWindowMSW() { Init(); }
+
+    wxWindowMSW(wxWindow *parent,
+                wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxString& name = wxPanelNameStr)

     {
         Init();
         Create(parent, id, pos, size, style, name);
     }
 
     {
         Init();
         Create(parent, id, pos, size, style, name);
     }
 

-    virtual ~wxWindow();
+    virtual ~wxWindowMSW();

 
     bool Create(wxWindow *parent,
                 wxWindowID id,
 
     bool Create(wxWindow *parent,
                 wxWindowID id,


@@ -78,49 +61,60 @@ public:
                 const wxString& name = wxPanelNameStr);
 
     // implement base class pure virtuals
                 const wxString& name = wxPanelNameStr);
 
     // implement base class pure virtuals

-    virtual void SetTitle( const wxString& title);
-    virtual wxString GetTitle() const;
+    virtual void SetLabel(const wxString& label);
+    virtual wxString GetLabel() const;

 
     virtual void Raise();
     virtual void Lower();
 
 
     virtual void Raise();
     virtual void Lower();
 

-    virtual bool Show( bool show = TRUE );
-    virtual bool Enable( bool enable = TRUE );
+    virtual bool Show(bool show = true);
+    virtual bool ShowWithEffect(wxShowEffect effect,
+                                unsigned timeout = 0)
+    {
+        return MSWShowWithEffect(true, effect, timeout);
+    }
+    virtual bool HideWithEffect(wxShowEffect effect,
+                                unsigned timeout = 0)
+    {
+        return MSWShowWithEffect(false, effect, timeout);
+    }

 
     virtual void SetFocus();
 
     virtual void SetFocus();

+    virtual void SetFocusFromKbd();

 
 

-    virtual bool Reparent( wxWindow *newParent );
+    virtual bool Reparent(wxWindowBase *newParent);

 
     virtual void WarpPointer(int x, int y);
 
     virtual void WarpPointer(int x, int y);

-    virtual void CaptureMouse();
-    virtual void ReleaseMouse();

 
 

-    virtual void Refresh( bool eraseBackground = TRUE,
+    virtual void Refresh( bool eraseBackground = true,

                           const wxRect *rect = (const wxRect *) NULL );
                           const wxRect *rect = (const wxRect *) NULL );

-    virtual void Clear();
+    virtual void Update();

 
 

+    virtual void SetWindowStyleFlag(long style);
+    virtual void SetExtraStyle(long exStyle);

     virtual bool SetCursor( const wxCursor &cursor );
     virtual bool SetFont( const wxFont &font );
 
     virtual int GetCharHeight() const;
     virtual int GetCharWidth() const;
     virtual bool SetCursor( const wxCursor &cursor );
     virtual bool SetFont( const wxFont &font );
 
     virtual int GetCharHeight() const;
     virtual int GetCharWidth() const;

-    virtual void GetTextExtent(const wxString& string,
-                               int *x, int *y,
-                               int *descent = (int *) NULL,
-                               int *externalLeading = (int *) NULL,
-                               const wxFont *theFont = (const wxFont *) NULL)
-                               const;
-
-    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );

 
     virtual void SetScrollbar( int orient, int pos, int thumbVisible,
 
     virtual void SetScrollbar( int orient, int pos, int thumbVisible,

-                               int range, bool refresh = TRUE );
-    virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
+                               int range, bool refresh = true );
+    virtual void SetScrollPos( int orient, int pos, bool refresh = true );

     virtual int GetScrollPos( int orient ) const;
     virtual int GetScrollThumb( int orient ) const;
     virtual int GetScrollRange( int orient ) const;
     virtual void ScrollWindow( int dx, int dy,
     virtual int GetScrollPos( int orient ) const;
     virtual int GetScrollThumb( int orient ) const;
     virtual int GetScrollRange( int orient ) const;
     virtual void ScrollWindow( int dx, int dy,

-                               const wxRect* rect = (wxRect *) NULL );
+                               const wxRect* rect = NULL );
+
+    virtual bool ScrollLines(int lines);
+    virtual bool ScrollPages(int pages);
+
+    virtual void SetLayoutDirection(wxLayoutDirection dir);
+    virtual wxLayoutDirection GetLayoutDirection() const;
+    virtual wxCoord AdjustForLayoutDirection(wxCoord x,
+                                             wxCoord width,
+                                             wxCoord widthTotal) const;

 
 #if wxUSE_DRAG_AND_DROP
     virtual void SetDropTarget( wxDropTarget *dropTarget );
 
 #if wxUSE_DRAG_AND_DROP
     virtual void SetDropTarget( wxDropTarget *dropTarget );


@@ -129,68 +123,75 @@ public:
     // Accept files for dragging
     virtual void DragAcceptFiles(bool accept);
 
     // Accept files for dragging
     virtual void DragAcceptFiles(bool accept);
 

-#if WXWIN_COMPATIBILITY
-    // Set/get scroll attributes
-    virtual void SetScrollRange(int orient, int range, bool refresh = TRUE);
-    virtual void SetScrollPage(int orient, int page, bool refresh = TRUE);
-    virtual int OldGetScrollRange(int orient) const;
-    virtual int GetScrollPage(int orient) const;
-
-    // event handlers
-        // Handle a control command
-    virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
-
-        // Override to define new behaviour for default action (e.g. double
-        // clicking on a listbox)
-    virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { }
-#endif // WXWIN_COMPATIBILITY
-
-#if wxUSE_CARET && WXWIN_COMPATIBILITY
-    // caret manipulation (old MSW only functions, see wxCaret class for the
-    // new API)
-    void CreateCaret(int w, int h);
-    void CreateCaret(const wxBitmap *bitmap);
-    void DestroyCaret();
-    void ShowCaret(bool show);
-    void SetCaretPos(int x, int y);
-    void GetCaretPos(int *x, int *y) const;
-#endif // wxUSE_CARET
-
+#ifndef __WXUNIVERSAL__

     // Native resource loading (implemented in src/msw/nativdlg.cpp)
     // FIXME: should they really be all virtual?
     virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
     virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
     wxWindow* GetWindowChild1(wxWindowID id);
     wxWindow* GetWindowChild(wxWindowID id);
     // Native resource loading (implemented in src/msw/nativdlg.cpp)
     // FIXME: should they really be all virtual?
     virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
     virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
     wxWindow* GetWindowChild1(wxWindowID id);
     wxWindow* GetWindowChild(wxWindowID id);

+#endif // __WXUNIVERSAL__

 
 

-    // implementation from now on
-    // --------------------------
+#if wxUSE_HOTKEY
+    // install and deinstall a system wide hotkey
+    virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode);
+    virtual bool UnregisterHotKey(int hotkeyId);
+#endif // wxUSE_HOTKEY

 
 

-    // simple accessors
-    // ----------------
+#ifdef __POCKETPC__
+    bool IsContextMenuEnabled() const { return m_contextMenuEnabled; }
+    void EnableContextMenu(bool enable = true) { m_contextMenuEnabled = enable; }
+#endif
+
+    // window handle stuff
+    // -------------------

 
     WXHWND GetHWND() const { return m_hWnd; }
     void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
     virtual WXWidget GetHandle() const { return GetHWND(); }
 
 
     WXHWND GetHWND() const { return m_hWnd; }
     void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
     virtual WXWidget GetHandle() const { return GetHWND(); }
 

-    bool GetUseCtl3D() const { return m_useCtl3D; }
-    bool GetTransparentBackground() const { return m_backgroundTransparent; }
-    void SetTransparent(bool t = TRUE) { m_backgroundTransparent = t; }
+    void AssociateHandle(WXWidget handle);
+    void DissociateHandle();
+
+    // does this window have deferred position and/or size?
+    bool IsSizeDeferred() const;
+
+    // these functions allow to register a global handler for the given Windows
+    // message: it will be called from MSWWindowProc() of any window which gets
+    // this event if it's not processed before (i.e. unlike a hook procedure it
+    // does not override the normal processing)
+    //
+    // notice that if you want to process a message for a given window only you
+    // should override its MSWWindowProc() instead
+
+    // type of the handler: it is called with the message parameters (except
+    // that the window object is passed instead of window handle) and should
+    // return true if it handled the message or false if it should be passed to
+    // DefWindowProc()
+    typedef bool (*MSWMessageHandler)(wxWindowMSW *win,
+                                      WXUINT nMsg,
+                                      WXWPARAM wParam,
+                                      WXLPARAM lParam);
+
+    // install a handler, shouldn't be called more than one for the same message
+    static bool MSWRegisterMessageHandler(int msg, MSWMessageHandler handler);
+
+    // unregister a previously registered handler
+    static void MSWUnregisterMessageHandler(int msg, MSWMessageHandler handler);
+
+
+    // implementation from now on
+    // ==========================

 
     // event handlers
     // --------------
 
     // event handlers
     // --------------

-    void OnEraseBackground(wxEraseEvent& event);
-    void OnIdle(wxIdleEvent& event);

 
 

-public:
-    // For implementation purposes - sometimes decorations make the client area
-    // smaller
-    virtual wxPoint GetClientAreaOrigin() const;
-
-    // Makes an adjustment to the window position (for example, a frame that has
-    // a toolbar that it manages itself).
-    virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
+    void OnPaint(wxPaintEvent& event);
+#ifdef __WXWINCE__
+    void OnInitDialog(wxInitDialogEvent& event);
+#endif

 
 

+public:

     // Windows subclassing
     void SubclassWin(WXHWND hWnd);
     void UnsubclassWin();
     // Windows subclassing
     void SubclassWin(WXHWND hWnd);
     void UnsubclassWin();


@@ -198,40 +199,67 @@ public:
     WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; }
     void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; }
 
     WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; }
     void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; }
 

+    // return true if the window is of a standard (i.e. not wxWidgets') class
+    //
+    // to understand why does it work, look at SubclassWin() code and comments
+    bool IsOfStandardClass() const { return m_oldWndProc != NULL; }
+

     wxWindow *FindItem(long id) const;
     wxWindow *FindItem(long id) const;

-    wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = FALSE) const;
-
-    // Make a Windows extended style from the given wxWindows window style
-    static WXDWORD MakeExtendedStyle(long style,
-                                     bool eliminateBorders = TRUE);
-    // Determine whether 3D effects are wanted
-    WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D) const;
-
-    // MSW only: TRUE if this control is part of the main control
-    virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };
-
-    // returns TRUE if the window has been created
-    bool MSWCreate(int id,
-                   wxWindow *parent,
-                   const wxChar *wclass,
-                   wxWindow *wx_win,
-                   const wxChar *title,
-                   int x, int y, int width, int height,
-                   WXDWORD style,
-                   const wxChar *dialog_template = NULL,
+    wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = false) const;
+
+    // MSW only: true if this control is part of the main control
+    virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return false; }
+
+#if wxUSE_TOOLTIPS
+    // MSW only: true if this window or any of its children have a tooltip
+    virtual bool HasToolTips() const { return GetToolTip() != NULL; }
+#endif // wxUSE_TOOLTIPS
+
+    // translate wxWidgets style flags for this control into the Windows style
+    // and optional extended style for the corresponding native control
+    //
+    // this is the function that should be overridden in the derived classes,
+    // but you will mostly use MSWGetCreateWindowFlags() below
+    virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const ;
+
+    // get the MSW window flags corresponding to wxWidgets ones
+    //
+    // the functions returns the flags (WS_XXX) directly and puts the ext
+    // (WS_EX_XXX) flags into the provided pointer if not NULL
+    WXDWORD MSWGetCreateWindowFlags(WXDWORD *exflags = NULL) const
+        { return MSWGetStyle(GetWindowStyle(), exflags); }
+
+    // update the real underlying window style flags to correspond to the
+    // current wxWindow object style (safe to call even if window isn't fully
+    // created yet)
+    void MSWUpdateStyle(long flagsOld, long exflagsOld);
+
+    // get the HWND to be used as parent of this window with CreateWindow()
+    virtual WXHWND MSWGetParent() const;
+
+    // get the Win32 window class name used by all wxWindow objects by default
+    static const wxChar *MSWGetRegisteredClassName();
+
+    // creates the window of specified Windows class with given style, extended
+    // style, title and geometry (default values
+    //
+    // returns true if the window has been created, false if creation failed
+    bool MSWCreate(const wxChar *wclass,
+                   const wxChar *title = NULL,
+                   const wxPoint& pos = wxDefaultPosition,
+                   const wxSize& size = wxDefaultSize,
+                   WXDWORD style = 0,

                    WXDWORD exendedStyle = 0);
                    WXDWORD exendedStyle = 0);

-    virtual bool MSWCommand(WXUINT param, WXWORD id);

 
 

-#if WXWIN_COMPATIBILITY
-    wxObject *GetChild(int number) const;
-    virtual void MSWDeviceToLogical(float *x, float *y) const;
-#endif // WXWIN_COMPATIBILITY
+    virtual bool MSWCommand(WXUINT param, WXWORD id);

 
 

+#ifndef __WXUNIVERSAL__

     // Create an appropriate wxWindow from a HWND
     virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd);
 
     // Make sure the window style reflects the HWND style (roughly)
     virtual void AdoptAttributesFromHWND();
     // Create an appropriate wxWindow from a HWND
     virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd);
 
     // Make sure the window style reflects the HWND style (roughly)
     virtual void AdoptAttributesFromHWND();

+#endif // __WXUNIVERSAL__

 
     // Setup background and foreground colours correctly
     virtual void SetupColours();
 
     // Setup background and foreground colours correctly
     virtual void SetupColours();


@@ -249,13 +277,13 @@ public:
     void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
                       WXWORD *code, WXWORD *pos, WXHWND *hwnd);
     void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
     void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
                       WXWORD *code, WXWORD *pos, WXHWND *hwnd);
     void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,

-                        WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd);
+                        WXHDC *hdc, WXHWND *hwnd);

     void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                           WXWORD *item, WXWORD *flags, WXHMENU *hmenu);
 
     // ------------------------------------------------------------------------
     void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                           WXWORD *item, WXWORD *flags, WXHMENU *hmenu);
 
     // ------------------------------------------------------------------------

-    // internal handlers for MSW messages: all handlers return a boolen value:
-    // TRUE means that the handler processed the event and FALSE that it didn't
+    // internal handlers for MSW messages: all handlers return a boolean value:
+    // true means that the handler processed the event and false that it didn't

     // ------------------------------------------------------------------------
 
     // there are several cases where we have virtual functions for Windows
     // ------------------------------------------------------------------------
 
     // there are several cases where we have virtual functions for Windows


@@ -270,9 +298,7 @@ public:
                              WXWORD pos, WXHWND control);
 
     // child control notifications
                              WXWORD pos, WXHWND control);
 
     // child control notifications

-#ifdef __WIN95__

     virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
     virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);

-#endif // __WIN95__

 
     // owner-drawn controls need to process these messages
     virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item);
 
     // owner-drawn controls need to process these messages
     virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item);


@@ -284,30 +310,30 @@ public:
     bool HandleDestroy();
 
     bool HandlePaint();
     bool HandleDestroy();
 
     bool HandlePaint();

-    bool HandleEraseBkgnd(WXHDC pDC);
+    bool HandlePrintClient(WXHDC hDC);
+    bool HandleEraseBkgnd(WXHDC hDC);

 
     bool HandleMinimize();
     bool HandleMaximize();
     bool HandleSize(int x, int y, WXUINT flag);
 
     bool HandleMinimize();
     bool HandleMaximize();
     bool HandleSize(int x, int y, WXUINT flag);

+    bool HandleSizing(wxRect& rect);

     bool HandleGetMinMaxInfo(void *mmInfo);
     bool HandleGetMinMaxInfo(void *mmInfo);

+    bool HandleEnterSizeMove();
+    bool HandleExitSizeMove();

 
     bool HandleShow(bool show, int status);
     bool HandleActivate(int flag, bool minimized, WXHWND activate);
 
     bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
 
     bool HandleShow(bool show, int status);
     bool HandleActivate(int flag, bool minimized, WXHWND activate);
 
     bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);

-    bool HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam);

 
 

-    bool HandleCtlColor(WXHBRUSH *hBrush,
-                        WXHDC hdc,
-                        WXHWND hWnd,
-                        WXUINT nCtlColor,
-                        WXUINT message,
-                        WXWPARAM wParam,
-                        WXLPARAM lParam);
+    bool HandleCtlColor(WXHBRUSH *hBrush, WXHDC hdc, WXHWND hWnd);

 
     bool HandlePaletteChanged(WXHWND hWndPalChange);
     bool HandleQueryNewPalette();
     bool HandleSysColorChange();
 
     bool HandlePaletteChanged(WXHWND hWndPalChange);
     bool HandleQueryNewPalette();
     bool HandleSysColorChange();

+    bool HandleDisplayChange();
+    bool HandleCaptureChanged(WXHWND gainedCapture);
+    virtual bool HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam);

 
     bool HandleQueryEndSession(long logOff, bool *mayEnd);
     bool HandleEndSession(bool endSession, long logOff);
 
     bool HandleQueryEndSession(long logOff, bool *mayEnd);
     bool HandleEndSession(bool endSession, long logOff);


@@ -319,40 +345,162 @@ public:
 
     bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags);
     bool HandleMouseMove(int x, int y, WXUINT flags);
 
     bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags);
     bool HandleMouseMove(int x, int y, WXUINT flags);

-
-    bool HandleChar(WXWORD wParam, WXLPARAM lParam, bool isASCII = FALSE);
-    bool HandleKeyDown(WXWORD wParam, WXLPARAM lParam);
-    bool HandleKeyUp(WXWORD wParam, WXLPARAM lParam);
+    bool HandleMouseWheel(wxMouseWheelAxis axis,
+                          WXWPARAM wParam, WXLPARAM lParam);
+
+    bool HandleChar(WXWPARAM wParam, WXLPARAM lParam);
+    bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam);
+    bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam);
+#if wxUSE_ACCEL
+    bool HandleHotKey(WXWPARAM wParam, WXLPARAM lParam);
+#endif
+#ifdef __WIN32__
+    int HandleMenuChar(int chAccel, WXLPARAM lParam);
+#endif
+    // Create and process a clipboard event specified by type.
+    bool HandleClipboardEvent( WXUINT nMsg );

 
     bool HandleQueryDragIcon(WXHICON *hIcon);
 
     bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg);
 
 
     bool HandleQueryDragIcon(WXHICON *hIcon);
 
     bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg);
 

-    // Window procedure
-    virtual long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+    bool HandlePower(WXWPARAM wParam, WXLPARAM lParam, bool *vetoed);
+
+
+    // The main body of common window proc for all wxWindow objects. It tries
+    // to handle the given message and returns true if it was handled (the
+    // appropriate return value is then put in result, which must be non-NULL)
+    // or false if it wasn't.
+    //
+    // This function should be overridden in any new code instead of
+    // MSWWindowProc() even if currently most of the code overrides
+    // MSWWindowProc() as it had been written before this function was added.
+    virtual bool MSWHandleMessage(WXLRESULT *result,
+                                  WXUINT message,
+                                  WXWPARAM wParam,
+                                  WXLPARAM lParam);
+
+    // Common Window procedure for all wxWindow objects: forwards to
+    // MSWHandleMessage() and MSWDefWindowProc() if the message wasn't handled.
+    virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);

 
     // Calls an appropriate default window procedure
 
     // Calls an appropriate default window procedure

-    virtual long MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+    virtual WXLRESULT MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+
+    // message processing helpers
+
+    // return false if the message shouldn't be translated/preprocessed but
+    // dispatched normally
+    virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg);
+
+    // return true if the message was preprocessed and shouldn't be dispatched

     virtual bool MSWProcessMessage(WXMSG* pMsg);
     virtual bool MSWProcessMessage(WXMSG* pMsg);

+
+    // return true if the message was translated and shouldn't be dispatched

     virtual bool MSWTranslateMessage(WXMSG* pMsg);
     virtual bool MSWTranslateMessage(WXMSG* pMsg);

+
+    // called when the window is about to be destroyed

     virtual void MSWDestroyWindow();
 
     virtual void MSWDestroyWindow();
 

-    // Detach "Window" menu from menu bar so it doesn't get deleted
-    void MSWDetachWindowMenu();

 
 

-    // this function should return the brush to paint the window background
-    // with or 0 for the default brush
-    virtual WXHBRUSH OnCtlColor(WXHDC hDC,
-                                WXHWND hWnd,
-                                WXUINT nCtlColor,
-                                WXUINT message,
-                                WXWPARAM wParam,
-                                WXLPARAM lParam);
+    // Functions dealing with painting the window background. The derived
+    // classes should normally only need to reimplement MSWGetBgBrush() if they
+    // need to use a non-solid brush for erasing their background. This
+    // function is called by MSWGetBgBrushForChild() which only exists for the
+    // weird wxToolBar case and MSWGetBgBrushForChild() itself is used by
+    // MSWGetBgBrush() to actually find the right brush to use.
+
+    // The brush returned from here must remain valid at least until the next
+    // event loop iteration. Returning 0, as is done by default, indicates
+    // there is no custom background brush.
+    virtual WXHBRUSH MSWGetCustomBgBrush() { return 0; }
+
+    // this function should return the brush to paint the children controls
+    // background or 0 if this window doesn't impose any particular background
+    // on its children
+    //
+    // the hDC parameter is the DC background will be drawn on, it can be used
+    // to call SetBrushOrgEx() on it if the returned brush is a bitmap one
+    //
+    // child parameter is never NULL, it can be this window itself or one of
+    // its (grand)children
+    //
+    // the base class version returns a solid brush if we have a non default
+    // background colour or 0 otherwise
+    virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child);
+
+    // return the background brush to use for painting the given window by
+    // querying the parent windows via MSWGetBgBrushForChild() recursively
+    WXHBRUSH MSWGetBgBrush(WXHDC hDC);
+
+    enum MSWThemeColour
+    {
+        ThemeColourText = 0,
+        ThemeColourBackground,
+        ThemeColourBorder
+    };
+
+    // returns a specific theme colour, or if that is not possible then
+    // wxSystemSettings::GetColour(fallback)
+    wxColour MSWGetThemeColour(const wchar_t *themeName,
+                               int themePart,
+                               int themeState,
+                               MSWThemeColour themeColour,
+                               wxSystemColour fallback) const;
+
+    // gives the parent the possibility to draw its children background, e.g.
+    // this is used by wxNotebook to do it using DrawThemeBackground()
+    //
+    // return true if background was drawn, false otherwise
+    virtual bool MSWPrintChild(WXHDC WXUNUSED(hDC), wxWindow * WXUNUSED(child))
+    {
+        return false;
+    }

 
 

-#if WXWIN_COMPATIBILITY
-    void SetShowing(bool show) { (void)Show(show); }
-    bool IsUserEnabled() const { return IsEnabled(); }
-#endif // WXWIN_COMPATIBILITY
+    // some controls (e.g. wxListBox) need to set the return value themselves
+    //
+    // return true to let parent handle it if we don't, false otherwise
+    virtual bool MSWShouldPropagatePrintChild()
+    {
+        return true;
+    }
+
+    // This should be overridden to return true for the controls which have
+    // themed background that should through their children. Currently only
+    // wxNotebook uses this.
+    //
+    // The base class version already returns true if we have a solid
+    // background colour that should be propagated to our children.
+    virtual bool MSWHasInheritableBackground() const
+    {
+        return InheritsBackgroundColour();
+    }
+
+#if !defined(__WXWINCE__) && !defined(__WXUNIVERSAL__)
+    #define wxHAS_MSW_BACKGROUND_ERASE_HOOK
+#endif
+
+#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
+    // allows the child to hook into its parent WM_ERASEBKGND processing: call
+    // MSWSetEraseBgHook() with a non-NULL window to make parent call
+    // MSWEraseBgHook() on this window (don't forget to reset it to NULL
+    // afterwards)
+    //
+    // this hack is used by wxToolBar, see comments there
+    void MSWSetEraseBgHook(wxWindow *child);
+
+    // return true if WM_ERASEBKGND is currently hooked
+    bool MSWHasEraseBgHook() const;
+
+    // called when the window on which MSWSetEraseBgHook() had been called
+    // receives WM_ERASEBKGND
+    virtual bool MSWEraseBgHook(WXHDC WXUNUSED(hDC)) { return false; }
+#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
+
+    // common part of Show/HideWithEffect()
+    bool MSWShowWithEffect(bool show,
+                           wxShowEffect effect,
+                           unsigned timeout);

 
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);


@@ -360,7 +508,38 @@ public:
     // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
     void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags);
 
     // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
     void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags);
 

+    // check if mouse is in the window
+    bool IsMouseInWindow() const;
+
+    // check if a native double-buffering applies for this window
+    virtual bool IsDoubleBuffered() const;
+
+    void SetDoubleBuffered(bool on);
+
+    // synthesize a wxEVT_LEAVE_WINDOW event and set m_mouseInWindow to false
+    void GenerateMouseLeave();
+
+    // virtual function for implementing internal idle
+    // behaviour
+    virtual void OnInternalIdle();
+

 protected:
 protected:

+    // this allows you to implement standard control borders without
+    // repeating the code in different classes that are not derived from
+    // wxControl
+    virtual wxBorder GetDefaultBorderForControl() const;
+
+    // choose the default border for this window
+    virtual wxBorder GetDefaultBorder() const;
+
+    // Translate wxBORDER_THEME (and other border styles if necessary to the value
+    // that makes most sense for this Windows environment
+    virtual wxBorder TranslateBorder(wxBorder border) const;
+
+#if wxUSE_MENUS_NATIVE
+    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
+#endif // wxUSE_MENUS_NATIVE
+

     // the window handle
     WXHWND                m_hWnd;
 
     // the window handle
     WXHWND                m_hWnd;
 


@@ -368,29 +547,19 @@ protected:
     WXFARPROC             m_oldWndProc;
 
     // additional (MSW specific) flags
     WXFARPROC             m_oldWndProc;
 
     // additional (MSW specific) flags

-    bool                  m_useCtl3D:1; // Using CTL3D for this control
-    bool                  m_backgroundTransparent:1;

     bool                  m_mouseInWindow:1;
     bool                  m_mouseInWindow:1;

-    bool                  m_doubleClickAllowed:1;
-    bool                  m_winCaptured:1;
+    bool                  m_lastKeydownProcessed:1;

 
     // the size of one page for scrolling
     int                   m_xThumbSize;
     int                   m_yThumbSize;
 
 
     // the size of one page for scrolling
     int                   m_xThumbSize;
     int                   m_yThumbSize;
 

-#if wxUSE_MOUSEEVENT_HACK
-    // the coordinates of the last mouse event and the type of it
-    long                  m_lastMouseX,
-                          m_lastMouseY;
-    int                   m_lastMouseEvent;
-#endif // wxUSE_MOUSEEVENT_HACK
-
-    WXHMENU               m_hMenu; // Menu, if any
-
-    // the return value of WM_GETDLGCODE handler
-    long m_lDlgCode;
-

     // implement the base class pure virtuals
     // implement the base class pure virtuals

+    virtual void DoGetTextExtent(const wxString& string,
+                                 int *x, int *y,
+                                 int *descent = NULL,
+                                 int *externalLeading = NULL,
+                                 const wxFont *font = NULL) const;

     virtual void DoClientToScreen( int *x, int *y ) const;
     virtual void DoScreenToClient( int *x, int *y ) const;
     virtual void DoGetPosition( int *x, int *y ) const;
     virtual void DoClientToScreen( int *x, int *y ) const;
     virtual void DoScreenToClient( int *x, int *y ) const;
     virtual void DoGetPosition( int *x, int *y ) const;


@@ -401,9 +570,23 @@ protected:
                            int sizeFlags = wxSIZE_AUTO);
     virtual void DoSetClientSize(int width, int height);
 
                            int sizeFlags = wxSIZE_AUTO);
     virtual void DoSetClientSize(int width, int height);
 

-    // get the size which best suits the window: e.g., for a static text it
-    // will be the width and height of the text
-    virtual wxSize DoGetBestSize();
+    virtual wxSize DoGetBorderSize() const;
+
+    virtual void DoCaptureMouse();
+    virtual void DoReleaseMouse();
+
+    virtual void DoEnable(bool enable);
+
+    virtual void DoFreeze();
+    virtual void DoThaw();
+
+    // this simply moves/resizes the given HWND which is supposed to be our
+    // sibling (this is useful for controls which are composite at MSW level
+    // and for which DoMoveWindow() is not enough)
+    //
+    // returns true if the window move was deferred, false if it was moved
+    // immediately (no error return)
+    bool DoMoveSibling(WXHWND hwnd, int x, int y, int width, int height);

 
     // move the window to the specified location and resize it: this is called
     // from both DoSetSize() and DoSetClientSize() and would usually just call
 
     // move the window to the specified location and resize it: this is called
     // from both DoSetSize() and DoSetClientSize() and would usually just call


@@ -413,31 +596,107 @@ protected:
 
 #if wxUSE_TOOLTIPS
     virtual void DoSetToolTip( wxToolTip *tip );
 
 #if wxUSE_TOOLTIPS
     virtual void DoSetToolTip( wxToolTip *tip );

+
+    // process TTN_NEEDTEXT message properly (i.e. fixing the bugs in
+    // comctl32.dll in our code -- see the function body for more info)
+    bool HandleTooltipNotify(WXUINT code,
+                             WXLPARAM lParam,
+                             const wxString& ttip);

 #endif // wxUSE_TOOLTIPS
 
 #endif // wxUSE_TOOLTIPS
 

+    // This is used by CreateKeyEvent() and also for wxEVT_CHAR[_HOOK] event
+    // creation. Notice that this method doesn't initialize wxKeyEvent
+    // m_keyCode and m_uniChar fields.
+    void InitAnyKeyEvent(wxKeyEvent& event,
+                         WXWPARAM wParam,
+                         WXLPARAM lParam) const;
+
+    // Helper functions used by HandleKeyXXX() methods and some derived
+    // classes, wParam and lParam have the same meaning as in WM_KEY{DOWN,UP}.
+    //
+    // NB: evType here must be wxEVT_KEY_{DOWN,UP} as wParam here contains the
+    //     virtual key code, not character!
+    wxKeyEvent CreateKeyEvent(wxEventType evType,
+                              WXWPARAM wParam,
+                              WXLPARAM lParam = 0) const;
+
+    // Another helper for creating wxKeyEvent for wxEVT_CHAR and related types.
+    //
+    // The wParam and lParam here must come from WM_CHAR event parameters, i.e.
+    // wParam must be a character and not a virtual code.
+    wxKeyEvent CreateCharEvent(wxEventType evType,
+                               WXWPARAM wParam,
+                               WXLPARAM lParam) const;
+
+
+    // default OnEraseBackground() implementation, return true if we did erase
+    // the background, false otherwise (i.e. the system should erase it)
+    bool DoEraseBackground(WXHDC hDC);
+
+    // generate WM_CHANGEUISTATE if it's needed for the OS we're running under
+    //
+    // action should be one of the UIS_XXX constants
+    // state should be one or more of the UISF_XXX constants
+    // if action == UIS_INITIALIZE then it doesn't seem to matter what we use
+    // for state as the system will decide for us what needs to be set
+    void MSWUpdateUIState(int action, int state = 0);
+
+    // translate wxWidgets coords into Windows ones suitable to be passed to
+    // ::CreateWindow(), called from MSWCreate()
+    virtual void MSWGetCreateWindowCoords(const wxPoint& pos,
+                                          const wxSize& size,
+                                          int& x, int& y,
+                                          int& w, int& h) const;
+
+    bool MSWEnableHWND(WXHWND hWnd, bool enable);
+

 private:
     // common part of all ctors
     void Init();
 
     // the (non-virtual) handlers for the events
     bool HandleMove(int x, int y);
 private:
     // common part of all ctors
     void Init();
 
     // the (non-virtual) handlers for the events
     bool HandleMove(int x, int y);

+    bool HandleMoving(wxRect& rect);

     bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);
     bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);

-
-#ifdef __WIN95__

     bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
     bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);

-#endif // __WIN95__

 
 

-    DECLARE_NO_COPY_CLASS(wxWindow);
-    DECLARE_EVENT_TABLE()
-};
+#if wxUSE_DEFERRED_SIZING
+protected:
+    // this function is called after the window was resized to its new size
+    virtual void MSWEndDeferWindowPos()
+    {
+        m_pendingPosition = wxDefaultPosition;
+        m_pendingSize = wxDefaultSize;
+    }

 
 

-// ---------------------------------------------------------------------------
-// global functions
-// ---------------------------------------------------------------------------
+    // current defer window position operation handle (may be NULL)
+    WXHANDLE m_hDWP;

 
 

-// kbd code translation
-WXDLLEXPORT int wxCharCodeMSWToWX(int keySym);
-WXDLLEXPORT int wxCharCodeWXToMSW(int id, bool *IsVirtual);
+    // When deferred positioning is done these hold the pending changes, and
+    // are used for the default values if another size/pos changes is done on
+    // this window before the group of deferred changes is completed.
+    wxPoint     m_pendingPosition;
+    wxSize      m_pendingSize;
+#endif // wxUSE_DEFERRED_SIZING

 
 

+private:
+#ifdef __POCKETPC__
+    bool        m_contextMenuEnabled;

 #endif
 #endif

-    // _WX_WINDOW_H_
+
+    DECLARE_DYNAMIC_CLASS(wxWindowMSW)
+    wxDECLARE_NO_COPY_CLASS(wxWindowMSW);
+    DECLARE_EVENT_TABLE()
+};
+
+// window creation helper class: before creating a new HWND, instantiate an
+// object of this class on stack - this allows to process the messages sent to
+// the window even before CreateWindow() returns
+class wxWindowCreationHook
+{
+public:
+    wxWindowCreationHook(wxWindowMSW *winBeingCreated);
+    ~wxWindowCreationHook();
+};
+
+#endif // _WX_WINDOW_H_