wxWindow split (MSW part of changes)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2384 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/msw/cursor.h

@@ -54,9 +54,9 @@ public:
 
   virtual bool Ok(void) const { return (m_refData != NULL && M_CURSORDATA->m_hCursor) ; }
 
-  inline wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
+  wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
-  inline bool operator == (const wxCursor& cursor) { return m_refData == cursor.m_refData; }
+  bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
-  inline bool operator != (const wxCursor& cursor) { return m_refData != cursor.m_refData; }
+  bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
 
   void SetHCURSOR(WXHCURSOR cursor);
   inline WXHCURSOR GetHCURSOR(void) const { return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0); }

include/wx/msw/dialog.h

@@ -60,6 +60,9 @@ public:
 
     ~wxDialog();
 
+    void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
+    int GetReturnCode() const { return m_returnCode; }
+
     virtual bool Destroy();
 
     virtual void DoSetClientSize(int width, int height);
@@ -125,6 +128,8 @@ protected:
     WXHWND                m_hwndToolTip;
 #endif // tooltips
 
+    int m_returnCode;
+
     DECLARE_EVENT_TABLE()
 };
 

include/wx/msw/font.h

@@ -89,9 +89,9 @@ public:
   void SetFaceName(const wxString& faceName);
   void SetUnderlined(bool underlined);
 
-  inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
+  wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
-  inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; }
+  bool operator == (const wxFont& font) const { return m_refData == font.m_refData; }
-  inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; }
+  bool operator != (const wxFont& font) const { return m_refData != font.m_refData; }
 
 protected:
   void Unshare();

include/wx/msw/frame.h

@@ -19,6 +19,7 @@
 #include "wx/window.h"
 #include "wx/toolbar.h"
 #include "wx/msw/accel.h"
+#include "wx/icon.h"
 
 WXDLLEXPORT_DATA(extern const wxChar*) wxFrameNameStr;
 WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
@@ -56,15 +57,6 @@ public:
 
     virtual bool Destroy();
 
-    void GetClientSize(int *width, int *height) const;
-    void GetSize(int *width, int *height) const ;
-    void GetPosition(int *x, int *y) const ;
-
-    wxSize GetSize() const { return wxWindow::GetSize(); }
-    wxPoint GetPosition() const { return wxWindow::GetPosition(); }
-    wxSize GetClientSize() const { return wxWindow::GetClientSize(); }
-    wxRect GetClientRect() const { return wxWindow::GetClientRect(); }
-
     virtual void ClientToScreen(int *x, int *y) const;
     virtual void ScreenToClient(int *x, int *y) const;
 
@@ -182,6 +174,10 @@ public:
 #endif // tooltips
 
 protected:
+    void DoGetClientSize(int *width, int *height) const;
+    void DoGetSize(int *width, int *height) const ;
+    void DoGetPosition(int *x, int *y) const ;
+
     // propagate our state change to all child frames
     void IconizeChildFrames(bool bIconize);
 

include/wx/msw/gauge95.h

@@ -57,8 +57,8 @@ public:
     int GetRange(void) const ;
     int GetValue(void) const ;
 
-    void SetForegroundColour(const wxColour& col);
+    bool SetForegroundColour(const wxColour& col);
-    void SetBackgroundColour(const wxColour& col);
+    bool SetBackgroundColour(const wxColour& col);
 
     // Backward compatibility
 #if WXWIN_COMPATIBILITY

include/wx/msw/listctrl.h

@@ -204,7 +204,7 @@ class WXDLLEXPORT wxListCtrl: public wxControl
 
   // Sets the background colour (GetBackgroundColour already implicit in
   // wxWindow class)
-  void SetBackgroundColour(const wxColour& col);
+  bool SetBackgroundColour(const wxColour& col);
 
   // Gets information about this column
   bool GetColumn(int col, wxListItem& item) const;

include/wx/msw/mdi.h

@@ -65,12 +65,6 @@ class WXDLLEXPORT wxMDIParentFrame: public wxFrame
 
   void SetMenuBar(wxMenuBar *menu_bar);
 
-  // Gets the size available for subwindows after menu size, toolbar size
-  // and status bar size have been subtracted. If you want to manage your own
-  // toolbar(s), don't call SetToolBar.
-  void GetClientSize(int *width, int *height) const;
-  wxSize GetClientSize() const { return wxWindow::GetClientSize(); }
-
   // Get the active MDI child window (Windows only)
   wxMDIChildFrame *GetActiveChild(void) const ;
 
@@ -106,6 +100,11 @@ class WXDLLEXPORT wxMDIParentFrame: public wxFrame
   void OnSysColourChanged(wxSysColourChangedEvent& event);
 
  protected:
+  // Gets the size available for subwindows after menu size, toolbar size
+  // and status bar size have been subtracted. If you want to manage your own
+  // toolbar(s), don't call SetToolBar.
+  void DoGetClientSize(int *width, int *height) const;
+
     wxMDIClientWindow *             m_clientWindow;
     wxMDIChildFrame *               m_currentChild;
     WXHMENU                         m_windowMenu;
@@ -148,12 +147,6 @@ class WXDLLEXPORT wxMDIChildFrame: public wxFrame
   // Set menu bar
   void SetMenuBar(wxMenuBar *menu_bar);
 
-  void SetClientSize(int width, int height);
-  void SetClientSize(const wxSize& sz) { wxWindow::SetClientSize(sz); }
-
-  void GetPosition(int *x, int *y) const ;
-  wxPoint GetPosition() const { return wxWindow::GetPosition(); }
-
   // MDI operations
   virtual void Maximize(void);
   virtual void Restore(void);
@@ -172,8 +165,10 @@ class WXDLLEXPORT wxMDIChildFrame: public wxFrame
 
     // Implementation
     bool ResetWindowStyle(void *vrect);
- protected:
+
-//    bool            m_active;
+protected:
+  void DoGetPosition(int *x, int *y) const ;
+  void DoSetClientSize(int width, int height);
 };
 
 class WXDLLEXPORT wxMDIClientWindow: public wxWindow

include/wx/msw/private.h

@@ -84,10 +84,10 @@ typedef signed short int SHORT ;
 #endif
 
 #if wxUSE_PENWIN
-WXDLLEXPORT void wxRegisterPenWin();
+    WXDLLEXPORT void wxRegisterPenWin();
-WXDLLEXPORT void wxCleanUpPenWin();
+    WXDLLEXPORT void wxCleanUpPenWin();
-WXDLLEXPORT void wxEnablePenAppHooks (bool hook);
+    WXDLLEXPORT void wxEnablePenAppHooks (bool hook);
-#endif
+#endif // wxUSE_PENWIN
 
 #if wxUSE_ITSY_BITSY
 #define IBS_HORZCAPTION    0x4000L
@@ -167,6 +167,12 @@ WXDLLEXPORT void wxAddControlHandle(WXHWND hWnd, wxWindow *item);
 // Safely get the window text (i.e. without using fixed size buffer)
 WXDLLEXPORT extern wxString wxGetWindowText(WXHWND hWnd);
 
+// get the window class name
+WXDLLEXPORT extern wxString wxGetWindowClass(WXHWND hWnd);
+
+// get the window id
+WXDLLEXPORT extern wxWindowID wxGetWindowId(WXHWND hWnd);
+
 // Does this window style specify any border?
 inline bool wxStyleHasBorder(long style)
 {
@@ -182,18 +188,21 @@ inline bool wxStyleHasBorder(long style)
   #define WS_EX_CLIENTEDGE 0x00000200L
 #endif
 
+// ---------------------------------------------------------------------------
+// debug messages
+// ---------------------------------------------------------------------------
 #if defined(__WIN95__) && defined(__WXDEBUG__) && wxUSE_DBWIN32
 
-#ifndef __TWIN32__
+    #ifndef __TWIN32__
-#ifdef OutputDebugString
+        #ifdef OutputDebugString
-#undef OutputDebugString
+            #undef OutputDebugString
-#endif
+        #endif
 
-#define OutputDebugString OutputDebugStringW95
+        #define OutputDebugString OutputDebugStringW95
-#endif
+    #endif // __TWIN32__
 
-extern void OutputDebugStringW95(const wxChar*, ...);
+    extern void OutputDebugStringW95(const wxChar*, ...);
-#endif
+#endif // USE_DBWIN32
 
 #endif
     // _WX_PRIVATE_H_

include/wx/msw/radiobox.h

@@ -73,7 +73,7 @@ public:
     wxString GetLabel(int item) const;
     bool Show(bool show);
     void SetFocus();
-    void Enable(bool enable);
+    bool Enable(bool enable);
     void Enable(int item, bool enable);
     void Show(int item, bool show);
     void SetLabelFont(const wxFont& WXUNUSED(font)) {};

include/wx/msw/tbar95.h

@@ -70,14 +70,13 @@ class WXDLLEXPORT wxToolBar95: public wxToolBarBase
   wxSize GetMaxSize(void) const;
 
   void GetSize(int *w, int *y) const;
-  wxSize GetSize() const { return wxWindow::GetSize(); }
 
   virtual bool GetToolState(int toolIndex) const;
 
   // Add all the buttons: required for Win95.
   virtual bool CreateTools(void);
   virtual void SetRows(int nRows);
-  virtual void Layout(void) {}
+  virtual void LayoutButtons(void) {}
 
   // The post-tool-addition call
   bool Realize() { return CreateTools(); };

include/wx/msw/tbarmsw.h

@@ -65,7 +65,7 @@ public:
   // The button size is bigger than the bitmap size
   wxSize GetToolSize(void) const;
 
-  void Layout(void);
+  void LayoutTools();
 
   // The post-tool-addition call
   bool Realize() { Layout(); return TRUE; };

include/wx/msw/window.h

@@ -12,123 +12,52 @@
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma interface "window.h"
+    #pragma interface "window.h"
 #endif
 
-#include "wx/gdicmn.h"
+// windows.h #defines the following identifiers which are also used in wxWin
-#include "wx/icon.h"
-#include "wx/cursor.h"
-#include "wx/pen.h"
-#include "wx/font.h"
-#include "wx/validate.h"
-#include "wx/event.h"
-#include "wx/string.h"
-#include "wx/list.h"
-#include "wx/region.h"
-#include "wx/msw/accel.h"
-#include "wx/intl.h"
-
-#define wxKEY_SHIFT     1
-#define wxKEY_CTRL      2
-
-/*
- * Base class for frame, panel, canvas, panel items, dialog box.
- *
- */
-
-/*
- * Event handler: windows have themselves as their event handlers
- * by default, but their event handlers could be set to another
- * object entirely. This separation can reduce the amount of
- * derivation required, and allow alteration of a window's functionality
- * (e.g. by a resource editor that temporarily switches event handlers).
- */
-
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxEvent;
-class WXDLLEXPORT wxCommandEvent;
-class WXDLLEXPORT wxKeyEvent;
-class WXDLLEXPORT wxControl;
-class WXDLLEXPORT wxCursor;
-class WXDLLEXPORT wxColourMap;
-class WXDLLEXPORT wxFont;
-class WXDLLEXPORT wxMenu;
-class WXDLLEXPORT wxRect;
-class WXDLLEXPORT wxBitmap;
-class WXDLLEXPORT wxSizer;
-class WXDLLEXPORT wxList;
-class WXDLLEXPORT wxLayoutConstraints;
-class WXDLLEXPORT wxMouseEvent;
-class WXDLLEXPORT wxButton;
-class WXDLLEXPORT wxColour;
-class WXDLLEXPORT wxBrush;
-class WXDLLEXPORT wxPen;
-class WXDLLEXPORT wxIcon;
-class WXDLLEXPORT wxDC;
-class WXDLLEXPORT wxValidator;
-class WXDLLEXPORT wxToolTip;
-
-#if wxUSE_DRAG_AND_DROP
-class WXDLLEXPORT wxDropTarget;
-#endif
-
-#if wxUSE_WX_RESOURCES
-class WXDLLEXPORT wxResourceTable;
-class WXDLLEXPORT wxItemResource;
-#endif
-
-WXDLLEXPORT_DATA(extern const wxChar*) wxPanelNameStr;
-
-WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
-WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
-
-//-----------------------------------------------------------------------------
-// wxClientData
-//-----------------------------------------------------------------------------
-
-class wxClientData
-{
-public:
-    wxClientData() { }
-    virtual ~wxClientData() { }
-};
-
-//-----------------------------------------------------------------------------
-// wxStringClientData
-//-----------------------------------------------------------------------------
-
-class wxStringClientData: public wxClientData
-{
-public:
-    wxStringClientData() { }
-    wxStringClientData( wxString &data ) { m_data = data; }
-    void SetData( wxString &data ) { m_data = data; }
-    wxString GetData() const { return m_data; }
-
-private:
-    wxString  m_data;
-};
-
-// Clash with Windows headers
 #ifdef GetCharWidth
-#undef GetCharWidth
+    #undef GetCharWidth
 #endif
 
 #ifdef FindWindow
-#undef FindWindow
+    #undef FindWindow
 #endif
 
-class WXDLLEXPORT wxWindow : public wxEvtHandler
+// ---------------------------------------------------------------------------
-{
+// forward declarations
-    DECLARE_ABSTRACT_CLASS(wxWindow)
+// ---------------------------------------------------------------------------
 
-    friend class wxDC;
+class WXDLLEXPORT wxButton;
-    friend class wxPaintDC;
+
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+
+// FIXME does anybody use those? they're unused by wxWindows...
+enum
+{
+    wxKEY_SHIFT = 1,
+    wxKEY_CTRL  = 2
+};
+
+// ---------------------------------------------------------------------------
+// wxWindow declaration for MSW
+// ---------------------------------------------------------------------------
+class WXDLLEXPORT wxWindow : public wxWindowBase
+{
+    DECLARE_DYNAMIC_CLASS(wxWindow);
 
 public:
-    wxWindow();
+    wxWindow() { Init(); }
-    wxWindow(wxWindow *parent, wxWindowID id,
+
+    wxWindow(wxWindow *parent,
+             wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = 0,
@@ -140,229 +69,74 @@ public:
 
     virtual ~wxWindow();
 
-    bool Create(wxWindow *parent, wxWindowID id,
+    bool Create(wxWindow *parent,
+                wxWindowID id,
                 const wxPoint& pos = wxDefaultPosition,
                 const wxSize& size = wxDefaultSize,
                 long style = 0,
                 const wxString& name = wxPanelNameStr);
 
-    // Fit the window around the items
+    // implement base class pure virtuals
-    virtual void Fit();
-
-    // Show or hide the window
-    virtual bool Show(bool show);
-
-    // Is the window shown?
-    virtual bool IsShown() const;
-
-    // Raise the window to the top of the Z order
     virtual void Raise();
-
-    // Lower the window to the bottom of the Z order
     virtual void Lower();
 
-    // Is the window enabled?
+    virtual bool Show( bool show = TRUE );
-    virtual bool IsEnabled() const;
+    virtual bool Enable( bool enable = TRUE );
 
-    // For compatibility
-    inline bool Enabled() const { return IsEnabled(); }
-
-    // Dialog support: override these and call
-    // base class members to add functionality
-    // that can't be done using validators.
-
-    // Transfer values to controls. If returns FALSE,
-    // it's an application error (pops up a dialog)
-    virtual bool TransferDataToWindow();
-
-    // Transfer values from controls. If returns FALSE,
-    // transfer failed: don't quit
-    virtual bool TransferDataFromWindow();
-
-    // Validate controls. If returns FALSE,
-    // validation failed: don't quit
-    virtual bool Validate();
-
-    // Return code for dialogs
-    inline void SetReturnCode(int retCode);
-    inline int GetReturnCode();
-
-    // Set the cursor
-    virtual void SetCursor(const wxCursor& cursor);
-    inline virtual wxCursor& GetCursor() const { return (wxCursor& ) m_windowCursor; };
-
-    // Get the window with the focus
-    static wxWindow *FindFocus();
-
-    // Get character size
-    virtual int GetCharHeight() const;
-    virtual int GetCharWidth() const;
-
-    // moving/resizing
-    // ---------------
-
-    // set the window size and/or position
-    void SetSize( int x, int y, int width, int height,
-            int sizeFlags = wxSIZE_AUTO )
-        {  DoSetSize(x, y, width, height, sizeFlags); }
-
-    void SetSize( int width, int height )
-        { DoSetSize(-1, -1, width, height, wxSIZE_USE_EXISTING); }
-
-    void SetSize( const wxSize& size )
-        { SetSize(size.x, size.y); }
-
-    void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
-        { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
-
-    void Move( int x, int y )
-        { DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); }
-
-    void Move(const wxPoint& pt)
-        { Move(pt.x, pt.y); }
-
-    // client size is the size of area available for subwindows
-    void SetClientSize( int width, int height )
-        { DoSetClientSize(width, height); }
-
-    void SetClientSize( const wxSize& size )
-        { DoSetClientSize(size.x, size.y); }
-
-    void SetClientSize(const wxRect& rect)
-        { SetClientSize( rect.width, rect.height ); }
-
-    // get the window position and/or size
-    virtual void GetPosition( int *x, int *y ) const;
-    wxPoint GetPosition() const
-    {
-        int w, h;
-        GetPosition(& w, & h);
-
-        return wxPoint(w, h);
-    }
-
-    virtual void GetSize( int *width, int *height ) const;
-
-    wxSize GetSize() const
-    {
-        int w, h;
-        GetSize(& w, & h);
-        return wxSize(w, h);
-    }
-
-    wxRect GetRect() const
-    {
-        int x, y, w, h;
-        GetPosition(& x, & y);
-        GetSize(& w, & h);
-
-        return wxRect(x, y, w, h);
-    }
-
-    virtual void GetClientSize( int *width, int *height ) const;
-    wxSize GetClientSize() const
-    {
-        int w, h;
-        GetClientSize(& w, & h);
-        return wxSize(w, h);
-    }
-
-    wxRect GetClientRect() const
-    {
-        int w, h;
-        GetSize(& w, & h);
-
-        return wxRect(0, 0, w, h);
-    }
-
-    // Convert client to screen coordinates
-    virtual void ClientToScreen(int *x, int *y) const;
-    wxPoint ClientToScreen(const wxPoint& pt) const
-    { int x = pt.x; int y = pt.y; ClientToScreen(& x, & y); return wxPoint(x, y); }
-
-    // Convert screen to client coordinates
-    virtual void ScreenToClient(int *x, int *y) const;
-    wxPoint ScreenToClient(const wxPoint& pt) const
-    { int x = pt.x; int y = pt.y; ScreenToClient(& x, & y); return wxPoint(x, y); }
-
-    // Set the focus to this window
     virtual void SetFocus();
 
-    // Capture/release mouse
+    virtual bool Reparent( wxWindow *newParent );
+
+    virtual void WarpPointer(int x, int y);
     virtual void CaptureMouse();
     virtual void ReleaseMouse();
 
-    // Enable or disable the window
+    virtual void Refresh( bool eraseBackground = TRUE,
-    virtual void Enable(bool enable);
+                          const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
+
+    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 void ClientToScreen( int *x, int *y ) const;
+    virtual void ScreenToClient( int *x, int *y ) const;
+
+    virtual bool PopupMenu( wxMenu *menu, int x, int y );
+
+    virtual void SetScrollbar( int orient, int pos, int thumbVisible,
+                               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,
+                               const wxRect* rect = (wxRect *) NULL );
 
 #if wxUSE_DRAG_AND_DROP
-    // Associate a drop target with this window (if the window already had a drop
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
-    // target, it's deleted!) and return the current drop target (may be NULL).
+#endif // wxUSE_DRAG_AND_DROP
-    void          SetDropTarget(wxDropTarget *pDropTarget);
-    wxDropTarget *GetDropTarget() const { return m_pDropTarget; }
-#endif
-
-#if wxUSE_TOOLTIPS
-    // tooltips
-    // create a tooltip with this text
-    void SetToolTip(const wxString &tip);
-    // pointer may be NULL to remove the tooltip
-    void SetToolTip(wxToolTip *tooltip);
-    // get the current tooltip (may return NULL if none)
-    wxToolTip* GetToolTip() const { return m_tooltip; }
-
-#endif // wxUSE_TOOLTIPS
 
     // Accept files for dragging
     virtual void DragAcceptFiles(bool accept);
 
-    // Update region access
-    virtual wxRegion GetUpdateRegion() const;
-    virtual bool IsExposed(int x, int y, int w, int h) const;
-    virtual bool IsExposed(const wxPoint& pt) const;
-    virtual bool IsExposed(const wxRect& rect) const;
-
-    // Set/get the window title
-    virtual inline void SetTitle(const wxString& WXUNUSED(title)) {};
-    inline virtual wxString GetTitle() const { return wxString(""); };
-    // Most windows have the concept of a label; for frames, this is the
-    // title; for items, this is the label or button text.
-    inline virtual wxString GetLabel() const { return GetTitle(); }
-
-    // Set/get the window name (used for resource setting in X)
-    inline virtual wxString GetName() const;
-    inline virtual void SetName(const wxString& name);
-
-    // Centre the window
-    virtual void Centre(int direction) ;
-    inline void Center(int direction = wxHORIZONTAL) { Centre(direction); }
-
-    // Popup a menu
-    virtual bool PopupMenu(wxMenu *menu, int x, int y);
-
-    // Send the window a refresh event
-    virtual void Refresh(bool eraseBack = TRUE, const wxRect *rect = NULL);
-
 #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;
-#endif
+#endif // WXWIN_COMPATIBILITY
 
-    // New functions that will replace the above.
+    // caret manipulation (MSW only)
-    virtual void SetScrollbar(int orient, int pos, int thumbVisible,
-            int range, bool refresh = TRUE);
-
-    virtual void SetScrollPos(int orient, int pos, bool refresh = TRUE);
-    virtual int GetScrollPos(int orient) const;
-    virtual int GetScrollRange(int orient) const;
-    virtual int GetScrollThumb(int orient) const;
-
-    virtual void ScrollWindow(int dx, int dy, const wxRect *rect = NULL);
-
-    // Caret manipulation
     virtual void CreateCaret(int w, int h);
     virtual void CreateCaret(const wxBitmap *bitmap);
     virtual void DestroyCaret();
@@ -370,140 +144,36 @@ public:
     virtual void SetCaretPos(int x, int y);
     virtual void GetCaretPos(int *x, int *y) const;
 
-    // Tell window how much it can be sized
+    // event handlers (FIXME: shouldn't they be inside WXWIN_COMPATIBILITY?)
-    virtual void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1);
-
-    // Set/get the window's identifier
-    inline int GetId() const;
-    inline void SetId(int id);
-
-    // Make the window modal (all other windows unresponsive)
-    virtual void MakeModal(bool modal);
-
-    // Get the private handle (platform-dependent)
-    inline void *GetHandle() const;
-
-    // Set/get the window's relatives
-    inline wxWindow *GetParent() const;
-    inline void SetParent(wxWindow *p) ;
-    inline wxWindow *GetGrandParent() const;
-    inline wxList& GetChildren() const;
-    // Set this window to be the child of 'parent'.
-    // Returns FALSE it's not possible (some systems
-    // won't allow it)
-    virtual bool Reparent(wxWindow *parent);
-
-    // Set/get the window's font
-    virtual void SetFont(const wxFont& f);
-    inline virtual wxFont& GetFont() const;
-
-    // Set/get the window's validator
-    void SetValidator(const wxValidator& validator);
-    inline wxValidator *GetValidator() const;
-
-    // Set/get the window's style
-    inline void SetWindowStyleFlag(long flag);
-    inline long GetWindowStyleFlag() const;
-
-    // Set/get double-clickability
-    // TODO: we probably wish to get rid of this, and
-    // always allow double clicks.
-    inline void SetDoubleClick(bool flag);
-    inline bool GetDoubleClick() const;
-    inline void AllowDoubleClick(bool value)  { SetDoubleClick(value); }
-
         // Handle a control command
     virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
 
-    // Set/get event handler
+        // Override to define new behaviour for default action (e.g. double
-    inline void SetEventHandler(wxEvtHandler *handler);
+        // clicking on a listbox)
-    inline wxEvtHandler *GetEventHandler() const;
-
-    // Push/pop event handler (i.e. allow a chain of event handlers
-    // be searched)
-    void PushEventHandler(wxEvtHandler *handler) ;
-    wxEvtHandler *PopEventHandler(bool deleteHandler = FALSE) ;
-
-    // Close the window by calling OnClose, posting a deletion
-    virtual bool Close(bool force = FALSE);
-
-    // Destroy the window (delayed, if a managed window)
-    virtual bool Destroy() ;
-
-    // Mode for telling default OnSize members to
-    // call Layout(), if not using Sizers, just top-down constraints
-    inline void SetAutoLayout(bool a);
-    inline bool GetAutoLayout() const;
-
-    // Set/get constraints
-    inline wxLayoutConstraints *GetConstraints() const;
-    void SetConstraints(wxLayoutConstraints *c);
-
-    // Set/get window background colour
-    inline virtual void SetBackgroundColour(const wxColour& col);
-    inline virtual wxColour GetBackgroundColour() const;
-
-    // Set/get window foreground colour
-    inline virtual void SetForegroundColour(const wxColour& col);
-    inline virtual wxColour GetForegroundColour() const;
-
-    // For backward compatibility
-    inline virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
-    inline virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
-    inline virtual wxFont& GetLabelFont() const { return GetFont(); };
-    inline virtual wxFont& GetButtonFont() const { return GetFont(); };
-
-    // Get the default button, if there is one
-    inline virtual wxButton *GetDefaultItem() const;
-    inline virtual void SetDefaultItem(wxButton *but);
-
-    virtual void SetAcceleratorTable(const wxAcceleratorTable& accel);
-    inline virtual wxAcceleratorTable& GetAcceleratorTable() const { return (wxAcceleratorTable&) m_acceleratorTable; }
-
-    // Override to define new behaviour for default action (e.g. double clicking
-    // on a listbox)
     virtual void OnDefaultAction(wxControl *initiatingItem);
 
-    // Resource loading
+    // Native resource loading (implemented in src/msw/nativdlg.cpp)
-#if wxUSE_WX_RESOURCES
+    // FIXME: should they really be all virtual?
-    virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL);
-    virtual wxControl *CreateItem(const wxItemResource* childResource, const wxItemResource* parentResource, const wxResourceTable *table = NULL);
-#endif
-
-    // Native resource loading
     virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
     virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
-    virtual wxWindow* GetWindowChild1(wxWindowID& id);
+    virtual wxWindow* GetWindowChild1(wxWindowID id);
-    virtual wxWindow* GetWindowChild(wxWindowID& id);
+    virtual wxWindow* GetWindowChild(wxWindowID id);
 
-    virtual void GetTextExtent(const wxString& string, int *x, int *y,
+    // implementation from now on
-            int *descent = NULL,
+    // --------------------------
-            int *externalLeading = NULL,
-            const wxFont *theFont = NULL, bool use16 = FALSE) const;
 
-    // Is the window retained?
+    // simple accessors
-    inline bool IsRetained() const;
+    // ----------------
 
-    // Warp the pointer the given position
+    WXHWND GetHWND() const { return GetHandle(); }
-    virtual void WarpPointer(int x_pos, int y_pos) ;
+    void SetHWND(WXHWND hWnd) { m_widget = hWnd; }
 
-    // Clear the window
+    bool GetUseCtl3D() const { return m_useCtl3D; }
-    virtual void Clear();
+    bool GetTransparentBackground() const { return m_backgroundTransparent; }
-
+    void SetTransparent(bool t = TRUE) { m_backgroundTransparent = t; }
-    // Find a window by id or name
-    virtual wxWindow *FindWindow(long id);
-    virtual wxWindow *FindWindow(const wxString& name);
-
-    // Constraint operations
-    bool Layout();
-    void SetSizer(wxSizer *sizer);    // Adds sizer child to this window
-    inline wxSizer *GetSizer() const ;
-    inline wxWindow *GetSizerParent() const ;
-    inline void SetSizerParent(wxWindow *win);
-
-    // Do Update UI processing for controls
-    void UpdateWindowUI();
 
+    // event handlers
+    // --------------
     void OnEraseBackground(wxEraseEvent& event);
     void OnKeyDown(wxKeyEvent& event);
     void OnKeyUp(wxKeyEvent& event);
@@ -511,14 +181,12 @@ public:
     void OnChar(wxKeyEvent& event);
     void OnIdle(wxIdleEvent& event);
 
-    // Does this window want to accept keyboard focus?
+    // a window may have a default button
-    virtual bool AcceptsFocus() const;
+    // TODO move into wxPanel and/or wxFrame
+    wxButton *GetDefaultItem() const { return m_btnDefault; }
+    void SetDefaultItem(wxButton *btn) { m_btnDefault = btn; }
 
-    virtual void PrepareDC( wxDC& WXUNUSED(dc) ) {};
 public:
-    ////////////////////////////////////////////////////////////////////////
-    //// IMPLEMENTATION
-
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;
@@ -539,62 +207,15 @@ public:
     virtual wxWindow *FindItem(int id) const;
     virtual wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = FALSE) const ;
     virtual void PreDelete(WXHDC dc);              // Allows system cleanup
-    // TO DO: how many of these need to be virtual?
-    virtual WXHWND GetHWND() const ;
-    virtual void SetHWND(WXHWND hWnd);
 
     // Make a Windows extended style from the given wxWindows window style
     virtual WXDWORD MakeExtendedStyle(long style, bool eliminateBorders = TRUE);
     // Determine whether 3D effects are wanted
     virtual WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D);
 
-    virtual void AddChild(wxWindow *child);         // Adds reference to the child object
-    virtual void RemoveChild(wxWindow *child);   // Removes reference to child
-    // (but doesn't delete the child object)
-    virtual void DestroyChildren();  // Removes and destroys all children
-
-    inline bool IsBeingDeleted();
-
     // MSW only: TRUE if this control is part of the main control
     virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };
 
-    // Constraint implementation
-    void UnsetConstraints(wxLayoutConstraints *c);
-    inline wxList *GetConstraintsInvolvedIn() const ;
-    // Back-pointer to other windows we're involved with, so if we delete
-    // this window, we must delete any constraints we're involved with.
-    void AddConstraintReference(wxWindow *otherWin);
-    void RemoveConstraintReference(wxWindow *otherWin);
-    void DeleteRelatedConstraints();
-
-    virtual void ResetConstraints();
-    virtual void SetConstraintSizes(bool recurse = TRUE);
-    virtual bool LayoutPhase1(int *noChanges);
-    virtual bool LayoutPhase2(int *noChanges);
-    virtual bool DoPhase(int);
-    // Transforms from sizer coordinate space to actual
-    // parent coordinate space
-    virtual void TransformSizerToActual(int *x, int *y) const ;
-
-    // Set size with transformation to actual coordinates if nec.
-    virtual void SizerSetSize(int x, int y, int w, int h);
-    virtual void SizerMove(int x, int y);
-
-    // Only set/get the size/position of the constraint (if any)
-    virtual void SetSizeConstraint(int x, int y, int w, int h);
-    virtual void MoveConstraint(int x, int y);
-    virtual void GetSizeConstraint(int *w, int *h) const ;
-    virtual void GetClientSizeConstraint(int *w, int *h) const ;
-    virtual void GetPositionConstraint(int *x, int *y) const ;
-
-    // Dialog units translations. Implemented in wincmn.cpp.
-    wxPoint ConvertPixelsToDialog(const wxPoint& pt) ;
-    wxPoint ConvertDialogToPixels(const wxPoint& pt) ;
-    inline wxSize ConvertPixelsToDialog(const wxSize& sz)
-    { wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
-    inline wxSize ConvertDialogToPixels(const wxSize& sz)
-    { wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
-
     wxObject *GetChild(int number) const ;
 
     void MSWCreate(int id, wxWindow *parent, const char *wclass, wxWindow *wx_win, const char *title,
@@ -702,185 +323,85 @@ public:
     virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
             WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
 
-    inline void SetShowing(bool show);
+#if WXWIN_COMPATIBILITY
-    inline bool IsUserEnabled() const;
+    void SetShowing(bool show) { (void)Show(show); }
-    inline bool GetUseCtl3D() const ;
+    bool IsUserEnabled() const { return IsEnabled(); }
-    inline bool GetTransparentBackground() const ;
+#endif // WXWIN_COMPATIBILITY
 
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
-    // Transfers data to any child controls
+    // remember the parameters of the last message
-    void OnInitDialog(wxInitDialogEvent& event);
+    void PushLastMessage(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
+    {
+        m_lastMsg = msg;
+        m_lastWParam = wParam;
+        m_lastLParam = lParam;
+    }
 
-    // Sends an OnInitDialog event, which in turns transfers data to
-    // to the window via validators.
-    virtual void InitDialog();
-
-    ////////////////////////////////////////////////////////////////////////
-    //// PROTECTED DATA
 protected:
-    wxAcceleratorTable    m_acceleratorTable;
+    // the old window proc (we subclass all windows)
-    int                   m_windowId;
-    long                  m_windowStyle;                         // Store the window's style
-    wxEvtHandler *        m_windowEventHandler;         // Usually is 'this'
-    wxLayoutConstraints * m_constraints;           // Constraints for this window
-    wxList *              m_constraintsInvolvedIn; // List of constraints we're involved in
-    wxSizer *             m_windowSizer;                       // Window's top-level sizer (if any)
-    wxWindow *            m_sizerParent;                      // Window's parent sizer (if any)
-    bool                  m_autoLayout;                            // Whether to call Layout() in OnSize
-    wxWindow *            m_windowParent;                     // Each window always knows its parent
-    wxValidator *         m_windowValidator;
-    // Old window proc, for subclassed controls
     WXFARPROC             m_oldWndProc;
-    bool                  m_useCtl3D;             // Using CTL3D for this control
 
-    bool                  m_inOnSize;                         // Protection against OnSize reentry
+    // additional (MSW specific) flags
-#ifndef _WX_WIN32__
+    bool                  m_useCtl3D:1; // Using CTL3D for this control
-    // Pointer to global memory, for EDIT controls that need
+    bool                  m_inOnSize:1; // Protection against OnSize reentry
-    // special treatment to reduce USER area consumption.
+    bool                  m_backgroundTransparent:1;
-    WXHGLOBAL             m_globalHandle;
+    bool                  m_mouseInWindow:1;
-#endif
+    bool                  m_doubleClickAllowed:1;
-
+    bool                  m_winCaptured:1;
-    bool                  m_winEnabled;
-    int                   m_minSizeX;
-    int                   m_minSizeY;
-    int                   m_maxSizeX;
-    int                   m_maxSizeY;
 
     // Caret data
+    bool                  m_caretEnabled:1;
+    bool                  m_caretShown:1;
     int                   m_caretWidth;
     int                   m_caretHeight;
-    bool                  m_caretEnabled;
-    bool                  m_caretShown;
-    wxFont                m_windowFont;                               // Window's font
-    bool                  m_isShown;
-    bool                  m_doubleClickAllowed ;
-    wxCursor              m_windowCursor;                        // Window's cursor
-    bool                  m_winCaptured;
-    wxString              m_windowName;                            // Window name
-
-#if wxUSE_EXTENDED_STATICS
-    wxList                m_staticItems;
-#endif
-
-    wxButton *            m_defaultItem;
-    wxColour              m_backgroundColour ;
-    wxColour              m_foregroundColour ;
-    bool                  m_backgroundTransparent;
 
+    // the size of one page for scrolling
     int                   m_xThumbSize;
     int                   m_yThumbSize;
 
-    float                 m_lastXPos;
+    // the coordinates of the last mouse event and the typoe of it
-    float                 m_lastYPos;
+    long                  m_lastMouseX,
-    int                   m_lastEvent;
+                          m_lastMouseY;
+    int                   m_lastMouseEvent;
 
-    bool                  m_mouseInWindow;
+    // the parameters of the last message used in Default()
-
-#if wxUSE_DRAG_AND_DROP
-    wxDropTarget         *m_pDropTarget;    // the current drop target or NULL
-#endif  //USE_DRAG_AND_DROP
-
-public:
-    WXHWND                m_hWnd;                         // MS Windows window handle
     WXUINT                m_lastMsg;
     WXWPARAM              m_lastWParam;
     WXLPARAM              m_lastLParam;
 
-    wxRegion              m_updateRegion;
-    /*
-       wxRect           m_updateRect;             // Bounding box for screen damage area
-#ifdef __WIN32__
-WXHRGN                m_updateRgn;                  // NT allows access to the rectangle list
-#endif
-     */
-
-    //  WXHANDLE              m_acceleratorTable;
     WXHMENU               m_hMenu; // Menu, if any
-    wxList *              m_children;                           // Window's children
-    int                   m_returnCode;
-    bool                  m_isBeingDeleted; // Fudge because can't access parent
-    // when being deleted
 
-    // this is the virtual function to be overriden in any derived class which
+    wxButton             *m_btnDefault;
-    // wants to change how SetSize() or Move() works - it is called by all
+
-    // versions of these functions in the base class
+    // implement the base class pure virtuals
+    virtual void DoGetPosition( int *x, int *y ) const;
+    virtual void DoGetSize( int *width, int *height ) const;
+    virtual void DoGetClientSize( int *width, int *height ) const;
     virtual void DoSetSize(int x, int y,
                            int width, int height,
                            int sizeFlags = wxSIZE_AUTO);
-
-    // same as DoSetSize() for the client size
     virtual void DoSetClientSize(int width, int height);
 
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip( wxToolTip *tip );
+#endif // wxUSE_TOOLTIPS
+
 private:
     // common part of all ctors
     void Init();
 
-    // the associated tooltip (may be NULL if none)
-#if wxUSE_TOOLTIPS
-    wxToolTip *m_tooltip;
-#endif // tooltips
-
     DECLARE_EVENT_TABLE()
 };
 
-////////////////////////////////////////////////////////////////////////
+// ---------------------------------------------------------------------------
-//// INLINES
+// global functions
-
+// ---------------------------------------------------------------------------
-inline void *wxWindow::GetHandle() const { return (void *)GetHWND(); }
-inline int wxWindow::GetId() const { return m_windowId; }
-inline void wxWindow::SetId(int id) { m_windowId = id; }
-inline wxWindow *wxWindow::GetParent() const { return m_windowParent; }
-inline void wxWindow::SetParent(wxWindow *p) { m_windowParent = p; }
-inline wxWindow *wxWindow::GetGrandParent() const { return (m_windowParent ? m_windowParent->m_windowParent : (wxWindow*) NULL); }
-inline wxList& wxWindow::GetChildren() const { return (wxList&) *m_children; }
-inline wxFont& wxWindow::GetFont() const { return (wxFont&) m_windowFont; }
-inline wxString wxWindow::GetName() const { return m_windowName; }
-inline void wxWindow::SetName(const wxString& name) { m_windowName = name; }
-inline long wxWindow::GetWindowStyleFlag() const { return m_windowStyle; }
-inline void wxWindow::SetWindowStyleFlag(long flag) { m_windowStyle = flag; }
-inline void wxWindow::SetDoubleClick(bool flag) { m_doubleClickAllowed = flag; }
-inline bool wxWindow::GetDoubleClick() const { return m_doubleClickAllowed; }
-inline void wxWindow::SetEventHandler(wxEvtHandler *handler) { m_windowEventHandler = handler; }
-inline wxEvtHandler *wxWindow::GetEventHandler() const { return m_windowEventHandler; }
-inline void wxWindow::SetAutoLayout(bool a) { m_autoLayout = a; }
-inline bool wxWindow::GetAutoLayout() const { return m_autoLayout; }
-inline wxLayoutConstraints *wxWindow::GetConstraints() const { return m_constraints; }
-inline void wxWindow::SetBackgroundColour(const wxColour& col) { m_backgroundColour = col; };
-inline wxColour wxWindow::GetBackgroundColour() const { return m_backgroundColour; };
-inline void wxWindow::SetForegroundColour(const wxColour& col) { m_foregroundColour = col; };
-inline wxColour wxWindow::GetForegroundColour() const { return m_foregroundColour; };
-
-inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; }
-inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; }
-inline bool wxWindow::IsRetained() const { return ((m_windowStyle & wxRETAINED) == wxRETAINED); }
-
-inline void wxWindow::SetShowing(bool show) { m_isShown = show; }
-inline wxList *wxWindow::GetConstraintsInvolvedIn() const { return m_constraintsInvolvedIn; }
-inline wxSizer *wxWindow::GetSizer() const { return m_windowSizer; }
-inline wxWindow *wxWindow::GetSizerParent() const { return m_sizerParent; }
-inline void wxWindow::SetSizerParent(wxWindow *win) { m_sizerParent = win; }
-inline WXFARPROC wxWindow::MSWGetOldWndProc() const { return m_oldWndProc; }
-inline void wxWindow::MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; }
-inline wxValidator *wxWindow::GetValidator() const { return m_windowValidator; }
-inline bool wxWindow::IsUserEnabled() const { return m_winEnabled; }
-inline bool wxWindow::GetUseCtl3D() const { return m_useCtl3D; }
-inline bool wxWindow::GetTransparentBackground() const { return m_backgroundTransparent; }
-inline void wxWindow::SetReturnCode(int retCode) { m_returnCode = retCode; }
-inline int wxWindow::GetReturnCode() { return m_returnCode; }
-inline bool wxWindow::IsBeingDeleted() { return m_isBeingDeleted; }
-
-// Window specific (so far)
-WXDLLEXPORT wxWindow* wxGetActiveWindow();
-
-WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
 
+// kbd code translation
 WXDLLEXPORT int wxCharCodeMSWToWX(int keySym);
 WXDLLEXPORT int wxCharCodeWXToMSW(int id, bool *IsVirtual);
 
-// Allocates control ids
-WXDLLEXPORT int NewControlId();
-
 #endif
     // _WX_WINDOW_H_

include/wx/window.h

@@ -602,7 +602,14 @@ protected:
     // the window handle (for the underlying windowing system) and the window
     // id - a number which uniquely identifies a window among its siblings
     // unless it is -1
+    union
+    {
+        // we have 2 common names for this member, one for MSW and the other
+        // for the rest of the world
         WXWidget m_widget;
+        WXWidget m_hWnd;
+    };
+
     wxWindowID           m_windowId;
 
     // the parent window of this window (or NULL) and the list of the children
@@ -753,6 +760,7 @@ wxWindow *wxWindowBase::GetGrandParent() const
 // ----------------------------------------------------------------------------
 
 extern wxWindow* WXDLLEXPORT wxGetActiveWindow();
+inline int WXDLLEXPORT NewControlId() { return wxWindowBase::NewControlId(); }
 
 #endif
     // _WX_WINDOW_H_BASE_

src/common/wincmn.cpp

@@ -241,13 +241,12 @@ bool wxWindowBase::Close(bool force)
 bool wxWindowBase::DestroyChildren()
 {
     wxWindowList::Node *node;
-    for ( node = m_children.GetFirst(); node; node = node->GetNext() )
+    for ( node = GetChildren().GetFirst(); node; node = node->GetNext() )
     {
         wxWindow *child = node->GetData();
         if ( child )
         {
             delete child;
-            delete node;
         }
     }
 

src/msw/checklst.cpp

@@ -319,8 +319,8 @@ void wxCheckListBox::InsertItems(int nItems, const wxString items[], int pos)
 wxOwnerDrawn *wxCheckListBox::CreateItem(size_t nIndex)
 {
   wxCheckListBoxItem *pItem = new wxCheckListBoxItem(this, nIndex);
-  if ( m_windowFont.Ok() )
+  if ( m_font.Ok() )
-    pItem->SetFont(m_windowFont);
+    pItem->SetFont(m_font);
 
   return pItem;
 }

src/msw/control.cpp

@@ -168,17 +168,17 @@ void wxControl::MSWOnMouseMove(int x, int y, WXUINT flags)
   // Window gets a click down message followed by a mouse move
   // message even if position isn't changed!  We want to discard
   // the trailing move event if x and y are the same.
-  if ((m_lastEvent == wxEVT_RIGHT_DOWN || m_lastEvent == wxEVT_LEFT_DOWN ||
+  if ((m_lastMouseEvent == wxEVT_RIGHT_DOWN || m_lastMouseEvent == wxEVT_LEFT_DOWN ||
-       m_lastEvent == wxEVT_MIDDLE_DOWN) &&
+       m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
-      (m_lastXPos == event.GetX() && m_lastYPos == event.GetY()))
+      (m_lastMouseX == event.GetX() && m_lastMouseY == event.GetY()))
   {
-    m_lastXPos = event.GetX(); m_lastYPos = event.GetY();
+    m_lastMouseX = event.GetX(); m_lastMouseY = event.GetY();
-    m_lastEvent = wxEVT_MOTION;
+    m_lastMouseEvent = wxEVT_MOTION;
     return;
   }
 
-  m_lastEvent = wxEVT_MOTION;
+  m_lastMouseEvent = wxEVT_MOTION;
-  m_lastXPos = event.GetX(); m_lastYPos = event.GetY();
+  m_lastMouseX = event.GetX(); m_lastMouseY = event.GetY();
 
   if (!GetEventHandler()->ProcessEvent(event))
     Default();
@@ -250,18 +250,6 @@ bool wxControl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam,
 #endif
 }
 
-/*
- * Allocates control IDs within the appropriate range
- */
-
-
-int NewControlId(void)
-{
-  static int controlId = 0;
-  controlId ++;
-  return controlId;
-}
-
 void wxControl::ProcessCommand (wxCommandEvent & event)
 {
   // Tries:

src/msw/dc.cpp

@@ -803,7 +803,7 @@ void wxDC::SetBackground(const wxBrush& brush)
         {
             if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
             {
-                m_canvas->m_backgroundTransparent = TRUE;
+                m_canvas->SetTransparent(TRUE);
             }
             else
             {
@@ -815,7 +815,7 @@ void wxDC::SetBackground(const wxBrush& brush)
                 // wxWindow::SetTransparency(). Should that apply to the child itself, or the
                 // parent?
                 //        m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
-                m_canvas->m_backgroundTransparent = FALSE;
+                m_canvas->SetTransparent(FALSE);
             }
         }
     }

src/msw/dialog.cpp

@@ -415,9 +415,13 @@ bool wxDialog::Show(bool show)
       // enable it, else we enable all modeless windows
       if (last)
       {
+          // VZ: I don't understand what this is supposed to do, so I'll leave
+          //     it out for now and look for horrible consequences
         wxDialog *box = (wxDialog *)last->Data();
         HWND hwnd = (HWND) box->GetHWND();
-        if (box->m_winEnabled)
+#if 0
+        if (box->IsUserEnabled())
+#endif // 0
           EnableWindow(hwnd, TRUE);
         BringWindowToTop(hwnd);
       }
@@ -429,7 +433,9 @@ bool wxDialog::Show(bool show)
           wxWindow *win = (wxWindow *)node->Data();
           HWND hwnd = (HWND) win->GetHWND();
           // Only enable again if not user-disabled.
+#if 0
           if (win->IsUserEnabled())
+#endif // 0
             EnableWindow(hwnd, TRUE);
           node = node->Next();
         }

src/msw/frame.cpp

@@ -75,7 +75,6 @@ wxFrame::wxFrame()
   m_frameMenuBar = NULL;
   m_frameStatusBar = NULL;
 
-  m_windowParent = NULL;
   m_iconized = FALSE;
 }
 
@@ -170,7 +169,7 @@ WXHMENU wxFrame::GetWinMenu() const
 }
 
 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
-void wxFrame::GetClientSize(int *x, int *y) const
+void wxFrame::DoGetClientSize(int *x, int *y) const
 {
   RECT rect;
   ::GetClientRect((HWND) GetHWND(), &rect);
@@ -230,7 +229,7 @@ void wxFrame::DoSetClientSize(int width, int height)
   GetEventHandler()->ProcessEvent(event);
 }
 
-void wxFrame::GetSize(int *width, int *height) const
+void wxFrame::DoGetSize(int *width, int *height) const
 {
   RECT rect;
   GetWindowRect((HWND) GetHWND(), &rect);
@@ -238,7 +237,7 @@ void wxFrame::GetSize(int *width, int *height) const
   *height = rect.bottom - rect.top;
 }
 
-void wxFrame::GetPosition(int *x, int *y) const
+void wxFrame::DoGetPosition(int *x, int *y) const
 {
   RECT rect;
   GetWindowRect((HWND) GetHWND(), &rect);

src/msw/gauge95.cpp

@@ -182,14 +182,24 @@ int wxGauge95::GetValue(void) const
   return m_gaugePos;
 }
 
-void wxGauge95::SetForegroundColour(const wxColour& col)
+bool wxGauge95::SetForegroundColour(const wxColour& col)
 {
+    if ( !wxControl::SetForegroundColour(col) )
+        return FALSE;
+
     m_foregroundColour = col ;
+
+    return TRUE;
 }
 
-void wxGauge95::SetBackgroundColour(const wxColour& col)
+bool wxGauge95::SetBackgroundColour(const wxColour& col)
 {
+    if ( !wxControl::SetBackgroundColour(col) )
+        return FALSE;
+
     m_backgroundColour = col ;
+
+    return TRUE;
 }
 
 #endif // wxUSE_GAUGE

src/msw/listctrl.cpp

@@ -360,11 +360,14 @@ long wxListCtrl::ConvertToMSWStyle(long& oldStyle, long style) const
 
 // Sets the background colour (GetBackgroundColour already implicit in
 // wxWindow class)
-void wxListCtrl::SetBackgroundColour(const wxColour& col)
+bool wxListCtrl::SetBackgroundColour(const wxColour& col)
 {
-    wxWindow::SetBackgroundColour(col);
+    if ( !wxWindow::SetBackgroundColour(col) )
+        return FALSE;
 
     ListView_SetBkColor((HWND) GetHWND(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
+
+    return TRUE;
 }
 
 // Gets information about this column

src/msw/mdi.cpp

@@ -159,12 +159,12 @@ wxMDIParentFrame::~wxMDIParentFrame()
   if (m_clientWindow->MSWGetOldWndProc())
       m_clientWindow->UnsubclassWin();
 
-  m_clientWindow->m_hWnd = 0;
+  m_clientWindow->SetHWND(0);
   delete m_clientWindow;
 }
 
 // Get size *available for subwindows* i.e. excluding menu bar.
-void wxMDIParentFrame::GetClientSize(int *x, int *y) const
+void wxMDIParentFrame::DoGetClientSize(int *x, int *y) const
 {
   RECT rect;
   ::GetClientRect((HWND) GetHWND(), &rect);
@@ -662,7 +662,7 @@ wxMDIChildFrame::~wxMDIChildFrame()
 
 // Set the client size (i.e. leave the calculation of borders etc.
 // to wxWindows)
-void wxMDIChildFrame::SetClientSize(int width, int height)
+void wxMDIChildFrame::DoSetClientSize(int width, int height)
 {
   HWND hWnd = (HWND) GetHWND();
 
@@ -701,7 +701,7 @@ void wxMDIChildFrame::SetClientSize(int width, int height)
   GetEventHandler()->ProcessEvent(event);
 }
 
-void wxMDIChildFrame::GetPosition(int *x, int *y) const
+void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 {
   RECT rect;
   GetWindowRect((HWND) GetHWND(), &rect);
@@ -1065,7 +1065,7 @@ bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
 
   CLIENTCREATESTRUCT ccs;
   m_windowStyle = style;
-  m_windowParent = parent;
+  m_parent = parent;
 
   ccs.hWindowMenu = (HMENU) parent->GetWindowMenu();
   ccs.idFirstChild = wxFIRST_MDI_CHILD;

src/msw/nativdlg.cpp

@@ -9,34 +9,54 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ===========================================================================
+// declarations
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation
+    #pragma implementation
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
-#include <stdio.h>
+    #include <stdio.h>
-#include "wx/wx.h"
+
+    #include "wx/wx.h"
 #endif
 
 #include "wx/spinbutt.h"
 #include "wx/msw/private.h"
 
+// ---------------------------------------------------------------------------
+// global functions
+// ---------------------------------------------------------------------------
+
 extern wxWindow *wxWndHook;
-extern LONG APIENTRY _EXPORT wxDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+extern LONG APIENTRY _EXPORT wxDlgProc(HWND hWnd, UINT message,
+                                       WPARAM wParam, LPARAM lParam);
+
+// ===========================================================================
+// implementation
+// ===========================================================================
 
 bool wxWindow::LoadNativeDialog(wxWindow* parent, wxWindowID& id)
 {
     m_windowId = id;
     wxWndHook = this;
-	m_hWnd = (WXHWND) ::CreateDialog((HINSTANCE) wxGetInstance(), MAKEINTRESOURCE(id),
+    m_hWnd = (WXHWND)::CreateDialog((HINSTANCE)wxGetInstance(),
-		(HWND) (parent ? parent->GetHWND() : (WXHWND) NULL), (DLGPROC) wxDlgProc);
+                                    MAKEINTRESOURCE(id),
+                                    parent ? (HWND)parent->GetHWND() : 0,
+                                    (DLGPROC) wxDlgProc);
     wxWndHook = NULL;
 
     if ( !m_hWnd )
@@ -44,11 +64,10 @@ bool wxWindow::LoadNativeDialog(wxWindow* parent, wxWindowID& id)
 
     SubclassWin(GetHWND());
 
-    if (!parent)
-      wxTopLevelWindows.Append(this);
-
     if ( parent )
         parent->AddChild(this);
+    else
+        wxTopLevelWindows.Append(this);
 
     // Enumerate all children
     HWND hWndNext;
@@ -73,8 +92,10 @@ bool wxWindow::LoadNativeDialog(wxWindow* parent, const wxString& name)
     SetName(name);
 
     wxWndHook = this;
-	m_hWnd = (WXHWND) ::CreateDialog((HINSTANCE) wxGetInstance(), (const char *) name,
+    m_hWnd = (WXHWND)::CreateDialog((HINSTANCE) wxGetInstance(),
-		(HWND) (parent ? parent->GetHWND() : (WXHWND) NULL), (DLGPROC) wxDlgProc);
+                                    name.c_str(),
+                                    parent ? (HWND)parent->GetHWND() : 0,
+                                    (DLGPROC)wxDlgProc);
     wxWndHook = NULL;
 
     if ( !m_hWnd )
@@ -82,34 +103,40 @@ bool wxWindow::LoadNativeDialog(wxWindow* parent, const wxString& name)
 
     SubclassWin(GetHWND());
 
-    if (!parent)
-      wxTopLevelWindows.Append(this);
-
     if ( parent )
         parent->AddChild(this);
+    else
+        wxTopLevelWindows.Append(this);
+
+    // FIXME why don't we enum all children here?
 
     return TRUE;
 }
 
-wxWindow* wxWindow::GetWindowChild1(wxWindowID& id)
+// ---------------------------------------------------------------------------
+// look for child by id
+// ---------------------------------------------------------------------------
+
+wxWindow* wxWindow::GetWindowChild1(wxWindowID id)
 {
     if ( m_windowId == id )
         return this;
 
-	wxNode *node = GetChildren().First();
+    wxWindowList::Node *node = GetChildren().GetFirst();
     while ( node )
     {
-		wxWindow* child = (wxWindow*) node->Data();
+        wxWindow* child = node->GetData();
         wxWindow* win = child->GetWindowChild1(id);
         if ( win )
             return win;
-		node = node->Next();
+
+        node = node->GetNext();
     }
 
     return NULL;
 }
 
-wxWindow* wxWindow::GetWindowChild(wxWindowID& id)
+wxWindow* wxWindow::GetWindowChild(wxWindowID id)
 {
     wxWindow* win = GetWindowChild1(id);
     if ( !win )
@@ -126,37 +153,20 @@ wxWindow* wxWindow::GetWindowChild(wxWindowID& id)
             }
         }
     }
+
     return NULL;
 }
 
+// ---------------------------------------------------------------------------
+// create wxWin window from a native HWND
+// ---------------------------------------------------------------------------
 
 wxWindow* wxWindow::CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd)
 {
-	char buf[256];
+    wxString str(wxGetWindowClass(hWnd));
-
-#ifndef __WIN32__
-	GetClassName((HWND) hWnd, buf, 256);
-#else
-#ifdef UNICODE
-	GetClassNameW((HWND) hWnd, buf, 256);
-#else
-#ifdef __TWIN32__
-	GetClassName((HWND) hWnd, buf, 256);
-#else
-	GetClassNameA((HWND) hWnd, buf, 256);
-#endif
-#endif
-#endif
-
-	wxString str(buf);
     str.UpperCase();
 
-#ifndef __WIN32__
+    long id = wxGetWindowId(hWnd);
-	long id = (long) GetWindowWord((HWND) hWnd, GWW_ID);
-#else
-	long id = GetWindowLong((HWND) hWnd, GWL_ID);
-#endif
-
     long style = GetWindowLong((HWND) hWnd, GWL_STYLE);
 
     wxWindow* win = NULL;
@@ -201,9 +211,8 @@ wxWindow* wxWindow::CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd)
         }
         else
         {
-			char buf[256];
+            wxLogError(_T("Don't know what kind of button this is: id = %d"),
-			sprintf(buf, "Don't know what kind of button this is: id = %d", (int) id);
+                       id);
-			wxLogError(buf);
         }
     }
     else if (str == "COMBOBOX")
@@ -290,4 +299,3 @@ void wxWindow::AdoptAttributesFromHWND(void)
         m_windowStyle |= wxHSCROLL;
 }
 
-

src/msw/radiobox.cpp

@@ -46,13 +46,6 @@
 // private functions
 // ---------------------------------------------------------------------------
 
-// get the id of the window
-#ifdef __WIN32__
-    #define GET_WIN_ID(hwnd) ::GetWindowLong((HWND)hwnd, GWL_ID)
-#else // Win16
-    #define GET_WIN_ID(hwnd) ::GetWindowWord((HWND)hwnd, GWW_ID)
-#endif // Win32/16
-
 // wnd proc for radio buttons
 #ifdef __WIN32__
 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hWnd,
@@ -109,7 +102,7 @@ bool wxRadioBox::MSWCommand(WXUINT param, WXWORD id)
 
         for ( int i = 0; i < m_noItems; i++ )
         {
-            if ( id == GET_WIN_ID(m_radioButtons[i]) )
+            if ( id == wxGetWindowId(m_radioButtons[i]) )
             {
                 selectedButton = i;
 
@@ -597,13 +590,16 @@ void wxRadioBox::Enable(int item, bool enable)
 }
 
 // Enable all controls
-void wxRadioBox::Enable(bool enable)
+bool wxRadioBox::Enable(bool enable)
 {
-    wxControl::Enable(enable);
+    if ( !wxControl::Enable(enable) )
+        return FALSE;
 
     int i;
     for (i = 0; i < m_noItems; i++)
         ::EnableWindow((HWND) m_radioButtons[i], enable);
+
+    return TRUE;
 }
 
 // Show a specific button

src/msw/tbarmsw.cpp

@@ -381,7 +381,7 @@ wxToolBarTool *wxToolBarMSW::AddTool(int index, const wxBitmap& bitmap, const wx
   return tool;
 }
 
-void wxToolBarMSW::Layout(void)
+void wxToolBarMSW::LayoutTools()
 {
   m_currentRowsOrColumns = 0;
   m_lastX = m_xMargin;

src/msw/utils.cpp

@@ -796,6 +796,10 @@ bool wxDirExists(const wxString& dir)
 #endif
 }
 
+// ---------------------------------------------------------------------------
+// window information functions
+// ---------------------------------------------------------------------------
+
 wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
 {
     wxString str;
@@ -806,6 +810,58 @@ wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
     return str;
 }
 
+wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+{
+    wxString str;
+
+    int len = 256; // some starting value
+
+    for ( ;; )
+    {
+        // as we've #undefined GetClassName we must now manually choose the
+        // right function to call
+        int count =
+
+        #ifndef __WIN32__
+            GetClassName
+        #else // Win32
+            #ifdef UNICODE
+                GetClassNameW
+            #else // !Unicode
+                #ifdef __TWIN32__
+                    GetClassName
+                #else // !Twin32
+                    GetClassNameA
+                #endif // Twin32/!Twin32
+            #endif // Unicode/ANSI
+        #endif // Win16/32
+                                    ((HWND)hWnd, str.GetWriteBuf(len), len);
+
+        str.UngetWriteBuf();
+        if ( count == len )
+        {
+            // the class name might have been truncated, retry with larger
+            // buffer
+            len *= 2;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return str;
+}
+
+wxWindowID WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+{
+#ifndef __WIN32__
+    return (wxWindowID)GetWindowWord((HWND)hWnd, GWW_ID);
+#else // Win32
+    return (wxWindowID)GetWindowLong((HWND)hWnd, GWL_ID);
+#endif // Win16/32
+}
+
 #if 0
 //------------------------------------------------------------------------
 // wild character routines