wxWindow split into wxWindowBase and wxWindow (wxGTK part)

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

include/wx/control.h

@@ -1,6 +1,9 @@
 #ifndef _WX_CONTROL_H_BASE_
 #define _WX_CONTROL_H_BASE_
 
+// all classes derived from wxControl need the validators
+#include "wx/validate.h"
+
 #if defined(__WXMSW__)
 #include "wx/msw/control.h"
 #elif defined(__WXMOTIF__)

include/wx/defs.h

@@ -1106,7 +1106,8 @@ typedef int (__stdcall *WXFARPROC)();
 typedef int (*WXFARPROC)();
 #endif
 
-#endif
+typedef WXHWND WXWidget;
+#endif // MSW
 
 #ifdef __WXMOTIF__
 /* Stand-ins for X/Xt/Motif types */
@@ -1125,7 +1126,7 @@ typedef void*           WXFont;
 typedef void*           WXImage;
 typedef void*           WXCursor;
 typedef void*           WXFontList;
-#endif
+#endif // Motif
 
 #ifdef __WXGTK__
 /* Stand-ins for GLIB types */
@@ -1160,7 +1161,8 @@ typedef struct _GtkAccelGroup     GtkAccelGroup;
 typedef	struct _GtkItemFactory    GtkItemFactory;
 typedef	struct _GtkSelectionData  GtkSelectionData;
 
-#endif
+typedef GtkWidget *WXWidget;
+#endif // GTK
 
 // This is required because of clashing macros in windows.h, which may be
 // included before or after wxWindows classes, and therefore must be

include/wx/gdicmn.h

@@ -12,6 +12,10 @@
 #ifndef _WX_GDICMNH__
 #define _WX_GDICMNH__
 
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+
 #ifdef __GNUG__
     #pragma interface "gdicmn.h"
 #endif
@@ -23,10 +27,55 @@
 #include "wx/setup.h"
 #include "wx/colour.h"
 
+// ---------------------------------------------------------------------------
+// forward declarations
+// ---------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxBrush;
+class WXDLLEXPORT wxColour;
+class WXDLLEXPORT wxCursor;
+class WXDLLEXPORT wxFont;
+class WXDLLEXPORT wxIcon;
+class WXDLLEXPORT wxPalette;
+class WXDLLEXPORT wxPen;
+class WXDLLEXPORT wxRegion;
+class WXDLLEXPORT wxString;
+
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+
+// Bitmap flags
+enum
+{
+    wxBITMAP_TYPE_BMP = 1,
+    wxBITMAP_TYPE_BMP_RESOURCE,
+    wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
+    wxBITMAP_TYPE_ICO,
+    wxBITMAP_TYPE_ICO_RESOURCE,
+    wxBITMAP_TYPE_CUR,
+    wxBITMAP_TYPE_CUR_RESOURCE,
+    wxBITMAP_TYPE_XBM,
+    wxBITMAP_TYPE_XBM_DATA,
+    wxBITMAP_TYPE_XPM,
+    wxBITMAP_TYPE_XPM_DATA,
+    wxBITMAP_TYPE_TIF,
+    wxBITMAP_TYPE_TIF_RESOURCE,
+    wxBITMAP_TYPE_GIF,
+    wxBITMAP_TYPE_GIF_RESOURCE,
+    wxBITMAP_TYPE_PNG,
+    wxBITMAP_TYPE_PNG_RESOURCE,
+    wxBITMAP_TYPE_JPEG,
+    wxBITMAP_TYPE_JPEG_RESOURCE,
+    wxBITMAP_TYPE_ANY = 50
+};
+
 // Standard cursors
-typedef enum {
+enum wxStockCursor
- wxCURSOR_NONE =  0,
+{
- wxCURSOR_ARROW =  1,
+    wxCURSOR_NONE,          // should be 0
+    wxCURSOR_ARROW,
     wxCURSOR_BULLSEYE,
     wxCURSOR_CHAR,
     wxCURSOR_CROSS,
@@ -50,46 +99,94 @@ typedef enum {
     wxCURSOR_SPRAYCAN,
     wxCURSOR_WAIT,
     wxCURSOR_WATCH,
- wxCURSOR_BLANK
+    wxCURSOR_BLANK,
 #ifdef __X__
-  /* Not yet implemented for Windows */
+    // Not yet implemented for Windows
-  , wxCURSOR_CROSS_REVERSE,
+    wxCURSOR_CROSS_REVERSE,
     wxCURSOR_DOUBLE_ARROW,
     wxCURSOR_BASED_ARROW_UP,
     wxCURSOR_BASED_ARROW_DOWN
-#endif
+#endif // X11
-} wxStockCursor;
 
+    wxCURSOR_MAX
+};
+
+// ---------------------------------------------------------------------------
+// macros
+// ---------------------------------------------------------------------------
+
+/* Useful macro for creating icons portably, for example:
+
+    wxIcon *icon = new wxICON(mondrian);
+
+  expands into:
+
+    wxIcon *icon = new wxIcon("mondrian");      // On wxMSW
+    wxIcon *icon = new wxIcon(mondrian_xpm);    // On wxGTK
+ */
+
+#ifdef __WXMSW__
+    // Load from a resource
+    #define wxICON(X) wxIcon("" #X "")
+#elif defined(__WXGTK__)
+    // Initialize from an included XPM
+    #define wxICON(X) wxIcon( (const char**) X##_xpm )
+#elif defined(__WXMOTIF__)
+    // Initialize from an included XPM
+    #define wxICON(X) wxIcon( X##_xpm )
+#else
+    // This will usually mean something on any platform
+    #define wxICON(X) wxIcon("" #X "")
+#endif // platform
+
+// ===========================================================================
+// classes
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxSize
+// ---------------------------------------------------------------------------
 class WXDLLEXPORT wxSize
 {
 public:
+    // members are public for compatibility
     long x;
     long y;
-  inline wxSize() { x = 0; y = 0; }
+
-  inline wxSize(long xx, long yy) { x = xx; y = yy; }
+    // constructors
-  inline wxSize(const wxSize& sz) { x = sz.x; y = sz.y; }
+    wxSize() { x = y = 0; }
-  inline void operator = (const wxSize& sz) { x = sz.x; y = sz.y; }
+    wxSize(long xx, long yy) { Set(xx, yy); }
-  inline bool operator == (const wxSize& sz) const { return (x == sz.x && y == sz.y); }
+
-  inline wxSize operator + (const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
+    // no copy ctor or assignment operator - the defaults are ok
-  inline wxSize operator - (const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
+
-  inline void Set(long xx, long yy) { x = xx; y = yy; }
+    bool operator==(const wxSize& sz) const { return x == sz.x && y == sz.y; }
-  inline long GetX() const { return x; }
+
-  inline long GetY() const { return y; }
+    // FIXME are these really useful? If they're, we should have += &c as well
+    wxSize operator+(const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
+    wxSize operator-(const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
+
+    void Set(long xx, long yy) { x = xx; y = yy; }
+
+    long GetX() const { return x; }
+    long GetY() const { return y; }
 };
 
-// Point
+// ---------------------------------------------------------------------------
+// Point classes: with real or integer coordinates
+// ---------------------------------------------------------------------------
 class WXDLLEXPORT wxRealPoint
 {
 public:
     double x;
     double y;
-  inline wxRealPoint() { x = 0.0; y = 0.0; };
-  inline wxRealPoint(double _x, double _y) { x = _x; y = _y; };
-  inline wxRealPoint operator + (const wxRealPoint& pt) { return wxRealPoint(x + pt.x, y + pt.y); }
-  inline wxRealPoint operator - (const wxRealPoint& pt) { return wxRealPoint(x - pt.x, y - pt.y); }
 
-  inline void operator = (const wxRealPoint& pt) { x = pt.x; y = pt.y; }
+    wxRealPoint() { x = y = 0.0; };
-  inline bool operator == (const wxRealPoint& pt) const { return (x == pt.x && y == pt.y); }
+    wxRealPoint(double xx, double yy) { x = xx; y = yy; };
+
+    wxRealPoint operator+(const wxRealPoint& pt) { return wxRealPoint(x + pt.x, y + pt.y); }
+    wxRealPoint operator-(const wxRealPoint& pt) { return wxRealPoint(x - pt.x, y - pt.y); }
+
+    bool operator==(const wxRealPoint& pt) const { return x == pt.x && y == pt.y; }
 };
 
 class WXDLLEXPORT wxPoint
@@ -103,20 +200,25 @@ class WXDLLEXPORT wxPoint
     long y;
 #endif
 
-  inline wxPoint() { x = 0; y = 0; };
+    wxPoint() { x = y = 0; };
-  wxPoint(long the_x, long the_y) { x = the_x; y = the_y; };
+    wxPoint(long xx, long yy) { x = xx; y = yy; };
-  wxPoint(const wxPoint& pt) { x = pt.x; y = pt.y; };
 
-  inline void operator = (const wxPoint& pt) { x = pt.x; y = pt.y; }
+    // no copy ctor or assignment operator - the defaults are ok
-  inline bool operator == (const wxPoint& pt) const { return (x == pt.x && y == pt.y); }
+
-  inline wxPoint operator + (const wxPoint& pt) { return wxPoint(x + pt.x, y + pt.y); }
+    bool operator==(const wxPoint& pt) const { return x == pt.x && y == pt.y; }
-  inline wxPoint operator - (const wxPoint& pt) { return wxPoint(x - pt.x, y - pt.y); }
+
+    wxPoint operator + (const wxPoint& pt) { return wxPoint(x + pt.x, y + pt.y); }
+    wxPoint operator - (const wxPoint& pt) { return wxPoint(x - pt.x, y - pt.y); }
 };
 
 #if WXWIN_COMPATIBILITY
     #define wxIntPoint wxPoint
     #define wxRectangle wxRect
-#endif
+#endif // WXWIN_COMPATIBILITY
+
+// ---------------------------------------------------------------------------
+// wxRect
+// ---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxRect
 {
@@ -127,81 +229,46 @@ public:
     wxRect(const wxPoint& pos, const wxSize& size);
     wxRect(const wxRect& rect);
 
-   inline long  GetX() const        { return x; }
+    long GetX() const { return x; }
-   inline void SetX(long X)       { x = X; }
+    void SetX(long xx) { x = xx; }
-   inline long  GetY() const        { return y; }
-   inline void SetY(long Y)       { y = Y; }
-   inline long  GetWidth() const        { return width; }
-   inline void SetWidth(long w)   { width = w; }
-   inline long  GetHeight() const       { return height; }
-   inline void SetHeight(long h)  { height = h; }
 
-   inline wxPoint GetPosition() { return wxPoint(x, y); }
+    long GetY() const { return y; }
-   inline wxSize GetSize() { return wxSize(width, height); }
+    void SetY(long yy) { y = yy; }
 
-   inline long  GetLeft()   const { return x; }
+    long GetWidth() const { return width; }
-   inline long  GetTop()    const { return y; }
+    void SetWidth(long w) { width = w; }
-   inline long  GetBottom() const { return y + height; }
+
-   inline long  GetRight()  const { return x + width; }
+    long GetHeight() const { return height; }
+    void SetHeight(long h) { height = h; }
+
+    wxPoint GetPosition() { return wxPoint(x, y); }
+    wxSize GetSize() { return wxSize(width, height); }
+
+    long GetLeft()   const { return x; }
+    long GetTop()    const { return y; }
+    long GetBottom() const { return y + height; }
+    long GetRight()  const { return x + width; }
 
     wxRect& operator = (const wxRect& rect);
     bool operator == (const wxRect& rect);
     bool operator != (const wxRect& rect);
+
 public:
     long x, y, width, height;
 };
 
-class WXDLLEXPORT wxBrush;
+// ---------------------------------------------------------------------------
-class WXDLLEXPORT wxPen;
-class WXDLLEXPORT wxBitmap;
-class WXDLLEXPORT wxIcon;
-class WXDLLEXPORT wxCursor;
-class WXDLLEXPORT wxFont;
-class WXDLLEXPORT wxPalette;
-class WXDLLEXPORT wxPalette;
-class WXDLLEXPORT wxRegion;
-
-/*
- * Bitmap flags
- */
-
-// Hint to indicate filetype
-#define wxBITMAP_TYPE_BMP               1
-#define wxBITMAP_TYPE_BMP_RESOURCE      2
-#define wxBITMAP_TYPE_ICO               3
-#define wxBITMAP_TYPE_ICO_RESOURCE      4
-#define wxBITMAP_TYPE_CUR               5
-#define wxBITMAP_TYPE_CUR_RESOURCE      6
-#define wxBITMAP_TYPE_XBM               7
-#define wxBITMAP_TYPE_XBM_DATA          8
-#define wxBITMAP_TYPE_XPM               9
-#define wxBITMAP_TYPE_XPM_DATA          10
-#define wxBITMAP_TYPE_TIF               11
-#define wxBITMAP_TYPE_TIF_RESOURCE      12
-#define wxBITMAP_TYPE_GIF               13
-#define wxBITMAP_TYPE_GIF_RESOURCE      14
-#define wxBITMAP_TYPE_PNG               15
-#define wxBITMAP_TYPE_PNG_RESOURCE      16
-#define wxBITMAP_TYPE_JPEG              17
-#define wxBITMAP_TYPE_JPEG_RESOURCE     18
-#define wxBITMAP_TYPE_ANY               50
-
-#define wxBITMAP_TYPE_RESOURCE wxBITMAP_TYPE_BMP_RESOURCE
-
-class WXDLLEXPORT wxBitmap;
-class WXDLLEXPORT wxCursor;
-class WXDLLEXPORT wxIcon;
-class WXDLLEXPORT wxColour;
-class WXDLLEXPORT wxString;
-
 // Management of pens, brushes and fonts
+// ---------------------------------------------------------------------------
+
 class WXDLLEXPORT wxPenList : public wxList
 {
     DECLARE_DYNAMIC_CLASS(wxPenList)
+
 public:
-  inline wxPenList()
+    wxPenList() { }
-    { }
     ~wxPenList();
+
     void AddPen(wxPen *pen);
     void RemovePen(wxPen *pen);
     wxPen *FindOrCreatePen(const wxColour& colour, int width, int style);
@@ -210,10 +277,11 @@ class WXDLLEXPORT wxPenList: public wxList
 class WXDLLEXPORT wxBrushList : public wxList
 {
     DECLARE_DYNAMIC_CLASS(wxBrushList)
+
 public:
-  inline wxBrushList()
+    wxBrushList() { }
-    { }
     ~wxBrushList();
+
     void AddBrush(wxBrush *brush);
     void RemoveBrush(wxBrush *brush);
     wxBrush *FindOrCreateBrush(const wxColour& colour, int style);
@@ -224,22 +292,26 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
 class WXDLLEXPORT wxFontList : public wxList
 {
     DECLARE_DYNAMIC_CLASS(wxFontList)
+
 public:
-  inline wxFontList()
+    wxFontList() { }
-    { }
     ~wxFontList();
+
     void AddFont(wxFont *font);
     void RemoveFont(wxFont *font);
     wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
-    bool underline = FALSE, const wxString& face = wxEmptyString);
+                             bool underline = FALSE,
+                             const wxString& face = wxEmptyString);
 };
 
 class WXDLLEXPORT wxColourDatabase : public wxList
 {
     DECLARE_CLASS(wxColourDatabase)
+
 public:
     wxColourDatabase(int type);
     ~wxColourDatabase() ;
+
     // Not const because it may add a name to the database
     wxColour *FindColour(const wxString& colour) ;
     wxString FindName(const wxColour& colour) const;
@@ -249,6 +321,7 @@ class WXDLLEXPORT wxColourDatabase: public wxList
 class WXDLLEXPORT wxBitmapList : public wxList
 {
     DECLARE_DYNAMIC_CLASS(wxBitmapList)
+
 public:
     wxBitmapList();
     ~wxBitmapList();
@@ -257,6 +330,21 @@ class WXDLLEXPORT wxBitmapList: public wxList
     void RemoveBitmap(wxBitmap *bitmap);
 };
 
+class WXDLLEXPORT wxResourceCache: public wxList
+{
+public:
+    wxResourceCache() { }
+    wxResourceCache(const unsigned int keyType) : wxList(keyType) { }
+    ~wxResourceCache();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxResourceCache)
+};
+
+// ---------------------------------------------------------------------------
+// global variables
+// ---------------------------------------------------------------------------
+
 // Lists of GDI objects
 WXDLLEXPORT_DATA(extern wxPenList*)   wxThePenList;
 WXDLLEXPORT_DATA(extern wxBrushList*)   wxTheBrushList;
@@ -315,58 +403,38 @@ WXDLLEXPORT_DATA(extern wxCursor*)		wxHOURGLASS_CURSOR;
 WXDLLEXPORT_DATA(extern wxCursor*)    wxCROSS_CURSOR;
 
 WXDLLEXPORT_DATA(extern wxColourDatabase*)  wxTheColourDatabase;
+
+WXDLLEXPORT_DATA(extern const wxChar*) wxPanelNameStr;
+
+WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
+WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
+
+// The list of objects which should be deleted
+WXDLLEXPORT_DATA(extern wxList) wxPendingDelete;
+
+// ---------------------------------------------------------------------------
+// global functions
+// ---------------------------------------------------------------------------
+
+// resource management
 extern void WXDLLEXPORT wxInitializeStockObjects();
 extern void WXDLLEXPORT wxInitializeStockLists();
 extern void WXDLLEXPORT wxDeleteStockObjects();
 extern void WXDLLEXPORT wxDeleteStockLists();
 
+// is the display colour (or monochrome)?
 extern bool WXDLLEXPORT wxColourDisplay();
 
 // Returns depth of screen
 extern int WXDLLEXPORT wxDisplayDepth();
 #define wxGetDisplayDepth wxDisplayDepth
 
+// get the diaplay size
 extern void WXDLLEXPORT wxDisplaySize(int *width, int *height);
 extern wxSize WXDLLEXPORT wxGetDisplaySize();
 
+// set global cursor
 extern void WXDLLEXPORT wxSetCursor(const wxCursor& cursor);
 
-// Useful macro for creating icons portably
-
-#ifdef __WXMSW__
-// Load from a resource
-# define wxICON(X) wxIcon("" #X "")
-
-#elif defined(__WXGTK__)
-// Initialize from an included XPM
-# define wxICON(X) wxIcon( (const char**) X##_xpm )
-#elif defined(__WXMOTIF__)
-// Initialize from an included XPM
-# define wxICON(X) wxIcon( X##_xpm )
-#else
-
-// This will usually mean something on any platform
-# define wxICON(X) wxIcon("" #X "")
-#endif
-
-/*
-  Example:
-    wxIcon *icon = new wxICON(mondrian);
-  expands into:
-    wxIcon *icon = new wxIcon("mondrian"); // On wxMSW
-    wxIcon *icon = new wxIcon(mondrian_xpm);   // On wxGTK
- */
-
-class WXDLLEXPORT wxResourceCache: public wxList
-{
-public:
-    wxResourceCache() { }
-    wxResourceCache(const unsigned int keyType) : wxList(keyType) { }
-    ~wxResourceCache();
-
-private:
-    DECLARE_DYNAMIC_CLASS(wxResourceCache)
-};
-
 #endif
     // _WX_GDICMNH__

include/wx/generic/listctrl.h

@@ -611,9 +611,9 @@ class WXDLLEXPORT wxListCtrl: public wxControl
     
     // We have to hand down a few functions
     
-    void SetBackgroundColour( const wxColour &colour );
+    bool SetBackgroundColour( const wxColour &colour );
-    void SetForegroundColour( const wxColour &colour );
+    bool SetForegroundColour( const wxColour &colour );
-    void SetFont( const wxFont &font );
+    bool SetFont( const wxFont &font );
     
 #if wxUSE_DRAG_AND_DROP
     void SetDropTarget( wxDropTarget *dropTarget )
@@ -622,14 +622,12 @@ class WXDLLEXPORT wxListCtrl: public wxControl
       { return m_mainWin->GetDropTarget(); }
 #endif
 
-    void SetCursor( const wxCursor &cursor )
+    bool SetCursor( const wxCursor &cursor )
-      { if (m_mainWin) m_mainWin->wxWindow::SetCursor( cursor); }
+      { return m_mainWin ? m_mainWin->wxWindow::SetCursor(cursor) : FALSE; }
     wxColour GetBackgroundColour() const
-      { if (m_mainWin) return m_mainWin->GetBackgroundColour();
+      { return m_mainWin ? m_mainWin->GetBackgroundColour() : wxColour(); }
-        else return wxColour(); }
     wxColour GetForegroundColour() const
-      { if (m_mainWin) return m_mainWin->GetForegroundColour();
+      { return m_mainWin ? m_mainWin->GetForegroundColour() : wxColour(); }
-        else return wxColour(); }
     bool PopupMenu( wxMenu *menu, int x, int y )
       { return m_mainWin->PopupMenu( menu, x, y ); }
     void SetFocus()

include/wx/generic/tabg.h

@@ -120,7 +120,7 @@ public:
   wxString GetTabText(int id) const;
 
   // Layout tabs (optional, e.g. if resizing window)
-  void Layout(void);
+  void LayoutTabs();
 
   // Draw all tabs
   virtual void Draw(wxDC& dc);

include/wx/gtk/bmpbuttn.h

@@ -72,7 +72,7 @@ public:
   void SetBitmapLabel( const wxBitmap& bitmap );
   void SetBitmapSelected( const wxBitmap& bitmap );
     
-  virtual void Enable(const bool);
+  virtual bool Enable(const bool);
   
 // implementation
 

include/wx/gtk/button.h

@@ -59,7 +59,7 @@ class wxButton: public wxControl
            const wxString& name = wxButtonNameStr);
     void SetDefault();
     void SetLabel( const wxString &label );
-    void Enable( bool enable );
+    bool Enable( bool enable );
     
   // implementation        
   

include/wx/gtk/checkbox.h

@@ -63,7 +63,7 @@ public:
     bool GetValue() const;
 
     void SetLabel( const wxString& label );
-    void Enable( bool enable );
+    bool Enable( bool enable );
 
     // implementation
     void ApplyWidgetStyle();

include/wx/gtk/dialog.h

@@ -87,6 +87,9 @@ public:
     virtual void Maximize() { }
     virtual void Restore() { }
 
+    void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
+    int GetReturnCode() const { return m_returnCode; }
+
     // implementation
 
     virtual void GtkOnSize( int x, int y, int width, int height );
@@ -105,6 +108,8 @@ protected:
                            int sizeFlags = wxSIZE_AUTO);
 
 private:
+    int m_returnCode;
+
     DECLARE_EVENT_TABLE()
 };
 

include/wx/gtk/font.h

@@ -58,8 +58,8 @@ public:
   wxFont( const wxFont& font );
   ~wxFont();
   wxFont& operator = ( const wxFont& font );
-  bool operator == ( const wxFont& font );
+  bool operator == ( const wxFont& font ) const;
-  bool operator != ( const wxFont& font );
+  bool operator != ( const wxFont& font ) const;
   bool Ok() const;
 
   int GetPointSize() const;

include/wx/gtk/radiobox.h

@@ -70,7 +70,7 @@ class wxRadioBox: public wxControl
     void SetLabel( int item, wxBitmap *bitmap );
     wxString GetLabel( int item ) const;
     bool Show( bool show );
-    void Enable( bool enable );
+    bool Enable( bool enable );
     void Enable( int item, bool enable );
     void Show( int item, bool show );
     virtual wxString GetStringSelection(void) const;

include/wx/gtk/radiobut.h

@@ -60,7 +60,7 @@ class wxRadioButton: public wxControl
     virtual void SetLabel(const wxString& label);
     virtual void SetValue(bool val);
     virtual bool GetValue(void) const;
-    void Enable( bool enable );
+    bool Enable( bool enable );
     
   // implementation
     

include/wx/gtk/textctrl.h

@@ -143,9 +143,9 @@ class wxTextCtrl: public wxControl
     wxTextCtrl& operator<<(const char c);
 #endif
 
-    void SetFont( const wxFont &font );
+    bool SetFont( const wxFont &font );
-    void SetForegroundColour(const wxColour &colour);
+    bool SetForegroundColour(const wxColour &colour);
-    void SetBackgroundColour(const wxColour &colour);
+    bool SetBackgroundColour(const wxColour &colour);
 
   // implementation    
     

include/wx/gtk/window.h

@@ -15,94 +15,17 @@
     #pragma interface
 #endif
 
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/event.h"
-#include "wx/validate.h"
-#include "wx/cursor.h"
-#include "wx/font.h"
-#include "wx/region.h"
-#include "wx/accel.h"
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const wxChar *wxFrameNameStr;
-extern wxWindowList wxTopLevelWindows;
-
-//-----------------------------------------------------------------------------
-// global function
-//-----------------------------------------------------------------------------
-
-extern wxWindow* wxGetActiveWindow();
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxLayoutConstraints;
-class wxSizer;
-class wxDC;
-class wxClientData;
-class wxVoidClientData;
-class wxWindow;
-#if wxUSE_WX_RESOURCES
-    class wxResourceTable;
-    class wxItemResource;
-#endif
-#if wxUSE_DRAG_AND_DROP
-    class wxDropTarget;
-#endif
-class wxToolTip;
-
 //-----------------------------------------------------------------------------
 // callback definition for inserting a window (internal)
 //-----------------------------------------------------------------------------
 
 typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );
 
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const wxChar *wxPanelNameStr;
-extern const wxSize wxDefaultSize;
-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;
-};
-
 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------
 
-class wxWindow : public wxEvtHandler
+class wxWindow : public wxWindowBase
 {
     DECLARE_DYNAMIC_CLASS(wxWindow)
 
@@ -110,300 +33,111 @@ public:
     // creating the window
     // -------------------
     wxWindow();
-    wxWindow(wxWindow *parent, wxWindowID id,
+    wxWindow(wxWindow *parent,
+             wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = 0,
              const wxString& name = wxPanelNameStr);
-    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);
     virtual ~wxWindow();
 
-#if wxUSE_WX_RESOURCES
+    // implement base class (pure) virtual methods
-    virtual bool LoadFromResource(wxWindow *parent,
+    // -------------------------------------------
-                                  const wxString& resourceName,
-                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
-    virtual wxControl *CreateItem(const wxItemResource* childResource,
-                                  const wxItemResource* parentResource,
-                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
-#endif // wxUSE_WX_RESOURCES
-
-    // closing the window
-    // ------------------
-    bool Close( bool force = FALSE );
     virtual bool Destroy();
-    virtual bool DestroyChildren();
-
-    bool IsBeingDeleted();
-
-    // 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);
-    }
-
-        // position with respect to the the parent window
-    virtual void Centre( int direction = wxHORIZONTAL );
-    void Center(int direction = wxHORIZONTAL) { Centre(direction); }
-    virtual void Fit();
-
-        // set min/max size of the window
-    virtual void SetSizeHints( int minW, int minH,
-                               int maxW = -1, int maxH = -1,
-                               int incW = -1, int incH = -1 );
-
-    // Dialog units translations. Implemented in wincmn.cpp.
-    // -----------------------------------------------------
-
-    wxPoint ConvertPixelsToDialog( const wxPoint& pt );
-    wxPoint ConvertDialogToPixels( const wxPoint& pt );
-    wxSize ConvertPixelsToDialog( const wxSize& sz )
-    {
-        wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
-        
-        return wxSize(pt.x, pt.y);
-    }
-
-    wxSize ConvertDialogToPixels( const wxSize& sz )
-    {
-        wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
-
-        return wxSize(pt.x, pt.y);
-    }
-
-    void OnSize( wxSizeEvent &event );
-
-    // window state
-    // ------------
-
-    virtual bool Show( bool show );
-    virtual void Enable( bool enable );
-    virtual void MakeModal( bool modal );
-    virtual bool IsEnabled() const { return m_isEnabled; }
-    inline bool Enabled() const { return IsEnabled(); }
-
-    virtual void SetFocus();
-    static wxWindow *FindFocus();
-
-    void SetReturnCode( int retCode );
-    int GetReturnCode();
-
-    // parent/children relations
-    // -------------------------
-
-    virtual void AddChild( wxWindow *child );
-    wxList& GetChildren() { return m_children; }
-
-    virtual void RemoveChild( wxWindow *child );
-
-    wxWindow *GetParent() const
-        { return m_parent; }
-    wxWindow *GetGrandParent() const
-        { return (m_parent ? m_parent->m_parent : (wxWindow*)NULL); }
-    void SetParent( wxWindow *parent )
-        { m_parent = parent; }
-    virtual wxWindow *ReParent( wxWindow *newParent );
-
-    // event handler stuff
-    // -------------------
-
-    wxEvtHandler *GetEventHandler() const;
-    void SetEventHandler( wxEvtHandler *handler );
-    void PushEventHandler( wxEvtHandler *handler );
-    wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
-
-    // validators and client data
-    // --------------------------
-
-    virtual void SetValidator( const wxValidator &validator );
-    virtual wxValidator *GetValidator();
-
-    virtual void SetClientObject( wxClientData *data );
-    virtual wxClientData *GetClientObject();
-
-    virtual void SetClientData( void *data );
-    virtual void *GetClientData();
-
-    // accelerators
-    // ------------
-    virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
-    virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }
-
-    void SetId( wxWindowID id );
-    wxWindowID GetId() const;
-
-    void SetCursor( const wxCursor &cursor );
-
-    virtual void PrepareDC( wxDC &dc );
-
-    void WarpPointer(int x, int y);
-
-#if wxUSE_TOOLTIPS
-    void SetToolTip( const wxString &tip );
-    virtual void SetToolTip( wxToolTip *tip );
-    wxToolTip* GetToolTip() const { return m_toolTip; }
-#endif // wxUSE_TOOLTIPS
-
-    virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = (const wxRect *) NULL );
-    virtual void Clear();
-
-    virtual wxRegion GetUpdateRegion() const;
-    virtual bool IsExposed( int x, int y ) 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;
-
-    // colours
-    // -------
-
-    virtual wxColour GetBackgroundColour() const;
-    virtual void SetBackgroundColour( const wxColour &colour );
-    virtual wxColour GetForegroundColour() const;
-    virtual void SetForegroundColour( const wxColour &colour );
-
-    // fonts
-    // -----
-
-    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, bool use16 = FALSE) const;
-
-    virtual void SetFont( const wxFont &font );
-    virtual wxFont& GetFont() { return m_font; }
-
-    // For backward compatibility
-    virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
-    virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
-    virtual wxFont& GetLabelFont() { return GetFont(); };
-    virtual wxFont& GetButtonFont() { return GetFont(); };
-
-    virtual void SetWindowStyleFlag( long flag );
-    virtual long GetWindowStyleFlag() const;
-
-    virtual void CaptureMouse();
-    virtual void ReleaseMouse();
-
-    virtual void SetTitle( const wxString &title );
-    virtual wxString GetTitle() const;
-    virtual void SetName( const wxString &name );
-    virtual wxString GetName() const;
-    virtual wxString GetLabel() const;
-
-    void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) { }
-    void OnKeyDown( wxKeyEvent &event );
-
-    virtual bool IsShown() const;
 
     virtual void Raise();
     virtual void Lower();
 
-    virtual bool IsRetained();
+    virtual bool Show( bool show = TRUE );
-    virtual wxWindow *FindWindow( long id );
+    virtual bool Enable( bool enable = TRUE );
-    virtual wxWindow *FindWindow( const wxString& name );
 
-    void AllowDoubleClick( bool WXUNUSED(allow) ) { }
+    virtual bool IsRetained() const;
-    void SetDoubleClick( bool WXUNUSED(allow) ) { }
 
-    virtual void ClientToScreen( int *x, int *y );
+    virtual void SetFocus();
-    virtual void ScreenToClient( int *x, int *y );
+    virtual bool AcceptsFocus() const;
 
-    virtual bool Validate();
+    virtual bool Reparent( wxWindow *newParent );
-    virtual bool TransferDataToWindow();
+
-    virtual bool TransferDataFromWindow();
+    virtual void WarpPointer(int x, int y);
-    void OnInitDialog( wxInitDialogEvent &event );
+    virtual void CaptureMouse();
-    virtual void InitDialog();
+    virtual void ReleaseMouse();
+
+    virtual void Refresh( bool eraseBackground = TRUE,
+                          const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
+
+    virtual bool SetBackgroundColour( const wxColour &colour );
+    virtual bool SetForegroundColour( const wxColour &colour );
+    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 );
 
-#if wxUSE_DRAG_AND_DROP
-    virtual void SetDropTarget( wxDropTarget *dropTarget );
-    virtual wxDropTarget *GetDropTarget() const;
-#endif
-
     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 );
+    virtual void ScrollWindow( int dx, int dy,
+                               const wxRect* rect = (wxRect *) NULL );
 
-    virtual bool AcceptsFocus() const;
+#if wxUSE_DRAG_AND_DROP
-
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
-    void UpdateWindowUI();
+#endif // wxUSE_DRAG_AND_DROP
 
     // implementation
+    // --------------
 
-    bool HasVMT();
+    // wxWindows callbacks
+    void OnKeyDown( wxKeyEvent &event );
+
+    // simple accessors
+    bool HasVMT() const { return m_hasVMT; }
+
+    int GetX() const { return m_x; }
+    int GetY() const { return m_y; }
+    int GetWidth() const { return m_width; }
+    int GetHeight() const { return m_height; }
+
+    GtkWidget *GetWxWindow() const { return m_wxwindow; }
+    GtkWidget *GetWidget() const { return GetHandle(); }
+
+    GtkAdjustment *GetHAdjust() const { return m_hAdjust; }
+    GtkAdjustment *GetVAdjust() const { return m_vAdjust; }
+
+    float GetOldHorizontalPos() const { return m_oldHorizontalPos; }
+    float GetOldVerticalPos() const { return m_oldVerticalPos; }
+
+    void SetOldHorizontalPos(float fpos) { m_oldHorizontalPos = fpos; }
+    void SetOldVerticalPos(float fpos) { m_oldVerticalPos = fpos; }
+
+    bool IsSizeSet() const { return m_sizeSet; }
+
+    // also sets the global flag
+    void SetScrolling(bool scroll);
+
+    bool HasScrolling() const { return m_hasScrolling; }
+    bool IsScrolling() const { return m_isScrolling; }
+    bool IsStaticBox() const { return m_isStaticBox; }
 
     /* I don't want users to override what's done in idle so everything that
        has to be done in idle time in order for wxGTK to work is done in
@@ -418,6 +152,9 @@ public:
             const wxSize &size, long style, const wxString &name );
     void PostCreation();
 
+    void InsertChild(wxWindow *child) { (*m_insertCallback)(this, child); }
+    void DoAddChild(wxWindow *child) { AddChild(child); InsertChild(child); }
+
     /* the methods below are required because many native widgets
        are composed of several subwidgets and setting a style for
        the widget means setting it for all subwidgets as well.
@@ -437,107 +174,57 @@ public:
     virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
 #endif // wxUSE_TOOLTIPS
 
-    /* private member variables */
+    // called from GTK signales handlers
+    void UpdateSize() { m_sizeSet = FALSE; }
+    void InternalSetPosition(int x, int y) { m_x = x; m_y = y; }
+    void InternalSetSize(int w, int h)
+        { m_width = w; m_height = h; UpdateSize(); }
 
-    wxWindow            *m_parent;
+protected:
-    wxList               m_children;
+    // position and size of the window
     int                  m_x, m_y;
     int                  m_width, m_height;
-    int                  m_minWidth,m_minHeight;
-    int                  m_maxWidth,m_maxHeight;
-    int                  m_retCode;
-    wxEvtHandler        *m_eventHandler;
-    wxValidator         *m_windowValidator;
-#if wxUSE_DRAG_AND_DROP
-    wxDropTarget        *m_dropTarget;
-#endif
-    wxWindowID           m_windowId;
-    wxCursor             m_cursor;
-    wxFont               m_font;
-    wxColour             m_backgroundColour;
-    wxColour             m_foregroundColour;
-    wxRegion             m_updateRegion;
-    long                 m_windowStyle;
-    bool                 m_isShown;
-    bool                 m_isEnabled;
-    wxString             m_windowName;
-    wxAcceleratorTable   m_acceleratorTable;
-    wxClientData        *m_clientObject;
-    void                *m_clientData;
 
-#if wxUSE_TOOLTIPS
+    // see the docs in src/gtk/window.cpp
-    wxToolTip           *m_toolTip;
-#endif // wxUSE_TOOLTIPS
-
-    GtkWidget           *m_widget;
     GtkWidget           *m_wxwindow;
+
+    // scrolling stuff
     GtkAdjustment       *m_hAdjust,*m_vAdjust;
-    float                m_oldHorizontalPos;
+    float                m_oldHorizontalPos,
-    float                m_oldVerticalPos;
+                         m_oldVerticalPos;
-    bool                 m_needParent;    /* ! wxFrame, wxDialog, wxNotebookPage ?  */
-    bool                 m_hasScrolling;
-    bool                 m_isScrolling;
-    bool                 m_hasVMT;
-    bool                 m_sizeSet;
-    bool                 m_resizing;
     GdkGC               *m_scrollGC;
+
+    // extra (wxGTK-specific) flags
+    bool                 m_needParent:1;    /* ! wxFrame, wxDialog, wxNotebookPage ?  */
+    bool                 m_hasScrolling:1;
+    bool                 m_isScrolling:1;
+    bool                 m_hasVMT:1;
+    bool                 m_sizeSet:1;
+    bool                 m_resizing:1;
+    bool                 m_isStaticBox:1;   /* faster than IS_KIND_OF */
+    bool                 m_isFrame:1;       /* faster than IS_KIND_OF */
+    bool                 m_acceptsFocus:1;  /* ! wxStaticBox etc.  */
+
     GtkStyle            *m_widgetStyle;
-    bool                 m_isStaticBox;   /* faster than IS_KIND_OF */
-    bool                 m_isFrame;       /* faster than IS_KIND_OF */
-    bool                 m_acceptsFocus;  /* ! wxStaticBox etc.  */
 
     wxInsertChildFunction  m_insertCallback;
 
-public:
+    // implement the base class pure virtuals
-
+    virtual void DoGetPosition( int *x, int *y ) const;
-    wxLayoutConstraints *m_constraints;
+    virtual void DoGetSize( int *width, int *height ) const;
-    wxList              *m_constraintsInvolvedIn;
+    virtual void DoGetClientSize( int *width, int *height ) const;
-    wxSizer             *m_windowSizer;
-    wxWindow            *m_sizerParent;
-    bool                 m_autoLayout;
-
-    wxLayoutConstraints *GetConstraints() const;
-    void SetConstraints( wxLayoutConstraints *constraints );
-    void SetAutoLayout( bool autoLayout );
-    bool GetAutoLayout() const;
-    bool Layout();
-    void SetSizer( wxSizer *sizer );
-    wxSizer *GetSizer() const;
-    void SetSizerParent( wxWindow *win );
-    wxWindow *GetSizerParent() const;
-    void UnsetConstraints(wxLayoutConstraints *c);
-    inline wxList *GetConstraintsInvolvedIn() const ;
-    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);
-    virtual void TransformSizerToActual(int *x, int *y) const ;
-    virtual void SizerSetSize(int x, int y, int w, int h);
-    virtual void SizerMove(int x, int y);
-    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 ;
-
-protected:
-    // common part of all ctors
-    void Init();
-
-    // this is the virtual function to be overriden in any derived class which
-    // wants to change how SetSize() or Move() works - it is called by all
-    // versions of these functions in the base class
     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
+
+    // common part of all ctors (can't be virtual because called from ctor)
+    void Init();
+
 private:
     DECLARE_EVENT_TABLE()
 };

include/wx/gtk1/bmpbuttn.h

@@ -72,7 +72,7 @@ public:
   void SetBitmapLabel( const wxBitmap& bitmap );
   void SetBitmapSelected( const wxBitmap& bitmap );
     
-  virtual void Enable(const bool);
+  virtual bool Enable(const bool);
   
 // implementation
 

include/wx/gtk1/button.h

@@ -59,7 +59,7 @@ class wxButton: public wxControl
            const wxString& name = wxButtonNameStr);
     void SetDefault();
     void SetLabel( const wxString &label );
-    void Enable( bool enable );
+    bool Enable( bool enable );
     
   // implementation        
   

include/wx/gtk1/checkbox.h

@@ -63,7 +63,7 @@ public:
     bool GetValue() const;
 
     void SetLabel( const wxString& label );
-    void Enable( bool enable );
+    bool Enable( bool enable );
 
     // implementation
     void ApplyWidgetStyle();

include/wx/gtk1/dialog.h

@@ -87,6 +87,9 @@ public:
     virtual void Maximize() { }
     virtual void Restore() { }
 
+    void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
+    int GetReturnCode() const { return m_returnCode; }
+
     // implementation
 
     virtual void GtkOnSize( int x, int y, int width, int height );
@@ -105,6 +108,8 @@ protected:
                            int sizeFlags = wxSIZE_AUTO);
 
 private:
+    int m_returnCode;
+
     DECLARE_EVENT_TABLE()
 };
 

include/wx/gtk1/font.h

@@ -58,8 +58,8 @@ public:
   wxFont( const wxFont& font );
   ~wxFont();
   wxFont& operator = ( const wxFont& font );
-  bool operator == ( const wxFont& font );
+  bool operator == ( const wxFont& font ) const;
-  bool operator != ( const wxFont& font );
+  bool operator != ( const wxFont& font ) const;
   bool Ok() const;
 
   int GetPointSize() const;

include/wx/gtk1/radiobox.h

@@ -70,7 +70,7 @@ class wxRadioBox: public wxControl
     void SetLabel( int item, wxBitmap *bitmap );
     wxString GetLabel( int item ) const;
     bool Show( bool show );
-    void Enable( bool enable );
+    bool Enable( bool enable );
     void Enable( int item, bool enable );
     void Show( int item, bool show );
     virtual wxString GetStringSelection(void) const;

include/wx/gtk1/radiobut.h

@@ -60,7 +60,7 @@ class wxRadioButton: public wxControl
     virtual void SetLabel(const wxString& label);
     virtual void SetValue(bool val);
     virtual bool GetValue(void) const;
-    void Enable( bool enable );
+    bool Enable( bool enable );
     
   // implementation
     

include/wx/gtk1/textctrl.h

@@ -143,9 +143,9 @@ class wxTextCtrl: public wxControl
     wxTextCtrl& operator<<(const char c);
 #endif
 
-    void SetFont( const wxFont &font );
+    bool SetFont( const wxFont &font );
-    void SetForegroundColour(const wxColour &colour);
+    bool SetForegroundColour(const wxColour &colour);
-    void SetBackgroundColour(const wxColour &colour);
+    bool SetBackgroundColour(const wxColour &colour);
 
   // implementation    
     

include/wx/gtk1/window.h

@@ -15,94 +15,17 @@
     #pragma interface
 #endif
 
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/event.h"
-#include "wx/validate.h"
-#include "wx/cursor.h"
-#include "wx/font.h"
-#include "wx/region.h"
-#include "wx/accel.h"
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const wxChar *wxFrameNameStr;
-extern wxWindowList wxTopLevelWindows;
-
-//-----------------------------------------------------------------------------
-// global function
-//-----------------------------------------------------------------------------
-
-extern wxWindow* wxGetActiveWindow();
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxLayoutConstraints;
-class wxSizer;
-class wxDC;
-class wxClientData;
-class wxVoidClientData;
-class wxWindow;
-#if wxUSE_WX_RESOURCES
-    class wxResourceTable;
-    class wxItemResource;
-#endif
-#if wxUSE_DRAG_AND_DROP
-    class wxDropTarget;
-#endif
-class wxToolTip;
-
 //-----------------------------------------------------------------------------
 // callback definition for inserting a window (internal)
 //-----------------------------------------------------------------------------
 
 typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );
 
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const wxChar *wxPanelNameStr;
-extern const wxSize wxDefaultSize;
-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;
-};
-
 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------
 
-class wxWindow : public wxEvtHandler
+class wxWindow : public wxWindowBase
 {
     DECLARE_DYNAMIC_CLASS(wxWindow)
 
@@ -110,300 +33,111 @@ public:
     // creating the window
     // -------------------
     wxWindow();
-    wxWindow(wxWindow *parent, wxWindowID id,
+    wxWindow(wxWindow *parent,
+             wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = 0,
              const wxString& name = wxPanelNameStr);
-    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);
     virtual ~wxWindow();
 
-#if wxUSE_WX_RESOURCES
+    // implement base class (pure) virtual methods
-    virtual bool LoadFromResource(wxWindow *parent,
+    // -------------------------------------------
-                                  const wxString& resourceName,
-                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
-    virtual wxControl *CreateItem(const wxItemResource* childResource,
-                                  const wxItemResource* parentResource,
-                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
-#endif // wxUSE_WX_RESOURCES
-
-    // closing the window
-    // ------------------
-    bool Close( bool force = FALSE );
     virtual bool Destroy();
-    virtual bool DestroyChildren();
-
-    bool IsBeingDeleted();
-
-    // 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);
-    }
-
-        // position with respect to the the parent window
-    virtual void Centre( int direction = wxHORIZONTAL );
-    void Center(int direction = wxHORIZONTAL) { Centre(direction); }
-    virtual void Fit();
-
-        // set min/max size of the window
-    virtual void SetSizeHints( int minW, int minH,
-                               int maxW = -1, int maxH = -1,
-                               int incW = -1, int incH = -1 );
-
-    // Dialog units translations. Implemented in wincmn.cpp.
-    // -----------------------------------------------------
-
-    wxPoint ConvertPixelsToDialog( const wxPoint& pt );
-    wxPoint ConvertDialogToPixels( const wxPoint& pt );
-    wxSize ConvertPixelsToDialog( const wxSize& sz )
-    {
-        wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
-        
-        return wxSize(pt.x, pt.y);
-    }
-
-    wxSize ConvertDialogToPixels( const wxSize& sz )
-    {
-        wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
-
-        return wxSize(pt.x, pt.y);
-    }
-
-    void OnSize( wxSizeEvent &event );
-
-    // window state
-    // ------------
-
-    virtual bool Show( bool show );
-    virtual void Enable( bool enable );
-    virtual void MakeModal( bool modal );
-    virtual bool IsEnabled() const { return m_isEnabled; }
-    inline bool Enabled() const { return IsEnabled(); }
-
-    virtual void SetFocus();
-    static wxWindow *FindFocus();
-
-    void SetReturnCode( int retCode );
-    int GetReturnCode();
-
-    // parent/children relations
-    // -------------------------
-
-    virtual void AddChild( wxWindow *child );
-    wxList& GetChildren() { return m_children; }
-
-    virtual void RemoveChild( wxWindow *child );
-
-    wxWindow *GetParent() const
-        { return m_parent; }
-    wxWindow *GetGrandParent() const
-        { return (m_parent ? m_parent->m_parent : (wxWindow*)NULL); }
-    void SetParent( wxWindow *parent )
-        { m_parent = parent; }
-    virtual wxWindow *ReParent( wxWindow *newParent );
-
-    // event handler stuff
-    // -------------------
-
-    wxEvtHandler *GetEventHandler() const;
-    void SetEventHandler( wxEvtHandler *handler );
-    void PushEventHandler( wxEvtHandler *handler );
-    wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
-
-    // validators and client data
-    // --------------------------
-
-    virtual void SetValidator( const wxValidator &validator );
-    virtual wxValidator *GetValidator();
-
-    virtual void SetClientObject( wxClientData *data );
-    virtual wxClientData *GetClientObject();
-
-    virtual void SetClientData( void *data );
-    virtual void *GetClientData();
-
-    // accelerators
-    // ------------
-    virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
-    virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }
-
-    void SetId( wxWindowID id );
-    wxWindowID GetId() const;
-
-    void SetCursor( const wxCursor &cursor );
-
-    virtual void PrepareDC( wxDC &dc );
-
-    void WarpPointer(int x, int y);
-
-#if wxUSE_TOOLTIPS
-    void SetToolTip( const wxString &tip );
-    virtual void SetToolTip( wxToolTip *tip );
-    wxToolTip* GetToolTip() const { return m_toolTip; }
-#endif // wxUSE_TOOLTIPS
-
-    virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = (const wxRect *) NULL );
-    virtual void Clear();
-
-    virtual wxRegion GetUpdateRegion() const;
-    virtual bool IsExposed( int x, int y ) 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;
-
-    // colours
-    // -------
-
-    virtual wxColour GetBackgroundColour() const;
-    virtual void SetBackgroundColour( const wxColour &colour );
-    virtual wxColour GetForegroundColour() const;
-    virtual void SetForegroundColour( const wxColour &colour );
-
-    // fonts
-    // -----
-
-    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, bool use16 = FALSE) const;
-
-    virtual void SetFont( const wxFont &font );
-    virtual wxFont& GetFont() { return m_font; }
-
-    // For backward compatibility
-    virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
-    virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
-    virtual wxFont& GetLabelFont() { return GetFont(); };
-    virtual wxFont& GetButtonFont() { return GetFont(); };
-
-    virtual void SetWindowStyleFlag( long flag );
-    virtual long GetWindowStyleFlag() const;
-
-    virtual void CaptureMouse();
-    virtual void ReleaseMouse();
-
-    virtual void SetTitle( const wxString &title );
-    virtual wxString GetTitle() const;
-    virtual void SetName( const wxString &name );
-    virtual wxString GetName() const;
-    virtual wxString GetLabel() const;
-
-    void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) { }
-    void OnKeyDown( wxKeyEvent &event );
-
-    virtual bool IsShown() const;
 
     virtual void Raise();
     virtual void Lower();
 
-    virtual bool IsRetained();
+    virtual bool Show( bool show = TRUE );
-    virtual wxWindow *FindWindow( long id );
+    virtual bool Enable( bool enable = TRUE );
-    virtual wxWindow *FindWindow( const wxString& name );
 
-    void AllowDoubleClick( bool WXUNUSED(allow) ) { }
+    virtual bool IsRetained() const;
-    void SetDoubleClick( bool WXUNUSED(allow) ) { }
 
-    virtual void ClientToScreen( int *x, int *y );
+    virtual void SetFocus();
-    virtual void ScreenToClient( int *x, int *y );
+    virtual bool AcceptsFocus() const;
 
-    virtual bool Validate();
+    virtual bool Reparent( wxWindow *newParent );
-    virtual bool TransferDataToWindow();
+
-    virtual bool TransferDataFromWindow();
+    virtual void WarpPointer(int x, int y);
-    void OnInitDialog( wxInitDialogEvent &event );
+    virtual void CaptureMouse();
-    virtual void InitDialog();
+    virtual void ReleaseMouse();
+
+    virtual void Refresh( bool eraseBackground = TRUE,
+                          const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
+
+    virtual bool SetBackgroundColour( const wxColour &colour );
+    virtual bool SetForegroundColour( const wxColour &colour );
+    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 );
 
-#if wxUSE_DRAG_AND_DROP
-    virtual void SetDropTarget( wxDropTarget *dropTarget );
-    virtual wxDropTarget *GetDropTarget() const;
-#endif
-
     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 );
+    virtual void ScrollWindow( int dx, int dy,
+                               const wxRect* rect = (wxRect *) NULL );
 
-    virtual bool AcceptsFocus() const;
+#if wxUSE_DRAG_AND_DROP
-
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
-    void UpdateWindowUI();
+#endif // wxUSE_DRAG_AND_DROP
 
     // implementation
+    // --------------
 
-    bool HasVMT();
+    // wxWindows callbacks
+    void OnKeyDown( wxKeyEvent &event );
+
+    // simple accessors
+    bool HasVMT() const { return m_hasVMT; }
+
+    int GetX() const { return m_x; }
+    int GetY() const { return m_y; }
+    int GetWidth() const { return m_width; }
+    int GetHeight() const { return m_height; }
+
+    GtkWidget *GetWxWindow() const { return m_wxwindow; }
+    GtkWidget *GetWidget() const { return GetHandle(); }
+
+    GtkAdjustment *GetHAdjust() const { return m_hAdjust; }
+    GtkAdjustment *GetVAdjust() const { return m_vAdjust; }
+
+    float GetOldHorizontalPos() const { return m_oldHorizontalPos; }
+    float GetOldVerticalPos() const { return m_oldVerticalPos; }
+
+    void SetOldHorizontalPos(float fpos) { m_oldHorizontalPos = fpos; }
+    void SetOldVerticalPos(float fpos) { m_oldVerticalPos = fpos; }
+
+    bool IsSizeSet() const { return m_sizeSet; }
+
+    // also sets the global flag
+    void SetScrolling(bool scroll);
+
+    bool HasScrolling() const { return m_hasScrolling; }
+    bool IsScrolling() const { return m_isScrolling; }
+    bool IsStaticBox() const { return m_isStaticBox; }
 
     /* I don't want users to override what's done in idle so everything that
        has to be done in idle time in order for wxGTK to work is done in
@@ -418,6 +152,9 @@ public:
             const wxSize &size, long style, const wxString &name );
     void PostCreation();
 
+    void InsertChild(wxWindow *child) { (*m_insertCallback)(this, child); }
+    void DoAddChild(wxWindow *child) { AddChild(child); InsertChild(child); }
+
     /* the methods below are required because many native widgets
        are composed of several subwidgets and setting a style for
        the widget means setting it for all subwidgets as well.
@@ -437,107 +174,57 @@ public:
     virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
 #endif // wxUSE_TOOLTIPS
 
-    /* private member variables */
+    // called from GTK signales handlers
+    void UpdateSize() { m_sizeSet = FALSE; }
+    void InternalSetPosition(int x, int y) { m_x = x; m_y = y; }
+    void InternalSetSize(int w, int h)
+        { m_width = w; m_height = h; UpdateSize(); }
 
-    wxWindow            *m_parent;
+protected:
-    wxList               m_children;
+    // position and size of the window
     int                  m_x, m_y;
     int                  m_width, m_height;
-    int                  m_minWidth,m_minHeight;
-    int                  m_maxWidth,m_maxHeight;
-    int                  m_retCode;
-    wxEvtHandler        *m_eventHandler;
-    wxValidator         *m_windowValidator;
-#if wxUSE_DRAG_AND_DROP
-    wxDropTarget        *m_dropTarget;
-#endif
-    wxWindowID           m_windowId;
-    wxCursor             m_cursor;
-    wxFont               m_font;
-    wxColour             m_backgroundColour;
-    wxColour             m_foregroundColour;
-    wxRegion             m_updateRegion;
-    long                 m_windowStyle;
-    bool                 m_isShown;
-    bool                 m_isEnabled;
-    wxString             m_windowName;
-    wxAcceleratorTable   m_acceleratorTable;
-    wxClientData        *m_clientObject;
-    void                *m_clientData;
 
-#if wxUSE_TOOLTIPS
+    // see the docs in src/gtk/window.cpp
-    wxToolTip           *m_toolTip;
-#endif // wxUSE_TOOLTIPS
-
-    GtkWidget           *m_widget;
     GtkWidget           *m_wxwindow;
+
+    // scrolling stuff
     GtkAdjustment       *m_hAdjust,*m_vAdjust;
-    float                m_oldHorizontalPos;
+    float                m_oldHorizontalPos,
-    float                m_oldVerticalPos;
+                         m_oldVerticalPos;
-    bool                 m_needParent;    /* ! wxFrame, wxDialog, wxNotebookPage ?  */
-    bool                 m_hasScrolling;
-    bool                 m_isScrolling;
-    bool                 m_hasVMT;
-    bool                 m_sizeSet;
-    bool                 m_resizing;
     GdkGC               *m_scrollGC;
+
+    // extra (wxGTK-specific) flags
+    bool                 m_needParent:1;    /* ! wxFrame, wxDialog, wxNotebookPage ?  */
+    bool                 m_hasScrolling:1;
+    bool                 m_isScrolling:1;
+    bool                 m_hasVMT:1;
+    bool                 m_sizeSet:1;
+    bool                 m_resizing:1;
+    bool                 m_isStaticBox:1;   /* faster than IS_KIND_OF */
+    bool                 m_isFrame:1;       /* faster than IS_KIND_OF */
+    bool                 m_acceptsFocus:1;  /* ! wxStaticBox etc.  */
+
     GtkStyle            *m_widgetStyle;
-    bool                 m_isStaticBox;   /* faster than IS_KIND_OF */
-    bool                 m_isFrame;       /* faster than IS_KIND_OF */
-    bool                 m_acceptsFocus;  /* ! wxStaticBox etc.  */
 
     wxInsertChildFunction  m_insertCallback;
 
-public:
+    // implement the base class pure virtuals
-
+    virtual void DoGetPosition( int *x, int *y ) const;
-    wxLayoutConstraints *m_constraints;
+    virtual void DoGetSize( int *width, int *height ) const;
-    wxList              *m_constraintsInvolvedIn;
+    virtual void DoGetClientSize( int *width, int *height ) const;
-    wxSizer             *m_windowSizer;
-    wxWindow            *m_sizerParent;
-    bool                 m_autoLayout;
-
-    wxLayoutConstraints *GetConstraints() const;
-    void SetConstraints( wxLayoutConstraints *constraints );
-    void SetAutoLayout( bool autoLayout );
-    bool GetAutoLayout() const;
-    bool Layout();
-    void SetSizer( wxSizer *sizer );
-    wxSizer *GetSizer() const;
-    void SetSizerParent( wxWindow *win );
-    wxWindow *GetSizerParent() const;
-    void UnsetConstraints(wxLayoutConstraints *c);
-    inline wxList *GetConstraintsInvolvedIn() const ;
-    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);
-    virtual void TransformSizerToActual(int *x, int *y) const ;
-    virtual void SizerSetSize(int x, int y, int w, int h);
-    virtual void SizerMove(int x, int y);
-    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 ;
-
-protected:
-    // common part of all ctors
-    void Init();
-
-    // this is the virtual function to be overriden in any derived class which
-    // wants to change how SetSize() or Move() works - it is called by all
-    // versions of these functions in the base class
     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
+
+    // common part of all ctors (can't be virtual because called from ctor)
+    void Init();
+
 private:
     DECLARE_EVENT_TABLE()
 };

include/wx/layout.h

@@ -12,14 +12,16 @@
 #ifndef _WX_LAYOUTH__
 #define _WX_LAYOUTH__
 
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
     #pragma interface "layout.h"
 #endif
 
 #include "wx/defs.h"
 
-class WXDLLEXPORT wxWindow;
-
 // X stupidly defines these in X.h
 #ifdef Above
     #undef Above
@@ -28,11 +30,28 @@ class WXDLLEXPORT wxWindow;
     #undef Below
 #endif
 
+// ----------------------------------------------------------------------------
+// forward declrations
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindowBase;
+class WXDLLEXPORT wxLayoutConstraints;
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
 #define wxLAYOUT_DEFAULT_MARGIN 0
 
-enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
+enum wxEdge
-  wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
+{
-enum wxRelationship { wxUnconstrained = 0,
+    wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
+    wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY
+};
+
+enum wxRelationship
+{
+    wxUnconstrained = 0,
     wxAsIs,
     wxPercentOf,
     wxAbove,
@@ -40,9 +59,26 @@ enum wxRelationship { wxUnconstrained = 0,
     wxLeftOf,
     wxRightOf,
     wxSameAs,
-                      wxAbsolute };
+    wxAbsolute
+};
+
+enum wxSizerBehaviour
+{
+    wxSizerShrink,
+    wxSizerExpand,
+    wxSizerNone
+};
+
+#define wxTYPE_SIZER        90
+
+// =============================================================================
+// classes
+// =============================================================================
+
+// ----------------------------------------------------------------------------
+// wxIndividualLayoutConstraint: a constraint on window position
+// ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxLayoutConstraints;
 class WXDLLEXPORT wxIndividualLayoutConstraint : public wxObject
 {
     DECLARE_DYNAMIC_CLASS(wxIndividualLayoutConstraint)
@@ -52,7 +88,7 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
     friend class wxIndividualLayoutConstraint_Serialize;
 
     // 'This' window is the parent or sibling of otherWin
-   wxWindow *otherWin;
+    wxWindowBase *otherWin;
 
     wxEdge myEdge;
     wxRelationship relationship;
@@ -66,23 +102,23 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
     wxIndividualLayoutConstraint();
     ~wxIndividualLayoutConstraint();
 
-  void Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val = 0, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val = 0, int marg = wxLAYOUT_DEFAULT_MARGIN);
 
     //
     // Sibling relationships
     //
-  void LeftOf(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void LeftOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
-  void RightOf(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void RightOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
-  void Above(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void Above(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
-  void Below(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void Below(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
 
     //
     // 'Same edge' alignment
     //
-  void SameAs(wxWindow *otherW, wxEdge edge, int marg = wxLAYOUT_DEFAULT_MARGIN);
+    void SameAs(wxWindowBase *otherW, wxEdge edge, int marg = wxLAYOUT_DEFAULT_MARGIN);
 
     // The edge is a percentage of the other window's edge
-  void PercentOf(wxWindow *otherW, wxEdge wh, int per);
+    void PercentOf(wxWindowBase *otherW, wxEdge wh, int per);
 
     //
     // Edge has absolute value
@@ -92,41 +128,45 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
     //
     // Dimension is unconstrained
     //
-  inline void Unconstrained() { relationship = wxUnconstrained; }
+    void Unconstrained() { relationship = wxUnconstrained; }
 
     //
     // Dimension is 'as is' (use current size settings)
     //
-  inline void AsIs() { relationship = wxAsIs; }
+    void AsIs() { relationship = wxAsIs; }
 
     //
     // Accessors
     //
-  inline wxWindow *GetOtherWindow() { return otherWin; }
+    wxWindowBase *GetOtherWindow() { return otherWin; }
-  inline wxEdge GetMyEdge() const { return myEdge; }
+    wxEdge GetMyEdge() const { return myEdge; }
-  inline void SetEdge(wxEdge which) { myEdge = which; }
+    void SetEdge(wxEdge which) { myEdge = which; }
-  inline void SetValue(int v) { value = v; }
+    void SetValue(int v) { value = v; }
-  inline int GetMargin() { return margin; }
+    int GetMargin() { return margin; }
-  inline void SetMargin(int m) { margin = m; }
+    void SetMargin(int m) { margin = m; }
-  inline int GetValue() const { return value; }
+    int GetValue() const { return value; }
-  inline int GetPercent() const { return percent; }
+    int GetPercent() const { return percent; }
-  inline int GetOtherEdge() const { return otherEdge; }
+    int GetOtherEdge() const { return otherEdge; }
-  inline bool GetDone() const { return done; }
+    bool GetDone() const { return done; }
-  inline void SetDone(bool d) { done = d; }
+    void SetDone(bool d) { done = d; }
-  inline wxRelationship GetRelationship() { return relationship; }
+    wxRelationship GetRelationship() { return relationship; }
-  inline void SetRelationship(wxRelationship r) { relationship = r; }
+    void SetRelationship(wxRelationship r) { relationship = r; }
 
     // Reset constraint if it mentions otherWin
-  bool ResetIfWin(wxWindow *otherW);
+    bool ResetIfWin(wxWindowBase *otherW);
 
     // Try to satisfy constraint
-  bool SatisfyConstraint(wxLayoutConstraints *constraints, wxWindow *win);
+    bool SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win);
 
     // Get the value of this edge or dimension, or if this
     // is not determinable, -1.
-  int GetEdge(wxEdge which, wxWindow *thisWin, wxWindow *other) const;
+    int GetEdge(wxEdge which, wxWindowBase *thisWin, wxWindowBase *other) const;
 };
 
+// ----------------------------------------------------------------------------
+// wxLayoutConstraints: the complete set of constraints for a window
+// ----------------------------------------------------------------------------
+
 class WXDLLEXPORT wxLayoutConstraints : public wxObject
 {
     DECLARE_DYNAMIC_CLASS(wxLayoutConstraints)
@@ -147,7 +187,7 @@ class WXDLLEXPORT wxLayoutConstraints: public wxObject
     wxLayoutConstraints();
     ~wxLayoutConstraints();
 
-  bool SatisfyConstraints(wxWindow *win, int *noChanges);
+    bool SatisfyConstraints(wxWindowBase *win, int *noChanges);
     bool AreSatisfied() const
     {
         return left.GetDone() && top.GetDone() && right.GetDone() &&
@@ -155,7 +195,9 @@ class WXDLLEXPORT wxLayoutConstraints: public wxObject
     }
 };
 
-bool WXDLLEXPORT wxOldDoLayout(wxWindow *win);
+// ----------------------------------------------------------------------------
+// sizers
+// ----------------------------------------------------------------------------
 
 /*
 
@@ -203,15 +245,6 @@ to the top of the hierarchy and call Layout() again.
 
 */
 
-enum wxSizerBehaviour
-{
-    wxSizerShrink,
-    wxSizerExpand,
-    wxSizerNone
-};
-
-#define wxTYPE_SIZER        90
-
 class WXDLLEXPORT wxSizer : public wxWindow
 {
     DECLARE_DYNAMIC_CLASS(wxSizer)
@@ -227,10 +260,10 @@ protected:
 
 public:
     wxSizer();
-    wxSizer(wxWindow *parent, wxSizerBehaviour behav = wxSizerNone);
+    wxSizer(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
     ~wxSizer();
 
-    bool Create(wxWindow *parent, wxSizerBehaviour behav = wxSizerNone);
+    bool Create(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
 
     virtual void GetSize(int *w, int *h) const;
 
@@ -245,8 +278,8 @@ public:
     int GetBorderX() { return borderX ; }
     int GetBorderY() { return borderY ; }
 
-    virtual void AddSizerChild(wxWindow *child);
+    virtual void AddSizerChild(wxWindowBase *child);
-    virtual void RemoveSizerChild(wxWindow *child);
+    virtual void RemoveSizerChild(wxWindowBase *child);
 
     virtual void SetBehaviour(wxSizerBehaviour b) { sizerBehaviour = b; }
     virtual wxSizerBehaviour GetBehaviour() { return sizerBehaviour; }
@@ -276,11 +309,11 @@ protected:
 public:
     // rowOrCol = TRUE to be laid out in rows, otherwise in columns.
     wxRowColSizer();
-    wxRowColSizer(wxWindow *parent, bool rowOrCol = wxSIZER_ROWS,
+    wxRowColSizer(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
                   int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
     ~wxRowColSizer();
 
-    bool Create(wxWindow *parent, bool rowOrCol = wxSIZER_ROWS,
+    bool Create(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
                 int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
 
     virtual void SetRowOrCol(bool rc) { rowOrCol = rc; }
@@ -300,13 +333,21 @@ DECLARE_DYNAMIC_CLASS(wxSpacingSizer)
 
 public:
     wxSpacingSizer();
-    wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing);
+    wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing);
-    wxSpacingSizer(wxWindow *parent);
+    wxSpacingSizer(wxWindowBase *parent);
     ~wxSpacingSizer();
 
-    bool Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int sp);
+    bool Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int sp);
-    bool Create(wxWindow *parent);
+    bool Create(wxWindowBase *parent);
 };
 
+// ----------------------------------------------------------------------------
+// global functions
+// ----------------------------------------------------------------------------
+
+#if WXWIN_COMPATIBILITY
+    extern bool WXDLLEXPORT wxOldDoLayout(wxWindowBase *win);
+#endif // WXWIN_COMPATIBILITY
+
 #endif
     // _WX_LAYOUTH__

include/wx/list.h

@@ -142,7 +142,7 @@ public:
 
     virtual ~wxNodeBase();
 
-    // @@ no check is done that the list is really keyed on strings
+    // FIXME no check is done that the list is really keyed on strings
     const wxChar *GetKeyString() const { return m_key.string; }
     long GetKeyInteger() const { return m_key.integer; }
 
@@ -339,8 +339,16 @@ private:
 //  2. We redefine all non-type-safe wxList functions with type-safe versions
 //     which don't take any space (everything is inline), but bring compile
 //     time error checking.
+//
+//  3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of
+//     a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most
+//     generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes
+//     interesting capability to store polymorphic objects in the list and is
+//     particularly useful with, for example, "wxWindow *" list where the
+//     wxWindowBase pointers are put into the list, but wxWindow pointers are
+//     retrieved from it.
 
-#define WX_DECLARE_LIST_2(T, name, nodetype)                                \
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype)                         \
     typedef int (*wxSortFuncFor_##name)(const T *, const T *);              \
                                                                             \
     class WXDLLEXPORT nodetype : public wxNodeBase                          \
@@ -390,11 +398,11 @@ private:
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \
-        nodetype *Append(T *object)                                         \
+        nodetype *Append(Tbase *object)                                     \
             { return (nodetype *)wxListBase::Append(object); }              \
-        nodetype *Insert(T *object)                                         \
+        nodetype *Insert(Tbase *object)                                     \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
-        nodetype *Insert(nodetype *prev, T *object)                         \
+        nodetype *Insert(nodetype *prev, Tbase *object)                     \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
@@ -406,16 +414,16 @@ private:
             { return (nodetype *)wxListBase::DetachNode(node); }            \
         bool DeleteNode(nodetype *node)                                     \
             { return wxListBase::DeleteNode(node); }                        \
-        bool DeleteObject(T *object)                                        \
+        bool DeleteObject(Tbase *object)                                    \
             { return wxListBase::DeleteObject(object); }                    \
                                                                             \
-        nodetype *Find(T *object) const                                     \
+        nodetype *Find(Tbase *object) const                                 \
             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \
-        int IndexOf( T *object ) const                                      \
+        int IndexOf(Tbase *object) const                                    \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \
@@ -432,6 +440,9 @@ private:
             }                                                               \
     }
 
+#define WX_DECLARE_LIST_2(elementtype, listname, nodename)                  \
+    WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename)
+
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
     WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
@@ -445,12 +456,9 @@ private:
 // =============================================================================
 
 // ----------------------------------------------------------------------------
-// commonly used string classes
+// commonly used list classes
 // ----------------------------------------------------------------------------
 
-class wxWindow;
-WX_DECLARE_LIST(wxWindow, wxWindowList);
-
 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------

include/wx/tbarbase.h

@@ -158,7 +158,7 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
 #endif
 
   // Lay the tools out
-  virtual void Layout(void);
+  virtual void LayoutTools();
   
   // Add all the buttons: required for Win95.
   virtual bool CreateTools(void) { return TRUE; }

include/wx/tbarsmpl.h

@@ -62,10 +62,10 @@ class WXDLLEXPORT wxToolBarSimple : public wxToolBarBase
 
   virtual void SpringUpButton(int index);
 
-  void Layout(void);
+  virtual void LayoutTools();
 
   // The post-tool-addition call
-  bool Realize() { Layout(); return TRUE; };
+  virtual bool Realize() { LayoutTools(); return TRUE; };
 
 protected:
   int                   m_currentRowsOrColumns;

include/wx/validate.h

@@ -18,7 +18,7 @@
 
 #include "wx/event.h"
 
-class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxWindowBase;
 
 /*
  A validator has up to three purposes:
@@ -36,7 +36,7 @@ class WXDLLEXPORT wxValidator : public wxEvtHandler
 {
 public:
     wxValidator();
-    ~wxValidator();
+    virtual ~wxValidator();
 
     // Make a clone of this validator (or return NULL) - currently necessary
     // if you're passing a reference to a validator.
@@ -49,7 +49,7 @@ public:
 
     // Called when the value in the window must be validated.
     // This function can pop up an error message.
-    virtual bool Validate(wxWindow *WXUNUSED(parent)) { return FALSE; };
+    virtual bool Validate(wxWindowBase *WXUNUSED(parent)) { return FALSE; };
 
     // Called to transfer data to the window
     virtual bool TransferToWindow() { return FALSE; }
@@ -58,8 +58,8 @@ public:
     virtual bool TransferFromWindow() { return FALSE; };
 
     // accessors
-    wxWindow *GetWindow() const { return m_validatorWindow; }
+    wxWindowBase *GetWindow() const { return m_validatorWindow; }
-    void SetWindow(wxWindow *win) { m_validatorWindow = win; }
+    void SetWindow(wxWindowBase *win) { m_validatorWindow = win; }
 
     // validators beep by default if invalid key is pressed, these functions
     // allow to change it
@@ -67,7 +67,7 @@ public:
     static void SetBellOnError(bool doIt = TRUE) { ms_isSilent = doIt; }
 
 protected:
-    wxWindow *m_validatorWindow;
+    wxWindowBase *m_validatorWindow;
 
 private:
     static bool ms_isSilent;

include/wx/window.h

@@ -1,6 +1,731 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        window.h
+// Purpose:     wxWindowBase class - the interface of wxWindowBase
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) wxWindows team
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
 #ifndef _WX_WINDOW_H_BASE_
 #define _WX_WINDOW_H_BASE_
 
+// ----------------------------------------------------------------------------
+// headers which we must include here
+// ----------------------------------------------------------------------------
+
+#include "wx/event.h"           // the base class
+
+#include "wx/list.h"            // defines wxWindowList
+
+#include "wx/cursor.h"          // we have member variables of these classes
+#include "wx/font.h"            // so we can't do without them
+#include "wx/colour.h"
+#include "wx/region.h"
+#include "wx/accel.h"
+
+// ----------------------------------------------------------------------------
+// forward declarations
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxClientData;
+class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxCursor;
+class WXDLLEXPORT wxDc;
+class WXDLLEXPORT wxDropTarget;
+class WXDLLEXPORT wxItemResource;
+class WXDLLEXPORT wxLayoutConstraints;
+class WXDLLEXPORT wxResourceTable;
+class WXDLLEXPORT wxSizer;
+class WXDLLEXPORT wxToolTip;
+class WXDLLEXPORT wxValidator;
+class WXDLLEXPORT wxWindowBase;
+class WXDLLEXPORT wxWindow;
+
+// ----------------------------------------------------------------------------
+// (pseudo)template list classes
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode);
+
+// ----------------------------------------------------------------------------
+// global variables
+// ----------------------------------------------------------------------------
+
+WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
+
+// ----------------------------------------------------------------------------
+// helper classes used by [SG]etClientObject/Data
+//
+// TODO move into a separate header?
+// ----------------------------------------------------------------------------
+
+class wxClientData
+{
+public:
+    wxClientData() { }
+    virtual ~wxClientData() { }
+};
+
+class wxStringClientData : public wxClientData
+{
+public:
+    wxStringClientData() { }
+    wxStringClientData( const wxString &data ) : m_data(data) { }
+    void SetData( const wxString &data ) { m_data = data; }
+    const wxString& GetData() const { return m_data; }
+
+private:
+    wxString  m_data;
+};
+
+// ----------------------------------------------------------------------------
+// wxWindowBase is the base class for all GUI controls/widgets, this is the public
+// interface of this class.
+//
+// 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 wxWindowBase : public wxEvtHandler
+{
+    DECLARE_ABSTRACT_CLASS(wxWindowBase);
+
+public:
+    // creating the window
+    // -------------------
+
+        // default ctor
+    wxWindowBase() { InitBase(); }
+
+        // pseudo ctor (can't be virtual, called from ctor)
+    bool CreateBase(wxWindowBase *parent,
+                    wxWindowID id,
+                    const wxPoint& pos = wxDefaultPosition,
+                    const wxSize& size = wxDefaultSize,
+                    long style = 0,
+                    const wxString& name = wxPanelNameStr);
+
+    virtual ~wxWindowBase();
+
+#if wxUSE_WX_RESOURCES
+    // these functions are implemented in resource.cpp and resourc2.cpp
+    virtual bool LoadFromResource(wxWindow *parent,
+                                  const wxString& resourceName,
+                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
+    virtual wxControl *CreateItem(const wxItemResource* childResource,
+                                  const wxItemResource* parentResource,
+                                  const wxResourceTable *table = (const wxResourceTable *) NULL);
+#endif // wxUSE_WX_RESOURCES
+
+    // deleting the window
+    // -------------------
+
+        // ask the window to close itself, return TRUE if the event handler
+        // honoured our request
+    bool Close( bool force = FALSE );
+
+        // the following functions delete the C++ objects (the window itself
+        // or its children) as well as the GUI windows and normally should
+        // never be used directly
+
+        // delete window unconditionally (dangerous!), returns TRUE if ok
+    virtual bool Destroy();
+        // delete all children of this window, returns TRUE if ok
+    bool DestroyChildren();
+
+        // is the window being deleted?
+    bool IsBeingDeleted() const { return m_isBeingDeleted; }
+
+    // window attributes
+    // -----------------
+
+        // the title (or label, see below) of the window: the text which the
+        // window shows
+    virtual void SetTitle( const wxString & WXUNUSED(title) ) { }
+    virtual wxString GetTitle() const { return ""; }
+
+        // label is just the same as the title (but for, e.g., buttons it
+        // makes more sense to speak about labels)
+    wxString GetLabel() const { return GetTitle(); }
+
+        // the window name is used for ressource setting in X, it is not the
+        // same as the window title/label
+    virtual void SetName( const wxString &name ) { m_windowName = name; }
+    virtual wxString GetName() const { return m_windowName; }
+
+        // window id uniquely identifies the window among its siblings unless
+        // it is -1 which means "don't care"
+    void SetId( wxWindowID id ) { m_windowId = id; }
+    wxWindowID GetId() const { return m_windowId; }
+
+        // generate a control id for the controls which were not given one by
+        // user
+    static int NewControlId() { return ++ms_lastControlId; }
+
+    // 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); }
+
+        // Z-order
+    virtual void Raise() = 0;
+    virtual void Lower() = 0;
+
+        // 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 (pointers may be NULL)
+    void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
+    wxPoint GetPosition() const
+    {
+        int w, h;
+        DoGetPosition(&w, &h);
+
+        return wxPoint(w, h);
+    }
+
+    void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
+    wxSize GetSize() const
+    {
+        int w, h;
+        DoGetSize(& 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);
+    }
+
+    void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
+    wxSize GetClientSize() const
+    {
+        int w, h;
+        DoGetClientSize(& w, & h);
+
+        return wxSize(w, h);
+    }
+
+        // centre with respect to the the parent window
+    void Centre( int direction = wxHORIZONTAL );
+    void Center( int direction = wxHORIZONTAL ) { Centre(direction); }
+
+        // set window size to wrap around its children
+    virtual void Fit();
+
+        // set min/max size of the window
+    virtual void SetSizeHints( int minW, int minH,
+                               int maxW = -1, int maxH = -1,
+                               int incW = -1, int incH = -1 );
+
+    // window state
+    // ------------
+
+        // returns TRUE if window was shown/hidden, FALSE if the nothing was
+        // done (window was already shown/hidden)
+    virtual bool Show( bool show = TRUE );
+    bool Hide() { return Show(FALSE); }
+
+        // returns TRUE if window was enabled/disabled, FALSE if nothing done
+    virtual bool Enable( bool enable = TRUE );
+    bool Disable() { return Enable(FALSE); }
+
+    bool IsShown() const { return m_isShown; }
+    bool IsEnabled() const { return m_isEnabled; }
+
+        // get/set window style (setting style won't update the window and so
+        // is only useful for internal usage)
+    virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
+    virtual long GetWindowStyleFlag() const { return m_windowStyle; }
+
+        // just some (somewhat shorter) synonims
+    void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
+    long GetWindowStyle() const { return GetWindowStyleFlag(); }
+
+    bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
+
+    virtual bool IsRetained() const
+        { return (m_windowStyle & wxRETAINED) != 0; }
+
+        // make the window modal (all other windows unresponsive)
+    virtual void MakeModal(bool modal = TRUE);
+
+    // focus handling
+    // --------------
+
+        // set focus to this window
+    virtual void SetFocus() = 0;
+
+        // return the window which currently has the focus or NULL
+    static wxWindow *FindFocus() /* = 0: implement in derived classes */;
+
+        // can this window have focus?
+    virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
+
+    // parent/children relations
+    // -------------------------
+
+        // get the list of children
+    const wxWindowList& GetChildren() const { return m_children; }
+    wxWindowList& GetChildren() { return m_children; }
+
+        // get the parent or the parent of the parent
+    wxWindow *GetParent() const { return m_parent; }
+    inline wxWindow *GetGrandParent() const;
+
+        // is this window a top level one?
+    bool IsTopLevel() const { return m_parent != 0; }
+
+        // it doesn't really change parent, use ReParent() instead
+    void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
+        // change the real parent of this window, return TRUE if the parent
+        // was changed, FALSE otherwise (error or newParent == oldParent)
+    virtual bool Reparent( wxWindowBase *newParent );
+
+        // find window among the descendants of this one either by id or by
+        // name (return NULL if not found)
+    wxWindow *FindWindow( long id );
+    wxWindow *FindWindow( const wxString& name );
+
+        // implementation mostly
+    virtual void AddChild( wxWindowBase *child );
+    virtual void RemoveChild( wxWindowBase *child );
+
+    // event handler stuff
+    // -------------------
+
+        // get the current event handler
+    wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
+
+        // replace the event handler (allows to completely subclass the
+        // window)
+    void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; }
+
+        // push/pop event handler: allows to chain a custom event handler to
+        // alreasy existing ones
+    void PushEventHandler( wxEvtHandler *handler );
+    wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
+
+    // validators and client data
+    // --------------------------
+
+        // a window may have an associated validator which is used to control
+        // user input
+    virtual void SetValidator( const wxValidator &validator );
+    virtual wxValidator *GetValidator() { return m_windowValidator; }
+
+        // each window may have associated client data: either a pointer to
+        // wxClientData object in which case it is managed by the window (i.e.
+        // it will delete the data when it's destroyed) or an untyped pointer
+        // which won't be deleted by the window
+    virtual void SetClientObject( wxClientData *data )
+    {
+        if ( m_clientObject )
+            delete m_clientObject;
+
+        m_clientObject = data;
+    }
+    virtual wxClientData *GetClientObject() const { return m_clientObject; }
+
+    virtual void SetClientData( void *data ) { m_clientData = data; }
+    virtual void *GetClientData() const { return m_clientData; }
+
+    // dialog oriented functions
+    // -------------------------
+
+        // validate the correctness of input, return TRUE if ok
+    virtual bool Validate();
+
+        // transfer data between internal and GUI representations
+    virtual bool TransferDataToWindow();
+    virtual bool TransferDataFromWindow();
+
+    virtual void InitDialog();
+
+    // accelerators
+    // ------------
+    virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
+        { m_acceleratorTable = accel; }
+    wxAcceleratorTable *GetAcceleratorTable()
+        { return &m_acceleratorTable; }
+
+    // dialog units translations
+    // -------------------------
+
+    wxPoint ConvertPixelsToDialog( const wxPoint& pt );
+    wxPoint ConvertDialogToPixels( const wxPoint& pt );
+    wxSize ConvertPixelsToDialog( const wxSize& sz )
+    {
+        wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
+
+        return wxSize(pt.x, pt.y);
+    }
+
+    wxSize ConvertDialogToPixels( const wxSize& sz )
+    {
+        wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
+
+        return wxSize(pt.x, pt.y);
+    }
+
+    // mouse functions
+    // ---------------
+
+        // move the mouse to the specified position
+    virtual void WarpPointer(int x, int y) = 0;
+
+        // start or end mouse capture
+    virtual void CaptureMouse() = 0;
+    virtual void ReleaseMouse() = 0;
+
+    // painting the window
+    // -------------------
+
+        // mark the specified rectangle (or the whole window) as "dirty" so it
+        // will be repainted
+    virtual void Refresh( bool eraseBackground = TRUE,
+                          const wxRect *rect = (const wxRect *) NULL ) = 0;
+        // clear the window entirely
+    virtual void Clear() = 0;
+
+        // adjust DC for drawing on this window
+    virtual void PrepareDC( wxDC &dc ) { }
+
+        // the update region of the window contains the areas which must be
+        // repainted by the program
+    const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
+    wxRegion& GetUpdateRegion() { return m_updateRegion; }
+
+        // these functions verify whether the given point/rectangle belongs to
+        // (or at least intersects with) the update region
+    bool IsExposed( int x, int y ) const;
+    bool IsExposed( int x, int y, int w, int h ) const;
+
+    bool IsExposed( const wxPoint& pt ) const
+        { return IsExposed(pt.x, pt.y); }
+    bool IsExposed( const wxRect& rect ) const
+        { return IsExposed(rect.x, rect.y, rect.width, rect.height); }
+
+    // colours, fonts and cursors
+    // --------------------------
+
+        // set/retrieve the window colours (system defaults are used by
+        // default): Set functions return TRUE if colour was changed
+    virtual bool SetBackgroundColour( const wxColour &colour );
+    virtual bool SetForegroundColour( const wxColour &colour );
+
+    wxColour GetBackgroundColour() const { return m_backgroundColour; }
+    wxColour GetForegroundColour() const { return m_foregroundColour; }
+
+        // set/retrieve the cursor for this window (SetCursor() returns TRUE
+        // if the cursor was really changed)
+    virtual bool SetCursor( const wxCursor &cursor );
+    const wxCursor& GetCursor() const { return m_cursor; }
+    wxCursor& GetCursor() { return m_cursor; }
+
+        // set/retrieve the font for the window (SetFont() returns TRUE if the
+        // font really changed)
+    virtual bool SetFont( const wxFont &font ) = 0;
+    const wxFont& GetFont() const { return m_font; }
+    wxFont& GetFont() { return m_font; }
+
+        // get the (average) character size for the current font
+    virtual int GetCharHeight() const = 0;
+    virtual int GetCharWidth() const = 0;
+
+        // get the width/height/... of the text using current or specified
+        // font
+    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 = 0;
+
+        // translate to/from screen/client coordinates (pointers may be NULL)
+    virtual void ClientToScreen( int *x, int *y ) const = 0;
+    virtual void ScreenToClient( int *x, int *y ) const = 0;
+
+    // misc
+    // ----
+
+    void UpdateWindowUI();
+
+    virtual bool PopupMenu( wxMenu *menu, int x, int y ) = 0;
+
+    // scrollbars
+    // ----------
+
+        // configure the window scrollbars
+    virtual void SetScrollbar( int orient,
+                               int pos,
+                               int thumbVisible,
+                               int range,
+                               bool refresh = TRUE ) = 0;
+    virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ) = 0;
+    virtual int GetScrollPos( int orient ) const = 0;
+    virtual int GetScrollThumb( int orient ) const = 0;
+    virtual int GetScrollRange( int orient ) const = 0;
+
+        // scroll window to the specified position
+    virtual void ScrollWindow( int dx, int dy,
+                               const wxRect* rect = (wxRect *) NULL ) = 0;
+
+    // tooltips
+    // --------
+#if wxUSE_TOOLTIPS
+        // the easiest way to set a tooltip for a window is to use this method
+    void SetToolTip( const wxString &tip );
+        // attach a tooltip to the window
+    void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
+        // get the associated tooltip or NULL if none
+    wxToolTip* GetToolTip() const { return m_tooltip; }
+#endif // wxUSE_TOOLTIPS
+
+    // drag and drop
+    // -------------
+#if wxUSE_DRAG_AND_DROP
+        // set/retrieve the drop target associated with this window (may be
+        // NULL; it's owned by the window and will be deleted by it)
+    virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
+    virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
+#endif // wxUSE_DRAG_AND_DROP
+
+    // constraints and sizers
+    // ----------------------
+#if wxUSE_CONSTRAINTS
+        // set the constraints for this window or retrieve them (may be NULL)
+    void SetConstraints( wxLayoutConstraints *constraints );
+    wxLayoutConstraints *GetConstraints() const { return m_constraints; }
+
+        // when using constraints, it makes sense to update children positions
+        // automatically whenever the window is resized - this is done if
+        // autoLayout is on
+    void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
+    bool GetAutoLayout() const { return m_autoLayout; }
+
+        // do layout the window and its children
+    virtual bool Layout();
+
+        // implementation only
+    void UnsetConstraints(wxLayoutConstraints *c);
+    wxWindowList *GetConstraintsInvolvedIn() const
+        { return m_constraintsInvolvedIn; }
+    void AddConstraintReference(wxWindowBase *otherWin);
+    void RemoveConstraintReference(wxWindowBase *otherWin);
+    void DeleteRelatedConstraints();
+    void ResetConstraints();
+
+        // these methods may be overriden for special layout algorithms
+    virtual void SetConstraintSizes(bool recurse = TRUE);
+    virtual bool LayoutPhase1(int *noChanges);
+    virtual bool LayoutPhase2(int *noChanges);
+    virtual bool DoPhase(int);
+
+        // these methods are virtual but normally won't be overridden
+    virtual void TransformSizerToActual(int *x, int *y) const ;
+    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 ;
+
+        // sizers
+        // TODO: what are they and how do they work??
+    void SetSizer( wxSizer *sizer );
+    wxSizer *GetSizer() const { return m_windowSizer; }
+
+    void SetSizerParent( wxWindowBase *win ) { m_sizerParent = win; }
+    wxWindowBase *GetSizerParent() const { return m_sizerParent; }
+
+    virtual void SizerSetSize(int x, int y, int w, int h);
+    virtual void SizerMove(int x, int y);
+#endif // wxUSE_CONSTRAINTS
+
+    // backward compatibility
+    // ----------------------
+#if WXWIN_COMPATIBILITY
+    bool Enabled() const { return IsEnabled(); }
+
+    void SetButtonFont(const wxFont& font) { SetFont(font); }
+    void SetLabelFont(const wxFont& font) { SetFont(font); }
+    wxFont& GetLabelFont() { return GetFont(); };
+    wxFont& GetButtonFont() { return GetFont(); };
+#endif // WXWIN_COMPATIBILITY
+
+    // implementation
+    // --------------
+
+        // event handlers
+    void OnSysColourChanged( wxSysColourChangedEvent& event );
+    void OnInitDialog( wxInitDialogEvent &event );
+
+        // accessors
+    WXWidget GetHandle() const { return m_widget; }
+
+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
+    WXWidget             m_widget;
+    wxWindowID           m_windowId;
+
+    // the parent window of this window (or NULL) and the list of the children
+    // of this window
+    wxWindow            *m_parent;
+    wxWindowList         m_children;
+
+    // the minimal allowed size for the window (no minimal size if variable(s)
+    // contain(s) -1)
+    int                  m_minWidth, m_minHeight, m_maxWidth, m_maxHeight;
+
+    // event handler for this window: usually is just 'this' but may be
+    // changed with SetEventHandler()
+    wxEvtHandler        *m_eventHandler;
+
+    // associated validator or NULL if none
+    wxValidator         *m_windowValidator;
+
+#if wxUSE_DRAG_AND_DROP
+    wxDropTarget        *m_dropTarget;
+#endif // wxUSE_DRAG_AND_DROP
+
+    // visual window attributes
+    wxCursor             m_cursor;
+    wxFont               m_font;
+    wxColour             m_backgroundColour, m_foregroundColour;
+
+    // the region which should be repainted in response to paint event
+    wxRegion             m_updateRegion;
+
+    // the accelerator table for the window which translates key strokes into
+    // command events
+    wxAcceleratorTable   m_acceleratorTable;
+
+    // user data associated with the window: either an object which will be
+    // deleted by the window when it's deleted or some raw pointer which we do
+    // nothing with
+    wxClientData        *m_clientObject;
+    void                *m_clientData;
+
+    // the tooltip for this window (may be NULL)
+#if wxUSE_TOOLTIPS
+    wxToolTip           *m_tooltip;
+#endif // wxUSE_TOOLTIPS
+
+    // constraints and sizers
+#if wxUSE_CONSTRAINTS
+    // the constraints for this window or NULL
+    wxLayoutConstraints *m_constraints;
+
+    // constraints this window is involved in
+    wxWindowList        *m_constraintsInvolvedIn;
+
+    // top level and the parent sizers
+    // TODO what's this and how does it work?)
+    wxSizer             *m_windowSizer;
+    wxWindowBase        *m_sizerParent;
+
+    // Layout() window automatically when its size changes?
+    bool                 m_autoLayout:1;
+#endif // wxUSE_CONSTRAINTS
+
+    // window state
+    bool                 m_isShown:1;
+    bool                 m_isEnabled:1;
+    bool                 m_isBeingDeleted:1;
+
+    // window attributes
+    long                 m_windowStyle;
+    wxString             m_windowName;
+
+protected:
+    // common part of all ctors: it is not virtual because it is called from
+    // ctor
+    void InitBase();
+
+    // get the default size for the new window if no explicit size given
+    // FIXME why 20 and not 30, 10 or ...?
+    static int WidthDefault(int w) { return w == -1 ? 20 : w; }
+    static int HeightDefault(int h) { return h == -1 ? 20 : h; }
+
+    // more pure virtual functions
+    // ---------------------------
+
+    // NB: we must have DoSomething() function when Something() is an overloaded
+    //     method: indeed, we can't just have "virtual Something()" in case when
+    //     the function is overloaded because then we'd have to make virtual all
+    //     the variants (otherwise only the virtual function may be called on a
+    //     pointer to derived class according to C++ rules) which is, in
+    //     general, absolutely not needed. So instead we implement all
+    //     overloaded Something()s in terms of DoSomething() which will be the
+    //     only one to be virtual.
+
+    // retrieve the position/size of the window
+    virtual void DoGetPosition( int *x, int *y ) const = 0;
+    virtual void DoGetSize( int *width, int *height ) const = 0;
+    virtual void DoGetClientSize( int *width, int *height ) const = 0;
+
+    // this is the virtual function to be overriden in any derived class which
+    // wants to change how SetSize() or Move() works - it is called by all
+    // versions of these functions in the base class
+    virtual void DoSetSize(int x, int y,
+                           int width, int height,
+                           int sizeFlags = wxSIZE_AUTO) = 0;
+
+    // same as DoSetSize() for the client size
+    virtual void DoSetClientSize(int width, int height) = 0;
+
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip( wxToolTip *tip );
+#endif // wxUSE_TOOLTIPS
+
+private:
+    // contains the last id generated by NewControlId
+    static int ms_lastControlId;
+
+    DECLARE_EVENT_TABLE()
+};
+
+// ----------------------------------------------------------------------------
+// now include the declaration of wxWindow class
+// ----------------------------------------------------------------------------
+
 #if defined(__WXMSW__)
     #include "wx/msw/window.h"
 #elif defined(__WXMOTIF__)
@@ -11,9 +736,23 @@
     #include "wx/qt/window.h"
 #elif defined(__WXMAC__)
     #include "wx/mac/window.h"
-#elif defined(__WXSTUBS__)
-#include "wx/stubs/window.h"
 #endif
 
+// ----------------------------------------------------------------------------
+// inline functions which couldn't be declared in the class body because of
+// forward dependencies
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::GetGrandParent() const
+{
+    return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
+}
+
+// ----------------------------------------------------------------------------
+// global function
+// ----------------------------------------------------------------------------
+
+extern wxWindow* WXDLLEXPORT wxGetActiveWindow();
+
 #endif
     // _WX_WINDOW_H_BASE_

src/common/layout.cpp

@@ -9,6 +9,13 @@
 // Licence:       wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// =============================================================================
+// declarations
+// =============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
 #ifdef __GNUG__
     #pragma implementation "layout.h"
 #endif
@@ -27,7 +34,7 @@
     #include "wx/utils.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
-#include <wx/intl.h>
+    #include "wx/intl.h"
 #endif
 
 #include "wx/layout.h"
@@ -64,7 +71,7 @@ TODO:
 */
 
 // Find margin sizes if a sizer, or zero otherwise
-int wxSizerMarginX(wxWindow *win)
+int wxSizerMarginX(wxWindowBase *win)
 {
     if ( win->IsKindOf(CLASSINFO(wxSizer)) )
     {
@@ -75,7 +82,7 @@ int wxSizerMarginX(wxWindow *win)
         return 0;
 }
 
-int wxSizerMarginY(wxWindow *win)
+int wxSizerMarginY(wxWindowBase *win)
 {
     if ( win->IsKindOf(CLASSINFO(wxSizer)) )
     {
@@ -89,40 +96,65 @@ int wxSizerMarginY(wxWindow *win)
 
 wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
 {
-  myEdge = wxTop; relationship = wxUnconstrained; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
+    myEdge = wxTop;
-  done = FALSE; otherWin = (wxWindow *) NULL;
+    relationship = wxUnconstrained;
+    margin = 0;
+    value = 0;
+    percent = 0;
+    otherEdge = wxTop;
+    done = FALSE;
+    otherWin = (wxWindowBase *) NULL;
 }
 
 wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
 {
 }
 
-void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val, int marg)
+void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
 {
-  relationship = rel; otherWin = otherW; otherEdge = otherE; value = val; margin = marg;
+  relationship = rel;
+  otherWin = otherW;
+  otherEdge = otherE;
+  value = val;
+  margin = marg;
 }
 
-void wxIndividualLayoutConstraint::LeftOf(wxWindow *sibling, int marg)
+void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
-{ Set(wxLeftOf, sibling, wxLeft, 0, marg); }
+{
+    Set(wxLeftOf, sibling, wxLeft, 0, marg);
+}
 
-void wxIndividualLayoutConstraint::RightOf(wxWindow *sibling, int marg)
+void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
-{ Set(wxRightOf, sibling, wxRight, 0, marg); }
+{
+    Set(wxRightOf, sibling, wxRight, 0, marg);
+}
 
-void wxIndividualLayoutConstraint::Above(wxWindow *sibling, int marg)
+void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
-{ Set(wxAbove, sibling, wxTop, 0, marg); }
+{
+    Set(wxAbove, sibling, wxTop, 0, marg);
+}
 
-void wxIndividualLayoutConstraint::Below(wxWindow *sibling, int marg)
+void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
-{ Set(wxBelow, sibling, wxBottom, 0, marg); }
+{
+    Set(wxBelow, sibling, wxBottom, 0, marg);
+}
 
 //
 // 'Same edge' alignment
 //
-void wxIndividualLayoutConstraint::SameAs(wxWindow *otherW, wxEdge edge, int marg)
+void wxIndividualLayoutConstraint::SameAs(wxWindowBase *otherW, wxEdge edge, int marg)
-{ Set(wxPercentOf, otherW, edge, 0, marg); percent = 100; }
+{ 
+    Set(wxPercentOf, otherW, edge, 0, marg);
+    percent = 100;
+}
 
 // The edge is a percentage of the other window's edge
-void wxIndividualLayoutConstraint::PercentOf(wxWindow *otherW, wxEdge wh, int per)
+void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
-{ otherWin = otherW; relationship = wxPercentOf; percent = per;
+{ 
+    otherWin = otherW;
+    relationship = wxPercentOf;
+    percent = per;
+
     otherEdge = wh;
 }
 
@@ -130,15 +162,22 @@ void wxIndividualLayoutConstraint::PercentOf(wxWindow *otherW, wxEdge wh, int pe
 // Edge has absolute value
 //
 void wxIndividualLayoutConstraint::Absolute(int val)
-{ value = val; relationship = wxAbsolute; }
+{
+    value = val; relationship = wxAbsolute;
+}
 
 // Reset constraint if it mentions otherWin
-bool wxIndividualLayoutConstraint::ResetIfWin(wxWindow *otherW)
+bool wxIndividualLayoutConstraint::ResetIfWin(wxWindowBase *otherW)
 {
     if (otherW == otherWin)
     {
-    myEdge = wxTop; relationship = wxAsIs; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
+        myEdge = wxTop;
-    otherWin = (wxWindow *) NULL;
+        relationship = wxAsIs;
+        margin = 0;
+        value = 0;
+        percent = 0;
+        otherEdge = wxTop;
+        otherWin = (wxWindowBase *) NULL;
         return TRUE;
     }
     else
@@ -146,7 +185,7 @@ bool wxIndividualLayoutConstraint::ResetIfWin(wxWindow *otherW)
 }
 
 // Try to satisfy constraint
-bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindow *win)
+bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win)
 {
     if (relationship == wxAbsolute)
     {
@@ -162,9 +201,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
             {
                 case wxLeftOf:
                 {
-          // We can know this edge if: otherWin is win's parent,
+                    // We can know this edge if: otherWin is win's
-          // or otherWin has a satisfied constraint, or
+                    // parent, or otherWin has a satisfied constraint,
-          // otherWin has no constraint.
+                    // or otherWin has no constraint.
                     int edgePos = GetEdge(otherEdge, win, otherWin);
                     if (edgePos != -1)
                     {
@@ -202,7 +241,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
                 case wxUnconstrained:
                 {
                     // We know the left-hand edge position if we know
-          // the right-hand edge and we know the width; OR if we know the centre and the width.
+                    // the right-hand edge and we know the width; OR if
+                    // we know the centre and the width.
                     if (constraints->right.GetDone() && constraints->width.GetDone())
                     {
                         value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
@@ -236,9 +276,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
             {
                 case wxLeftOf:
                 {
-          // We can know this edge if: otherWin is win's parent,
+                    // We can know this edge if: otherWin is win's
-          // or otherWin has a satisfied constraint, or
+                    // parent, or otherWin has a satisfied constraint,
-          // otherWin has no constraint.
+                    // or otherWin has no constraint.
                     int edgePos = GetEdge(otherEdge, win, otherWin);
                     if (edgePos != -1)
                     {
@@ -275,8 +315,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
                 }
                 case wxUnconstrained:
                 {
-          // We know the right-hand edge position if we know
+                    // We know the right-hand edge position if we know the
-          // the left-hand edge and we know the width, OR if we know the
+                    // left-hand edge and we know the width, OR if we know the
                     // centre edge and the width.
                     if (constraints->left.GetDone() && constraints->width.GetDone())
                     {
@@ -314,9 +354,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
             {
                 case wxAbove:
                 {
-          // We can know this edge if: otherWin is win's parent,
+                    // We can know this edge if: otherWin is win's
-          // or otherWin has a satisfied constraint, or
+                    // parent, or otherWin has a satisfied constraint,
-          // otherWin has no constraint.
+                    // or otherWin has no constraint.
                     int edgePos = GetEdge(otherEdge, win, otherWin);
                     if (edgePos != -1)
                     {
@@ -353,9 +393,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
                 }
                 case wxUnconstrained:
                 {
-          // We know the top edge position if we know
+                    // We know the top edge position if we know the bottom edge
-          // the bottom edge and we know the height; OR if we know the centre
+                    // and we know the height; OR if we know the centre edge and
-          // edge and the height.
+                    // the height.
                     if (constraints->bottom.GetDone() && constraints->height.GetDone())
                     {
                         value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
@@ -428,9 +468,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
                 }
                 case wxUnconstrained:
                 {
-          // We know the bottom edge position if we know
+                    // We know the bottom edge position if we know the top edge
-          // the top edge and we know the height; OR if we know the
+                    // and we know the height; OR if we know the centre edge and
-          // centre edge and the height.
+                    // the height.
                     if (constraints->top.GetDone() && constraints->height.GetDone())
                     {
                         value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
@@ -467,9 +507,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
             {
                 case wxLeftOf:
                 {
-          // We can know this edge if: otherWin is win's parent,
+                    // We can know this edge if: otherWin is win's parent, or
-          // or otherWin has a satisfied constraint, or
+                    // otherWin has a satisfied constraint, or otherWin has no
-          // otherWin has no constraint.
+                    // constraint.
                     int edgePos = GetEdge(otherEdge, win, otherWin);
                     if (edgePos != -1)
                     {
@@ -536,8 +576,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
                 case wxAbove:
                 {
                     // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
+                    // or otherWin has a satisfied constraint, or otherWin
-          // otherWin has no constraint.
+                    // has no constraint.
                     int edgePos = GetEdge(otherEdge, win, otherWin);
                     if (edgePos != -1)
                     {
@@ -719,17 +759,15 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
     return FALSE;
 }
 
-// Get the value of this edge or dimension, or if this
+// Get the value of this edge or dimension, or if this is not determinable, -1.
-// is not determinable, -1.
 int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
-                                          wxWindow *thisWin,
+                                          wxWindowBase *thisWin,
-                                          wxWindow *other) const
+                                          wxWindowBase *other) const
 {
-  // If the edge or dimension belongs to the parent, then we
+    // If the edge or dimension belongs to the parent, then we know the
-  // know the dimension is obtainable immediately.
+    // dimension is obtainable immediately. E.g. a wxExpandSizer may contain a
-  // E.g. a wxExpandSizer may contain a button (but the button's
+    // button (but the button's true parent is a panel, not the sizer)
-  // true parent is a panel, not the sizer)
+    if (other->GetChildren().Find(thisWin))
-  if (other->GetChildren().Member(thisWin))
     {
         switch (which)
         {
@@ -959,7 +997,7 @@ wxLayoutConstraints::~wxLayoutConstraints()
 {
 }
 
-bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
+bool wxLayoutConstraints::SatisfyConstraints(wxWindowBase *win, int *nChanges)
 {
     int noChanges = 0;
 
@@ -1042,7 +1080,8 @@ bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
 
  */
  
-bool wxOldDoLayout(wxWindow *win)
+#if WXWIN_COMPATIBILITY
+bool wxOldDoLayout(wxWindowBase *win)
 {
   // Make sure this isn't called recursively from below
   static wxList doneSoFar;
@@ -1055,7 +1094,7 @@ bool wxOldDoLayout(wxWindow *win)
   wxNode *node = win->GetChildren().First();
   while (node)
   {
-    wxWindow *child = (wxWindow *)node->Data();
+    wxWindowBase *child = (wxWindowBase *)node->Data();
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr)
     {
@@ -1080,7 +1119,7 @@ bool wxOldDoLayout(wxWindow *win)
     wxNode *node = win->GetChildren().First();
     while (node)
     {
-      wxWindow *child = (wxWindow *)node->Data();
+      wxWindowBase *child = (wxWindowBase *)node->Data();
       wxLayoutConstraints *constr = child->GetConstraints();
       if (constr)
       {
@@ -1097,7 +1136,7 @@ bool wxOldDoLayout(wxWindow *win)
   // failed, so we can print a specific diagnostic message.
   if (noFailures > 0)
   {
-    wxDebugMsg(_("wxWindow::Layout() failed.\n"));
+    wxDebugMsg(_("wxWindowBase::Layout() failed.\n"));
   }
 */
   // Now set the sizes and positions of the children, and
@@ -1105,7 +1144,7 @@ bool wxOldDoLayout(wxWindow *win)
   node = win->GetChildren().First();
   while (node)
   {
-    wxWindow *child = (wxWindow *)node->Data();
+    wxWindowBase *child = (wxWindowBase *)node->Data();
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr && constr->left.GetDone() && constr->right.GetDone() &&
                   constr->width.GetDone() && constr->height.GetDone())
@@ -1135,6 +1174,7 @@ bool wxOldDoLayout(wxWindow *win)
 
   return TRUE;
 }
+#endif // WXWIN_COMPATIBILITY
 
 wxSizer::wxSizer()
 {
@@ -1147,12 +1187,12 @@ wxSizer::wxSizer()
     sizerHeight = 0;
 }
 
-wxSizer::wxSizer(wxWindow *parent, wxSizerBehaviour behav)
+wxSizer::wxSizer(wxWindowBase *parent, wxSizerBehaviour behav)
 {
     Create(parent, behav);
 }
 
-bool wxSizer::Create(wxWindow *parent, wxSizerBehaviour behav)
+bool wxSizer::Create(wxWindowBase *parent, wxSizerBehaviour behav)
 {
     sizerBehaviour = behav;
     borderX = 2;
@@ -1205,11 +1245,11 @@ wxSizer::~wxSizer()
     while (node)
     {
         wxNode *next = node->Next();
-    wxWindow *win = (wxWindow *)node->Data();
+        wxWindowBase *win = (wxWindowBase *)node->Data();
         if (!win->IsKindOf(CLASSINFO(wxSizer)))
         {
             delete node;
-  		win->SetSizerParent((wxWindow *) NULL);
+            win->SetSizerParent((wxWindowBase *) NULL);
         }
         else
         {
@@ -1222,7 +1262,7 @@ wxSizer::~wxSizer()
     if (m_sizerParent) // && !m_sizerParent->IsKindOf(CLASSINFO(wxSizer)))
     {
         m_sizerParent->SetSizer((wxSizer *) NULL);
-	m_sizerParent = (wxWindow *) NULL;
+        m_sizerParent = (wxWindowBase *) NULL;
     }
 
 }
@@ -1244,7 +1284,7 @@ void wxSizer::SetBorder(int x, int y)
 
 }
 
-void wxSizer::AddSizerChild(wxWindow *child)
+void wxSizer::AddSizerChild(wxWindowBase *child)
 {
     child->SetSizerParent(this);
     GetChildren().Append(child);
@@ -1268,7 +1308,7 @@ void wxSizer::AddSizerChild(wxWindow *child)
     }
 }
 
-void wxSizer::RemoveSizerChild(wxWindow *child)
+void wxSizer::RemoveSizerChild(wxWindowBase *child)
 {
     GetChildren().DeleteObject(child);
 }
@@ -1368,7 +1408,7 @@ bool wxSizer::LayoutPhase1(int *noChanges)
                 while (node)
                 {
                     int x, y, width, height;
-        wxWindow *win = (wxWindow *)node->Data();
+                    wxWindowBase *win = (wxWindowBase *)node->Data();
                     win->GetSizeConstraint(&width, &height);
                     win->GetPositionConstraint(&x, &y);
                     if ((x+width) > maxX)
@@ -1481,12 +1521,12 @@ wxRowColSizer::wxRowColSizer()
     ySpacing = 2;
 }
 
-wxRowColSizer::wxRowColSizer(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
+wxRowColSizer::wxRowColSizer(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
 {
     Create(parent, rc, n, behav);
 }
 
-bool wxRowColSizer::Create(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
+bool wxRowColSizer::Create(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
 {
     wxSizer::Create(parent, behav);
 
@@ -1561,7 +1601,7 @@ bool wxRowColSizer::LayoutPhase1(int *noChanges)
         wxNode *node = GetChildren().First();
         while (node)
         {
-      wxWindow *win = (wxWindow *)node->Data();
+            wxWindowBase *win = (wxWindowBase *)node->Data();
             int childWidth, childHeight;
             if (win->GetConstraints() &&
                     win->GetConstraints()->width.GetDone() &&
@@ -1661,23 +1701,23 @@ wxSpacingSizer::wxSpacingSizer()
 {
 }
 
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent)
+wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent)
 {
     Create(parent);
 }
 
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
+wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
 {
     Create(parent, rel, other, spacing);
 }
 
-bool wxSpacingSizer::Create(wxWindow *parent)
+bool wxSpacingSizer::Create(wxWindowBase *parent)
 {
     wxSizer::Create(parent);
     return TRUE;
 }
 
-bool wxSpacingSizer::Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
+bool wxSpacingSizer::Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
 {
     wxLayoutConstraints *c = new wxLayoutConstraints;
 

src/common/list.cpp

@@ -37,13 +37,6 @@
     #include "wx/utils.h"   // for copystring() (beurk...)
 #endif
 
-// -----------------------------------------------------------------------------
-// implementation of standard lists
-// -----------------------------------------------------------------------------
-
-#include "wx/listimpl.cpp"
-WX_DEFINE_LIST(wxWindowList);
-
 // =============================================================================
 // implementation
 // =============================================================================

src/common/resource.cpp

@@ -2846,7 +2846,7 @@ bool wxResourceParseString(char *s, wxResourceTable *table)
  * resource loading facility
  */
 
-bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
+bool wxWindowBase::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
 {
   if (!table)
     table = wxDefaultResourceTable;
@@ -2885,7 +2885,7 @@ bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName,
   }
   else
   {
-    if (!this->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
+    if (!((wxWindow *)this)->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
       return FALSE;
   }
 
@@ -2932,7 +2932,7 @@ bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName,
   return TRUE;
 }
 
-wxControl *wxWindow::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
+wxControl *wxWindowBase::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
 {
   if (!table)
     table = wxDefaultResourceTable;

src/common/tbarbase.cpp

@@ -398,7 +398,7 @@ void wxToolBarBase::Command(wxCommandEvent& WXUNUSED(event))
 {
 }
 
-void wxToolBarBase::Layout()
+void wxToolBarBase::LayoutTools()
 {
 }
 

src/common/tbarsmpl.cpp

@@ -364,7 +364,7 @@ void wxToolBarSimple::SpringUpButton(int index)
   }
 }
 
-void wxToolBarSimple::Layout(void)
+void wxToolBarSimple::LayoutTools(void)
 {
   m_currentRowsOrColumns = 0;
   m_lastX = m_xMargin;

src/common/utilscmn.cpp

@@ -459,7 +459,7 @@ wxFindWindowByLabel1 (const wxString& title, wxWindow * parent)
 
     if (parent)
     {
-        for ( wxNode * node = parent->GetChildren().GetFirst();
+        for ( wxWindowList::Node * node = parent->GetChildren().GetFirst();
               node;
               node = node->GetNext() )
         {

src/common/valtext.cpp

@@ -129,7 +129,7 @@ bool wxTextValidator::Validate(wxWindow *parent)
     wxTextCtrl *control = (wxTextCtrl *) m_validatorWindow ;
 
     // If window is disabled, simply return
-    if ( !control->Enabled() )
+    if ( !control->IsEnabled() )
         return TRUE;
 
     wxString val(control->GetValue());

src/generic/listctrl.cpp

@@ -2330,7 +2330,7 @@ bool wxListCtrl::Create( wxWindow *parent, wxWindowID id,
 
     m_mainWin = new wxListMainWindow( this, -1, wxPoint(0,0), size, s );
 
-    if (GetWindowStyleFlag() & wxLC_REPORT)
+    if (HasFlag(wxLC_REPORT))
         m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin, wxPoint(0,0), wxSize(size.x,23), wxTAB_TRAVERSAL );
     else
         m_headerWin = (wxListHeaderWindow *) NULL;
@@ -2349,7 +2349,7 @@ void wxListCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
 
 void wxListCtrl::SetSingleStyle( long style, bool add )
 {
-    long flag = GetWindowStyleFlag();
+    long flag = GetWindowStyle();
 
     if (add)
     {
@@ -2382,7 +2382,7 @@ void wxListCtrl::SetWindowStyleFlag( long flag )
 
     if (flag & wxLC_REPORT)
     {
-        if (!(GetWindowStyleFlag() & wxLC_REPORT))
+        if (!HasFlag(wxLC_REPORT))
         {
 //          m_mainWin->SetSize( 0, 24, width, height-24 );
             if (!m_headerWin)
@@ -2398,7 +2398,7 @@ void wxListCtrl::SetWindowStyleFlag( long flag )
     }
     else
     {
-        if (GetWindowStyleFlag() & wxLC_REPORT)
+        if (HasFlag(wxLC_REPORT))
         {
 //          m_mainWin->SetSize( 0, 0, width, height );
             m_headerWin->Show( FALSE );
@@ -2769,7 +2769,7 @@ void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
     int w = 0;
     int h = 0;
 
-    if (GetWindowStyleFlag() & wxLC_REPORT)
+    if (HasFlag(wxLC_REPORT))
     {
         m_headerWin->GetPosition( &x, &y );
         m_headerWin->GetSize( &w, &h );
@@ -2795,9 +2795,10 @@ void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
     m_mainWin->Refresh();
 }
 
-void wxListCtrl::SetBackgroundColour( const wxColour &colour )
+bool wxListCtrl::SetBackgroundColour( const wxColour &colour )
 {
-    wxWindow::SetBackgroundColour( colour );
+    if ( !wxWindow::SetBackgroundColour( colour ) )
+        return FALSE;
 
     if (m_mainWin)
     {
@@ -2809,11 +2810,14 @@ void wxListCtrl::SetBackgroundColour( const wxColour &colour )
     {
         m_headerWin->SetBackgroundColour( colour );
     }
+
+    return TRUE;
 }
 
-void wxListCtrl::SetForegroundColour( const wxColour &colour )
+bool wxListCtrl::SetForegroundColour( const wxColour &colour )
 {
-    wxWindow::SetForegroundColour( colour );
+    if ( !wxWindow::SetForegroundColour( colour ) )
+        return FALSE;
     
     if (m_mainWin)
     {
@@ -2825,11 +2829,14 @@ void wxListCtrl::SetForegroundColour( const wxColour &colour )
     {
         m_headerWin->SetForegroundColour( colour );
     }
+
+    return TRUE;
 }
 
-void wxListCtrl::SetFont( const wxFont &font )
+bool wxListCtrl::SetFont( const wxFont &font )
 {
-    wxWindow::SetFont( font );
+    if ( !wxWindow::SetFont( font ) )
+        return FALSE;
     
     if (m_mainWin)
     {
@@ -2841,5 +2848,7 @@ void wxListCtrl::SetFont( const wxFont &font )
     {
         m_headerWin->SetFont( font );
     }
+
+    return TRUE;
 }
 

src/generic/panelg.cpp

@@ -109,24 +109,24 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
         return;
     }
 
-    wxNode *start_node = GetChildren().Find( winFocus );
+    wxWindowList::Node *start_node = GetChildren().Find( winFocus );
     if (!start_node)
-        start_node = GetChildren().First();
+        start_node = GetChildren().GetFirst();
 
-    wxNode *node = event.GetDirection() ? start_node->Next()
+    wxWindowList::Node *node = event.GetDirection() ? start_node->GetNext()
-                                        : start_node->Previous();
+                                                    : start_node->GetPrevious();
 
     while (node != start_node)
     {
         if (!node)
         {
-            node = event.GetDirection() ? GetChildren().First()
+            node = event.GetDirection() ? GetChildren().GetFirst()
-                                        : GetChildren().Last();
+                                        : GetChildren().GetLast();
 
             continue;
         }
 
-        wxWindow *child = (wxWindow *)node->Data();
+        wxWindow *child = node->GetData();
 
         if (child->AcceptsFocus())
         {
@@ -135,7 +135,7 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
             return;
         }
 
-        node = event.GetDirection() ? node->Next() : node->Previous();
+        node = event.GetDirection() ? node->GetNext() : node->GetPrevious();
     }
 
     // we cycled through all of our children and none of them wanted to accept

src/generic/tabg.cpp

@@ -623,7 +623,7 @@ bool wxTabView::RemoveTab(int id)
         m_noTabs --;
 
         // The layout has changed
-        Layout();
+        LayoutTabs();
         return TRUE;
       }
       tabNode = tabNode->Next();
@@ -703,7 +703,7 @@ void wxTabView::ClearTabs(bool deleteTabs)
 
 
 // Layout tabs (optional, e.g. if resizing window)
-void wxTabView::Layout(void)
+void wxTabView::LayoutTabs(void)
 {
   // Make a list of the tab controls, deleting the wxTabLayers.
   wxList controls;

src/gtk/app.cpp

@@ -45,7 +45,6 @@
 wxApp *wxTheApp = (wxApp *)  NULL;
 wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
 
-extern wxList wxPendingDelete;
 #if wxUSE_THREADS
 extern wxList *wxPendingEvents;
 extern wxCriticalSection *wxPendingEventsLocker;
@@ -287,11 +286,12 @@ bool wxApp::OnInitGui()
                 int gg = (g << 3) | (g >> 2);
                 int bb = (b << 3) | (b >> 2);
 
+                int index = -1;
+
                 GdkColor *colors = cmap->colors;
                 if(colors)
                 {
                     int max = 3 * 65536;
-                	int index = -1;
 
                     for (int i = 0; i < cmap->size; i++)
                     {
@@ -299,9 +299,13 @@ bool wxApp::OnInitGui()
                         int gdiff = ((gg << 8) - colors[i].green);
                         int bdiff = ((bb << 8) - colors[i].blue);
                         int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
-                    if (sum < max) { index = i; max = sum; }
+                        if (sum < max)
+                        { 
+                            index = i; max = sum;
                         }
                     }
+                }
+
                 m_colorCube[ (r*1024) + (g*32) + b ] = index;
             }
         }
@@ -448,7 +452,7 @@ void wxApp::DeletePendingObjects()
 
         delete obj;
 
-        if (wxPendingDelete.Member(obj))
+        if (wxPendingDelete.Find(obj))
             delete node;
 
         node = wxPendingDelete.First();

src/gtk/bmpbuttn.cpp

@@ -166,7 +166,7 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
  
     m_parent->AddChild( this );
 
-    (m_parent->m_insertCallback)( m_parent, this );
+    m_parent->InsertChild( this );
   
     PostCreation();
   
@@ -278,11 +278,14 @@ void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
     SetBitmap();
 }
 
-void wxBitmapButton::Enable( const bool enable )
+bool wxBitmapButton::Enable( bool enable )
 {
-    wxWindow::Enable(enable);
+    if ( !wxWindow::Enable(enable) )
+        return FALSE;
 
     SetBitmap();
+
+    return TRUE;
 }
 
 void wxBitmapButton::HasFocus()

src/gtk/button.cpp

@@ -96,9 +96,7 @@ bool wxButton::Create(  wxWindow *parent, wxWindowID id, const wxString &label,
     gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
       GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   
@@ -128,13 +126,14 @@ void wxButton::SetLabel( const wxString &label )
     gtk_label_set( GTK_LABEL( GTK_BUTTON(m_widget)->child ), GetLabel().mbc_str() );
 }
 
-void wxButton::Enable( bool enable )
+bool wxButton::Enable( bool enable )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid button") );
+    if ( !wxControl::Enable( enable ) )
-  
+        return FALSE;
-    wxControl::Enable( enable );
   
     gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
+
+    return TRUE;
 }
 
 void wxButton::ApplyWidgetStyle()

src/gtk/checkbox.cpp

@@ -124,9 +124,7 @@ bool wxCheckBox::Create(wxWindow *parent,
                         GTK_SIGNAL_FUNC(gtk_checkbox_clicked_callback),
                         (gpointer *)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -169,13 +167,14 @@ void wxCheckBox::SetLabel( const wxString& label )
     gtk_label_set( GTK_LABEL(m_widgetLabel), GetLabel().mbc_str() );
 }
 
-void wxCheckBox::Enable( bool enable )
+bool wxCheckBox::Enable( bool enable )
 {
-    wxCHECK_RET( m_widgetLabel != NULL, _T("invalid checkbox") );
+    if ( !wxControl::Enable( enable ) )
-
+        return FALSE;
-    wxControl::Enable( enable );
 
     gtk_widget_set_sensitive( m_widgetLabel, enable );
+
+    return TRUE;
 }
 
 void wxCheckBox::ApplyWidgetStyle()

src/gtk/choice.cpp

@@ -99,9 +99,7 @@ bool wxChoice::Create( wxWindow *parent, wxWindowID id,
     }
     gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk/combobox.cpp

@@ -134,9 +134,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
         gtk_widget_show( list_item );
     }
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -582,7 +580,7 @@ void wxComboBox::OnChar( wxKeyEvent &event )
 
 void wxComboBox::OnSize( wxSizeEvent &event )
 {
-    wxControl::OnSize( event );
+    event.Skip();
     
     return;
 

src/gtk/dcclient.cpp

@@ -110,8 +110,9 @@ wxWindowDC::wxWindowDC( wxWindow *window )
   
     if (!window) return;
     
-    GtkWidget *widget = window->m_wxwindow;
+    GtkWidget *widget = window->GetWxWindow();
-    if (!widget) return;
+    if (!widget)
+        return;
     
     m_window = widget->window;
     
@@ -126,10 +127,10 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     /* still not realized ? */
     if (!m_window) return;
     
-    if (window->m_wxwindow)
+    if (window->GetWxWindow())
-        m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
+        m_cmap = gtk_widget_get_colormap( window->GetWxWindow() );
     else
-        m_cmap = gtk_widget_get_colormap( window->m_widget );
+        m_cmap = gtk_widget_get_colormap( window->GetHandle() );
     
     m_isMemDC = FALSE;
         

src/gtk/dialog.cpp

@@ -69,11 +69,9 @@ static void gtk_dialog_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation
     printf( ".\n" );
 */
 
-   if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
+   if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
    {
-       win->m_sizeSet = FALSE;
+       win->InternalSetSize( alloc->width, alloc->height );
-       win->m_width = alloc->width;
-       win->m_height = alloc->height;
    }
 }
 
@@ -87,10 +85,9 @@ static gint gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEvent
 
     if (!win->HasVMT()) return FALSE;
 
-    win->m_x = event->x;
+    win->InternalSetPosition(event->x, event->y);
-    win->m_y = event->y;
 
-    wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
+    wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
     mevent.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( mevent );
 
@@ -129,43 +126,43 @@ gtk_dialog_map_callback( GtkWidget *widget, wxDialog *win )
 {
     /* I haven''t been able to set the position of
        the dialog before it is shown, so I do it here */
-    gtk_widget_set_uposition( widget, win->m_x, win->m_y );
+    gtk_widget_set_uposition( widget, win->GetX(), win->GetY() );
     
     /* all this is for Motif Window Manager "hints" and is supposed to be
        recognized by other WM as well. not tested. */
     long decor = (long) GDK_DECOR_BORDER;
     long func = (long) GDK_FUNC_MOVE ;
     
-    if ((win->m_windowStyle & wxCAPTION) != 0)
+    if ((win->GetWindowStyle() & wxCAPTION) != 0)
         decor |= GDK_DECOR_TITLE;
-    if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
+    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
     {
        decor |= GDK_DECOR_MENU;
        func |= GDK_FUNC_CLOSE;
     }
-    if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MINIMIZE;
         decor |= GDK_DECOR_MINIMIZE;
     }
-    if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
     {
         decor |= GDK_DECOR_MAXIMIZE;
         func |= GDK_FUNC_MAXIMIZE;           
     }
-    if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
     {
        func |= GDK_FUNC_RESIZE;
        decor |= GDK_DECOR_RESIZEH;
     }
-    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+    gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
-    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+    gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
       
     /* GTK's shrinking/growing policy */
-    if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
     else
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
     
     return FALSE;
 }
@@ -186,6 +183,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)
 
 void wxDialog::Init()
 {
+    m_returnCode = 0;
     m_sizeSet = FALSE;
     m_modalShowing = FALSE;
 }

src/gtk/dnd.cpp

@@ -702,8 +702,8 @@ wxDropSource::wxDropSource( wxWindow *win, const wxIcon &go, const wxIcon &stop
     m_waiting = TRUE;
 
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
 
     m_data = (wxDataBroker*) NULL;
     m_retValue = wxDragCancel;
@@ -722,8 +722,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
     m_waiting = TRUE;
 
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
     m_retValue = wxDragCancel;
 
     if (data)
@@ -748,8 +748,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
 wxDropSource::wxDropSource( wxDataBroker *data, wxWindow *win )
 {
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
     m_retValue = wxDragCancel;
 
     m_data = data;

src/gtk/filedlg.cpp

@@ -57,7 +57,7 @@ void gtk_filedialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFileDialog *dial
 
     int style = dialog->GetStyle();
 
-    GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->m_widget);
+    GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->GetHandle());
     char *filename = gtk_file_selection_get_filename(filedlg);
 
     if ( (style & wxSAVE) && ( style & wxOVERWRITE_PROMPT ) )

src/gtk/font.cpp

@@ -159,12 +159,12 @@ wxFont& wxFont::operator = ( const wxFont& font )
     return *this;
 }
 
-bool wxFont::operator == ( const wxFont& font )
+bool wxFont::operator == ( const wxFont& font ) const
 {
     return m_refData == font.m_refData;
 }
 
-bool wxFont::operator != ( const wxFont& font )
+bool wxFont::operator != ( const wxFont& font ) const
 {
     return m_refData != font.m_refData;
 }

src/gtk/frame.cpp

@@ -73,11 +73,9 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
     printf( ".\n" );
 */
 
-   if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
+   if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
    {
-       win->m_sizeSet = FALSE;
+       win->InternalSetSize( alloc->width, alloc->height );
-       win->m_width = alloc->width;
-       win->m_height = alloc->height;
    }
 }
 
@@ -112,7 +110,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->HasVMT()) return;
     
     win->m_menuBarDetached = FALSE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -126,7 +124,7 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->HasVMT()) return;
     
     win->m_menuBarDetached = TRUE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -140,7 +138,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
     if (!win->HasVMT()) return;
     
     win->m_toolBarDetached = FALSE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -154,7 +152,7 @@ static void gtk_toolbar_detached_callback( GtkWidget *widget, GtkWidget *WXUNUSE
     if (!win->HasVMT()) return;
     
     win->m_toolBarDetached = TRUE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -167,10 +165,9 @@ static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventC
 
     if (!win->HasVMT()) return FALSE;
 
-    win->m_x = event->x;
+    win->InternalSetPosition(event->x, event->y);
-    win->m_y = event->y;
 
-    wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
+    wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
     mevent.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( mevent );
 
@@ -194,38 +191,38 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
     long decor = (long) GDK_DECOR_BORDER;
     long func = (long) GDK_FUNC_MOVE;
     
-    if ((win->m_windowStyle & wxCAPTION) != 0)
+    if ((win->GetWindowStyle() & wxCAPTION) != 0)
         decor |= GDK_DECOR_TITLE;
-    if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
+    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
     {
        decor |= GDK_DECOR_MENU;
        func |= GDK_FUNC_CLOSE;
     }
-    if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MINIMIZE;
         decor |= GDK_DECOR_MINIMIZE;
     }
-    if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MAXIMIZE;
         decor |= GDK_DECOR_MAXIMIZE;
     }
-    if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
     {
        func |= GDK_FUNC_RESIZE;
        decor |= GDK_DECOR_RESIZEH;
     }
 
     
-    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+    gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
-    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+    gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
       
     /* GTK's shrinking/growing policy */
-    if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
     else
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
     
     /* reset the icon */
     if (win->m_icon != wxNullIcon)
@@ -237,17 +234,17 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
     
     /* we set the focus to the child that accepts the focus. this
        doesn't really have to be done in "realize" but why not? */
-    wxNode *node = win->m_children.First();
+    wxWindowList::Node *node = win->GetChildren().GetFirst();
     while (node)
     {
-        wxWindow *child = (wxWindow*) node->Data();
+        wxWindow *child = node->GetData();
         if (child->AcceptsFocus())
         {
             child->SetFocus();
             break;
         }
         
-        node = node->Next();
+        node = node->GetNext();
     }
     
     return FALSE;
@@ -272,23 +269,23 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
         /* these are outside the client area */
         wxFrame* frame = (wxFrame*) parent;
         gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
-                         GTK_WIDGET(child->m_widget),
+                         GTK_WIDGET(child->GetHandle()),
-                         child->m_x,
+                         child->GetX(),
-                         child->m_y,
+                         child->GetY(),
-			 child->m_width,
+                         child->GetWidth(),
-			 child->m_height );
+                         child->GetHeight() );
                          
         /* we connect to these events for recalculating the client area
            space when the toolbar is floating */
         if (wxIS_KIND_OF(child,wxToolBar))
         {
             wxToolBar *toolBar = (wxToolBar*) child;
-	    if (toolBar->m_windowStyle & wxTB_DOCKABLE)
+            if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
             {
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
+                gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_attached",
                     GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
                     
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
+                gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_detached",
                     GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
             }
         }
@@ -296,16 +293,16 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
     else
     {
         /* these are inside the client area */
-        gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+        gtk_myfixed_put( GTK_MYFIXED(parent->GetWxWindow()),
-                         GTK_WIDGET(child->m_widget),
+                         GTK_WIDGET(child->GetHandle()),
-                         child->m_x,
+                         child->GetX(),
-                         child->m_y,
+                         child->GetY(),
-			 child->m_width,
+                         child->GetWidth(),
-			 child->m_height );
+                         child->GetHeight() );
     }
 
     /* resize on OnInternalIdle */
-    parent->m_sizeSet = FALSE;
+    parent->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -671,12 +668,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
             int ww = m_width  - 2*m_miniEdge;
             int hh = wxMENU_HEIGHT;
             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
-            m_frameMenuBar->m_x = xx;
+            m_frameMenuBar->InternalSetPosition(xx, yy);
-            m_frameMenuBar->m_y = yy;
+            m_frameMenuBar->InternalSetSize(ww, hh);
-            m_frameMenuBar->m_width = ww;
-            m_frameMenuBar->m_height = hh;
             gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-	                          m_frameMenuBar->m_widget, 
+                                  m_frameMenuBar->GetHandle(), 
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
@@ -693,14 +688,17 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
                     yy += wxPLACE_HOLDER;
             }
             int ww = m_width - 2*m_miniEdge;
-            int hh = m_frameToolBar->m_height;
+            int hh = m_frameToolBar->GetHeight();
-	    if (m_toolBarDetached) hh = wxPLACE_HOLDER; 
+            // VZ: according to earlier comments in this file, the tbar height
-            m_frameToolBar->m_x = xx;
+            //     shouldn't be changed, so I comment out the next line
-            m_frameToolBar->m_y = yy;
+            //     (09.05.99)
-            /* m_frameToolBar->m_height = hh;   don't change the toolbar's height */
+            //if (m_toolBarDetached) hh = wxPLACE_HOLDER; 
-            m_frameToolBar->m_width = ww;
+
+            m_frameToolBar->InternalSetPosition(xx, yy);
+            m_frameToolBar->InternalSetSize(ww, hh);
+
             gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-	                          m_frameToolBar->m_widget, 
+                                  m_frameToolBar->GetHandle(), 
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
@@ -725,12 +723,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
         int ww = m_width - 2*m_miniEdge;
         int hh = wxSTATUS_HEIGHT;
-        m_frameStatusBar->m_x = xx;
+        m_frameStatusBar->InternalSetPosition(xx, yy);
-        m_frameStatusBar->m_y = yy;
+        m_frameStatusBar->InternalSetSize(ww, hh);
-        m_frameStatusBar->m_width = ww;
-        m_frameStatusBar->m_height = hh;
         gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow), 
-	                      m_frameStatusBar->m_widget, 
+                              m_frameStatusBar->GetHandle(), 
                               xx, yy, ww, hh );
     }
 
@@ -747,7 +743,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
     /* send size event to status bar */
     if (m_frameStatusBar)
     {
-        wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
+        wxSizeEvent event2( wxSize(m_frameStatusBar->GetWidth(),m_frameStatusBar->GetHeight()), m_frameStatusBar->GetId() );
         event2.SetEventObject( m_frameStatusBar );
         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
     }
@@ -812,7 +808,7 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
     
 #if (GTK_MINOR_VERSION > 0)
     /* support for native hot keys  */
-    gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->m_widget));
+    gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->GetHandle()));
 #endif
 
     wxNode *node = menu->GetItems().First();
@@ -847,22 +843,22 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
             node = node->Next();
         }
 
-        if (m_frameMenuBar->m_parent != this)
+        if (m_frameMenuBar->GetParent() != this)
         {
-            m_frameMenuBar->m_parent = this;
+            m_frameMenuBar->SetParent(this);
             gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
-                m_frameMenuBar->m_widget, 
+                m_frameMenuBar->GetHandle(), 
-		m_frameMenuBar->m_x, 
+                m_frameMenuBar->GetX(), 
-		m_frameMenuBar->m_y,
+                m_frameMenuBar->GetY(),
-		m_frameMenuBar->m_width,
+                m_frameMenuBar->GetWidth(),
-		m_frameMenuBar->m_height );
+                m_frameMenuBar->GetHeight() );
         
-	    if (menuBar->m_windowStyle & wxMB_DOCKABLE)
+            if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
             {
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
+                gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_attached",
                     GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
                     
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
+                gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_detached",
                     GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
             }
         }

src/gtk/gauge.cpp

@@ -37,9 +37,7 @@ bool wxGauge::Create( wxWindow *parent, wxWindowID id,  int range,
   
   m_widget = gtk_progress_bar_new();
   
-  m_parent->AddChild( this );
+  m_parent->DoAddChild( this );
-
-  (m_parent->m_insertCallback)( m_parent, this );
   
   PostCreation();
   

src/gtk/listbox.cpp

@@ -282,9 +282,7 @@ bool wxListBox::Create( wxWindow *parent, wxWindowID id,
         gtk_widget_show( list_item );
     }
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -419,7 +417,7 @@ void wxListBox::AppendCommon( const wxString &item )
     gtk_signal_connect( GTK_OBJECT(list_item), "select",
       GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 
-    if (GetWindowStyleFlag() & wxLB_MULTIPLE)
+    if (HasFlag(wxLB_MULTIPLE))
         gtk_signal_connect( GTK_OBJECT(list_item), "deselect",
           GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 
@@ -454,7 +452,7 @@ void wxListBox::AppendCommon( const wxString &item )
 #endif
 
 #if wxUSE_TOOLTIPS
-        if (m_toolTip) m_toolTip->Apply( this );
+        if (m_tooltip) m_tooltip->Apply( this );
 #endif
     }
 }
@@ -858,10 +856,13 @@ void wxListBox::ApplyWidgetStyle()
     if (m_backgroundColour.Ok())
     {
         GdkWindow *window = GTK_WIDGET(m_list)->window;
+        if ( window )
+        {
             m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
             gdk_window_set_background( window, m_backgroundColour.GetColor() );
             gdk_window_clear( window );
         }
+    }
 
     GList *child = m_list->children;
     while (child)

src/gtk/mdi.cpp

@@ -90,14 +90,12 @@ void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
 
     wxMenuBar *menu_bar = child_frame->m_menuBar;
     if (!menu_bar) return;
-    if (!menu_bar->m_widget) return;
+    if (!menu_bar->GetHandle()) return;
 
-    menu_bar->m_x = 0;
+    menu_bar->InternalSetPosition(0, 0);
-    menu_bar->m_y = 0;
+    menu_bar->InternalSetSize(m_width, wxMENU_HEIGHT);
-    menu_bar->m_width = m_width;
-    menu_bar->m_height = wxMENU_HEIGHT;
     gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-                          menu_bar->m_widget, 
+                          menu_bar->GetHandle(), 
                           0, 0, m_width, wxMENU_HEIGHT );
 }
 
@@ -110,7 +108,7 @@ void wxMDIParentFrame::OnInternalIdle()
 
     if (m_justInserted)
     {
-        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
+        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
         gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 );
 
         m_justInserted = FALSE;
@@ -122,7 +120,7 @@ void wxMDIParentFrame::OnInternalIdle()
     wxMDIChildFrame *active_child_frame = GetActiveChild();
     bool visible_child_menu = FALSE;
 
-    wxNode *node = m_clientWindow->m_children.First();
+    wxNode *node = m_clientWindow->GetChildren().First();
     while (node)
     {
         wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -130,11 +128,11 @@ void wxMDIParentFrame::OnInternalIdle()
         {
             if (child_frame == active_child_frame)
             {
-               gtk_widget_show( child_frame->m_menuBar->m_widget );
+               gtk_widget_show( child_frame->m_menuBar->GetHandle() );
                visible_child_menu = TRUE;
             }
             else
-               gtk_widget_hide( child_frame->m_menuBar->m_widget );
+               gtk_widget_hide( child_frame->m_menuBar->GetHandle() );
         }
         node = node->Next();
     }
@@ -152,7 +150,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
 {
     if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
     if (!notebook) return (wxMDIChildFrame*) NULL;
 
 #if (GTK_MINOR_VERSION > 0)
@@ -165,7 +163,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
     GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
     if (!page) return (wxMDIChildFrame*) NULL;
 
-    wxNode *node = m_clientWindow->m_children.First();
+    wxNode *node = m_clientWindow->GetChildren().First();
     while (node)
     {
         wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -191,13 +189,13 @@ wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
 void wxMDIParentFrame::ActivateNext()
 {
     if (m_clientWindow)
-      gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
+      gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
 }
 
 void wxMDIParentFrame::ActivatePrevious()
 {
     if (m_clientWindow)
-      gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
+      gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
 }
 
 void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
@@ -279,9 +277,9 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
 
     if (m_menuBar)
     {
-        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
+        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
 
-       if (m_menuBar->m_parent != this)
+       if (m_menuBar->GetParent() != this)
        {
             wxNode *node = m_menuBar->GetMenus().First();
             while (node)
@@ -291,16 +289,16 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
                 node = node->Next();
             }
 
-            m_menuBar->m_parent = mdi_frame;
+            m_menuBar->SetParent( mdi_frame );
         }
 
         /* the menu bar of the child window is shown in idle time as needed */
-        gtk_widget_hide( m_menuBar->m_widget );
+        gtk_widget_hide( m_menuBar->GetHandle() );
 
         /* insert the invisible menu bar into the _parent_ mdi frame */
         gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget), 
-	                 m_menuBar->m_widget, 
+                         m_menuBar->GetHandle(), 
-			 0, 0,  mdi_frame->m_width, wxMENU_HEIGHT );
+                         0, 0,  mdi_frame->GetWidth(), wxMENU_HEIGHT );
     }
 }
 
@@ -325,11 +323,11 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    if ((win->m_x == alloc->x) &&
+    if ((win->GetX() == alloc->x) &&
-        (win->m_y == alloc->y) &&
+        (win->GetY() == alloc->y) &&
-        (win->m_width == alloc->width) &&
+        (win->GetWidth() == alloc->width) &&
-        (win->m_height == alloc->height) &&
+        (win->GetHeight() == alloc->height) &&
-        (win->m_sizeSet))
+        (win->IsSizeSet()))
     {
         return;
     }
@@ -349,16 +347,16 @@ static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* chil
     GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
     gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
 
-    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
+    gtk_signal_connect( GTK_OBJECT(child->GetHandle()), "size_allocate",
       GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetHandle());
 
-    gtk_notebook_append_page( notebook, child->m_widget, label_widget );
+    gtk_notebook_append_page( notebook, child->GetHandle(), label_widget );
 
     child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
 
-    wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->m_parent;
+    wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->GetParent();
     parent_frame->m_justInserted = TRUE;
 }
 
@@ -393,9 +391,7 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
 
     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -404,5 +400,3 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
     return TRUE;
 }
 
-
-

src/gtk/minifram.cpp

@@ -73,23 +73,23 @@ static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
                      GTK_STATE_NORMAL,
                      GTK_SHADOW_OUT,
                      0, 0,
-		     win->m_width, win->m_height );
+                     win->GetWidth(), win->GetHeight() );
 
     if (!win->m_title.IsEmpty() &&
-        ((win->m_windowStyle & wxCAPTION) || 
+        ((win->GetWindowStyle() & wxCAPTION) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_HORIZ) || 
+         (win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_VERT)))
+         (win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
     {
         GdkGC *gc = gdk_gc_new( widget->window );
         GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
         int x = 2;
-	if (win->m_windowStyle & wxSYSTEM_MENU) x = 18;
+        if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
         
         gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
         gdk_draw_rectangle( widget->window, gc, TRUE, 
                             x, 
                             3, 
-			    win->m_width - 4 - x,
+                            win->GetWidth() - 4 - x,
                             font->ascent + font->descent+1 );
                             
         gdk_gc_set_foreground( gc, &widget->style->white );
@@ -117,23 +117,23 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
                      GTK_STATE_NORMAL,
                      GTK_SHADOW_OUT,
                      0, 0,
-		     win->m_width, win->m_height );
+                     win->GetWidth(), win->GetHeight() );
                      
     if (!win->m_title.IsEmpty() &&
-        ((win->m_windowStyle & wxCAPTION) || 
+        ((win->GetWindowStyle() & wxCAPTION) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_HORIZ) || 
+         (win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_VERT)))
+         (win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
     {
         GdkGC *gc = gdk_gc_new( widget->window );
         GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
         int x = 2;
-	if (win->m_windowStyle & wxSYSTEM_MENU) x = 17;
+        if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
         
         gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
         gdk_draw_rectangle( widget->window, gc, TRUE, 
                             x, 
                             3, 
-			    win->m_width - 4 - x,
+                            win->GetWidth() - 4 - x,
                             font->ascent + font->descent+1 );
                             
         gdk_gc_set_foreground( gc, &widget->style->white );
@@ -174,7 +174,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
                      
     win->m_diffX = (int)gdk_event->x;
     win->m_diffY = (int)gdk_event->y;
-    DrawFrame( widget, 0, 0, win->m_width, win->m_height );
+    DrawFrame( widget, 0, 0, win->GetWidth(), win->GetHeight() );
     win->m_oldX = 0;
     win->m_oldY = 0;
     
@@ -202,16 +202,15 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     int x = (int)gdk_event->x;
     int y = (int)gdk_event->y;
     
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
     int org_x = 0;    
     int org_y = 0;
     gdk_window_get_origin( widget->window, &org_x, &org_y );
     x += org_x - win->m_diffX;
     y += org_y - win->m_diffY;
-    win->m_x = x;
+    win->InternalSetPosition(x, y);
-    win->m_y = y;
+    gtk_widget_set_uposition( win->GetWidget(), x, y );
-    gtk_widget_set_uposition( win->m_widget, x, y );
 
     return TRUE;
 }
@@ -241,10 +240,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
        gdk_event->state = state;
     }
 
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     win->m_oldX = (int)gdk_event->x - win->m_diffX;
     win->m_oldY = (int)gdk_event->y - win->m_diffY;
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     
     return TRUE;
 }

src/gtk/notebook.cpp

@@ -125,10 +125,10 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 {
     if (g_isIdle) wxapp_install_idle_handler();
     
-    if ((win->m_x == alloc->x) &&
+    if ((win->GetX() == alloc->x) &&
-        (win->m_y == alloc->y) &&
+        (win->GetY() == alloc->y) &&
-        (win->m_width == alloc->width) &&
+        (win->GetWidth() == alloc->width) &&
-        (win->m_height == alloc->height))
+        (win->GetHeight() == alloc->height))
     {
         return;
     }
@@ -188,16 +188,16 @@ static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
     page->m_box = gtk_hbox_new (FALSE, 0);
     gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetWidget());
 
     page->m_client = child;
-    gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
+    gtk_notebook_append_page( notebook, child->GetWidget(), page->m_box );
 
     page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
 
     page->m_parent = notebook;
 
-    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
+    gtk_signal_connect( GTK_OBJECT(child->GetWidget()), "size_allocate",
       GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
 
     wxASSERT_MSG( page->m_page, _T("Notebook page creation error") );
@@ -267,9 +267,7 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
                   GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
                   (gpointer)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );

src/gtk/radiobox.cpp

@@ -68,7 +68,7 @@ BEGIN_EVENT_TABLE(wxRadioBox, wxControl)
     EVT_SIZE(wxRadioBox::OnSize)
 END_EVENT_TABLE()
 
-wxRadioBox::wxRadioBox(void)
+wxRadioBox::wxRadioBox()
 {
 }
 
@@ -108,7 +108,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
         gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
            GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
 
-        gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow), 
+        gtk_myfixed_put( GTK_MYFIXED(m_parent->GetWxWindow()), 
                          GTK_WIDGET(m_radio), 
                          m_x+10, m_y+10+(i*24), 10, 10 );
     }
@@ -120,9 +120,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
     if (newSize.y == -1) newSize.y = ls.y;
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -137,7 +135,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
     return TRUE;
 }
 
-wxRadioBox::~wxRadioBox(void)
+wxRadioBox::~wxRadioBox()
 {
     wxNode *node = m_boxes.First();
     while (node)
@@ -150,9 +148,9 @@ wxRadioBox::~wxRadioBox(void)
 
 void wxRadioBox::OnSize( wxSizeEvent &event )
 {
-    wxControl::OnSize( event );
-
     LayoutItems();
+
+    event.Skip();
 }
 
 wxSize wxRadioBox::LayoutItems()
@@ -181,7 +179,7 @@ wxSize wxRadioBox::LayoutItems()
                 int len = 22+gdk_string_measure( font, label->label );
                 if (len > max_len) max_len = len;
 
-                gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
+                gtk_myfixed_move( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y );
                 y += 20;
 
                 node = node->Next();
@@ -195,7 +193,7 @@ wxSize wxRadioBox::LayoutItems()
             {
                 GtkWidget *button = GTK_WIDGET( node->Data() );
 
-                gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
+                gtk_myfixed_resize( GTK_MYFIXED(m_parent->GetWxWindow()), button, max_len, 20 );
 
                 node = node->Next();
                 if (!node) break;
@@ -231,7 +229,7 @@ wxSize wxRadioBox::LayoutItems()
         {
             GtkWidget *button = GTK_WIDGET( node->Data() );
 
-            gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
+            gtk_myfixed_set_size( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y, max, 20 );
             x += max;
 
             node = node->Next();
@@ -389,9 +387,10 @@ void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
     wxFAIL_MSG(_T("wxRadioBox::SetLabel not implemented."));
 }
 
-void wxRadioBox::Enable( bool enable )
+bool wxRadioBox::Enable( bool enable )
 {
-    wxControl::Enable( enable );
+    if ( !wxControl::Enable( enable ) )
+        return FALSE;
 
     wxNode *node = m_boxes.First();
     while (node)
@@ -402,6 +401,8 @@ void wxRadioBox::Enable( bool enable )
         gtk_widget_set_sensitive( label, enable );
         node = node->Next();
     }
+
+    return TRUE;
 }
 
 void wxRadioBox::Enable( int item, bool enable )

src/gtk/radiobut.cpp

@@ -91,9 +91,7 @@ bool wxRadioButton::Create( wxWindow *parent, wxWindowID id, const wxString& lab
     gtk_signal_connect( GTK_OBJECT(m_widget), "clicked", 
       GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
        
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 
@@ -138,13 +136,14 @@ bool wxRadioButton::GetValue(void) const
     return GTK_TOGGLE_BUTTON(m_widget)->active;
 }
 
-void wxRadioButton::Enable( bool enable )
+bool wxRadioButton::Enable( bool enable )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid radiobutton") );
+    if ( !wxControl::Enable( enable ) )
-  
+        return FALSE;
-    wxControl::Enable( enable );
   
     gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
+
+    return TRUE;
 }
 
 void wxRadioButton::ApplyWidgetStyle()

src/gtk/scrolbar.cpp

@@ -53,7 +53,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
     float line_step = win->m_adjust->step_increment;
     float page_step = win->m_adjust->page_increment;
   
-    if (win->m_isScrolling)
+    if (win->IsScrolling())
     {
         command = wxEVT_SCROLL_THUMBTRACK;
     }
@@ -70,8 +70,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
 
     int value = (int)(win->m_adjust->value+0.5);
       
-    int orient = wxHORIZONTAL;
+    int orient = win->HasFlag(wxSB_VERTICAL) ? wxVERTICAL : wxHORIZONTAL;
-    if (win->GetWindowStyleFlag() & wxSB_VERTICAL == wxSB_VERTICAL) orient = wxVERTICAL;
   
     wxScrollEvent event( command, win->GetId(), value, orient );
     event.SetEventObject( win );
@@ -94,7 +93,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    win->m_isScrolling = TRUE;
+    win->SetScrolling(TRUE);
 //  g_blockEventsOnScroll = TRUE;  doesn't work in DialogEd
   
     return FALSE;
@@ -110,7 +109,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    win->m_isScrolling = FALSE;
+    win->SetScrolling(FALSE);
 //  g_blockEventsOnScroll = FALSE;
   
     gtk_signal_emit_by_name( GTK_OBJECT(win->m_adjust), "value_changed" );
@@ -163,9 +162,7 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
                         (GtkSignalFunc)gtk_scrollbar_button_release_callback, 
                         (gpointer) this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk/slider.cpp

@@ -144,9 +144,7 @@ bool wxSlider::Create(wxWindow *parent, wxWindowID id,
     SetRange( minValue, maxValue );
     SetValue( value );
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk/spinbutt.cpp

@@ -111,9 +111,7 @@ bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, c
                         (GtkSignalFunc) gtk_spinbutt_callback,
                         (gpointer) this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk/statbmp.cpp

@@ -60,9 +60,7 @@ bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
         m_widget = gtk_label_new( "Bitmap" );
     }
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk/statbox.cpp

@@ -45,9 +45,7 @@ bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label
     
     m_widget = gtk_frame_new(m_label.mbc_str());
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 

src/gtk/statline.cpp

@@ -46,9 +46,7 @@ bool wxStaticLine::Create( wxWindow *parent, wxWindowID id,
     else
         m_widget = gtk_hseparator_new();
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk/stattext.cpp

@@ -76,9 +76,7 @@ bool wxStaticText::Create(wxWindow *parent,
 
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk/tbargtk.cpp

@@ -209,9 +209,7 @@ bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
     m_xMargin = 0;
     m_yMargin = 0;
     
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 

src/gtk/textctrl.cpp

@@ -46,11 +46,11 @@ gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    if (!win->m_hasVMT) return;
+    if (!win->HasVMT()) return;
 
     win->SetModified();
 
-    wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
+    wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
     event.SetString( win->GetValue() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
@@ -67,7 +67,7 @@ gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
 
     win->CalculateScrollbar();
     
-    if (!win->m_hasVMT) return;
+    if (!win->HasVMT()) return;
 }
 
 //-----------------------------------------------------------------------------
@@ -152,7 +152,6 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
         /* ... and put into the upper left hand corner of the table */
         m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
         GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-
         gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
@@ -160,13 +159,11 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
 
         /* always wrap words */
         gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
-
         /* put the horizontal scrollbar in the lower left hand corner */
         if (bHasHScrollbar)
         {
             GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
             GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
-
             gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
                        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
                        GTK_FILL,
@@ -178,11 +175,9 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
             gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
 #endif
         }
-
         /* finally, put the vertical scrollbar in the upper right corner */
         m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
         GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
-
         gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
                      GTK_FILL,
                      (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
@@ -200,9 +195,7 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
     if (newSize.y == -1) newSize.y = 26;
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -948,46 +941,53 @@ bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
         return (window == GTK_ENTRY(m_text)->text_area);
 }
 
-void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
+bool wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     // doesn't work
+    return FALSE;
 }
 
-void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
+bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     // doesn't work
+    return FALSE;
 }
 
-void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
+bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     wxControl::SetBackgroundColour( colour );
 
-    if (!m_widget->window) return;
+    if (!m_widget->window)
+        return FALSE;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (sysbg.Red() == colour.Red() &&
         sysbg.Green() == colour.Green() &&
         sysbg.Blue() == colour.Blue())
     {
-        return;
+        return FALSE; // FIXME or TRUE?
     }
 
-    if (!m_backgroundColour.Ok()) return;
+    if (!m_backgroundColour.Ok())
+        return FALSE;
 
     if (m_windowStyle & wxTE_MULTILINE)
     {
         GdkWindow *window = GTK_TEXT(m_text)->text_area;
-        if (!window) return;
+        if (!window)
+            return FALSE;
         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
         gdk_window_set_background( window, m_backgroundColour.GetColor() );
         gdk_window_clear( window );
     }
+
+    return TRUE;
 }
 
 void wxTextCtrl::ApplyWidgetStyle()

src/gtk/treectrl.cpp

@@ -133,9 +133,7 @@ printf("5\n");
   SetValidator(validator);
 
 printf("Robert's new insertion code :-)\n");
-  m_parent->AddChild( this );
+  m_parent->DoAddChild( this );
-  (m_parent->m_insertCallback)( m_parent, this );
-
 printf("postcreate\n");
   PostCreation();
 

src/gtk1/app.cpp

@@ -45,7 +45,6 @@
 wxApp *wxTheApp = (wxApp *)  NULL;
 wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
 
-extern wxList wxPendingDelete;
 #if wxUSE_THREADS
 extern wxList *wxPendingEvents;
 extern wxCriticalSection *wxPendingEventsLocker;
@@ -287,11 +286,12 @@ bool wxApp::OnInitGui()
                 int gg = (g << 3) | (g >> 2);
                 int bb = (b << 3) | (b >> 2);
 
+                int index = -1;
+
                 GdkColor *colors = cmap->colors;
                 if(colors)
                 {
                     int max = 3 * 65536;
-                	int index = -1;
 
                     for (int i = 0; i < cmap->size; i++)
                     {
@@ -299,9 +299,13 @@ bool wxApp::OnInitGui()
                         int gdiff = ((gg << 8) - colors[i].green);
                         int bdiff = ((bb << 8) - colors[i].blue);
                         int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
-                    if (sum < max) { index = i; max = sum; }
+                        if (sum < max)
+                        { 
+                            index = i; max = sum;
                         }
                     }
+                }
+
                 m_colorCube[ (r*1024) + (g*32) + b ] = index;
             }
         }
@@ -448,7 +452,7 @@ void wxApp::DeletePendingObjects()
 
         delete obj;
 
-        if (wxPendingDelete.Member(obj))
+        if (wxPendingDelete.Find(obj))
             delete node;
 
         node = wxPendingDelete.First();

src/gtk1/bmpbuttn.cpp

@@ -166,7 +166,7 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
  
     m_parent->AddChild( this );
 
-    (m_parent->m_insertCallback)( m_parent, this );
+    m_parent->InsertChild( this );
   
     PostCreation();
   
@@ -278,11 +278,14 @@ void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
     SetBitmap();
 }
 
-void wxBitmapButton::Enable( const bool enable )
+bool wxBitmapButton::Enable( bool enable )
 {
-    wxWindow::Enable(enable);
+    if ( !wxWindow::Enable(enable) )
+        return FALSE;
 
     SetBitmap();
+
+    return TRUE;
 }
 
 void wxBitmapButton::HasFocus()

src/gtk1/button.cpp

@@ -96,9 +96,7 @@ bool wxButton::Create(  wxWindow *parent, wxWindowID id, const wxString &label,
     gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
       GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   
@@ -128,13 +126,14 @@ void wxButton::SetLabel( const wxString &label )
     gtk_label_set( GTK_LABEL( GTK_BUTTON(m_widget)->child ), GetLabel().mbc_str() );
 }
 
-void wxButton::Enable( bool enable )
+bool wxButton::Enable( bool enable )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid button") );
+    if ( !wxControl::Enable( enable ) )
-  
+        return FALSE;
-    wxControl::Enable( enable );
   
     gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
+
+    return TRUE;
 }
 
 void wxButton::ApplyWidgetStyle()

src/gtk1/checkbox.cpp

@@ -124,9 +124,7 @@ bool wxCheckBox::Create(wxWindow *parent,
                         GTK_SIGNAL_FUNC(gtk_checkbox_clicked_callback),
                         (gpointer *)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -169,13 +167,14 @@ void wxCheckBox::SetLabel( const wxString& label )
     gtk_label_set( GTK_LABEL(m_widgetLabel), GetLabel().mbc_str() );
 }
 
-void wxCheckBox::Enable( bool enable )
+bool wxCheckBox::Enable( bool enable )
 {
-    wxCHECK_RET( m_widgetLabel != NULL, _T("invalid checkbox") );
+    if ( !wxControl::Enable( enable ) )
-
+        return FALSE;
-    wxControl::Enable( enable );
 
     gtk_widget_set_sensitive( m_widgetLabel, enable );
+
+    return TRUE;
 }
 
 void wxCheckBox::ApplyWidgetStyle()

src/gtk1/choice.cpp

@@ -99,9 +99,7 @@ bool wxChoice::Create( wxWindow *parent, wxWindowID id,
     }
     gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk1/combobox.cpp

@@ -134,9 +134,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
         gtk_widget_show( list_item );
     }
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -582,7 +580,7 @@ void wxComboBox::OnChar( wxKeyEvent &event )
 
 void wxComboBox::OnSize( wxSizeEvent &event )
 {
-    wxControl::OnSize( event );
+    event.Skip();
     
     return;
 

src/gtk1/dcclient.cpp

@@ -110,8 +110,9 @@ wxWindowDC::wxWindowDC( wxWindow *window )
   
     if (!window) return;
     
-    GtkWidget *widget = window->m_wxwindow;
+    GtkWidget *widget = window->GetWxWindow();
-    if (!widget) return;
+    if (!widget)
+        return;
     
     m_window = widget->window;
     
@@ -126,10 +127,10 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     /* still not realized ? */
     if (!m_window) return;
     
-    if (window->m_wxwindow)
+    if (window->GetWxWindow())
-        m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
+        m_cmap = gtk_widget_get_colormap( window->GetWxWindow() );
     else
-        m_cmap = gtk_widget_get_colormap( window->m_widget );
+        m_cmap = gtk_widget_get_colormap( window->GetHandle() );
     
     m_isMemDC = FALSE;
         

src/gtk1/dialog.cpp

@@ -69,11 +69,9 @@ static void gtk_dialog_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation
     printf( ".\n" );
 */
 
-   if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
+   if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
    {
-       win->m_sizeSet = FALSE;
+       win->InternalSetSize( alloc->width, alloc->height );
-       win->m_width = alloc->width;
-       win->m_height = alloc->height;
    }
 }
 
@@ -87,10 +85,9 @@ static gint gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEvent
 
     if (!win->HasVMT()) return FALSE;
 
-    win->m_x = event->x;
+    win->InternalSetPosition(event->x, event->y);
-    win->m_y = event->y;
 
-    wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
+    wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
     mevent.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( mevent );
 
@@ -129,43 +126,43 @@ gtk_dialog_map_callback( GtkWidget *widget, wxDialog *win )
 {
     /* I haven''t been able to set the position of
        the dialog before it is shown, so I do it here */
-    gtk_widget_set_uposition( widget, win->m_x, win->m_y );
+    gtk_widget_set_uposition( widget, win->GetX(), win->GetY() );
     
     /* all this is for Motif Window Manager "hints" and is supposed to be
        recognized by other WM as well. not tested. */
     long decor = (long) GDK_DECOR_BORDER;
     long func = (long) GDK_FUNC_MOVE ;
     
-    if ((win->m_windowStyle & wxCAPTION) != 0)
+    if ((win->GetWindowStyle() & wxCAPTION) != 0)
         decor |= GDK_DECOR_TITLE;
-    if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
+    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
     {
        decor |= GDK_DECOR_MENU;
        func |= GDK_FUNC_CLOSE;
     }
-    if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MINIMIZE;
         decor |= GDK_DECOR_MINIMIZE;
     }
-    if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
     {
         decor |= GDK_DECOR_MAXIMIZE;
         func |= GDK_FUNC_MAXIMIZE;           
     }
-    if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
     {
        func |= GDK_FUNC_RESIZE;
        decor |= GDK_DECOR_RESIZEH;
     }
-    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+    gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
-    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+    gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
       
     /* GTK's shrinking/growing policy */
-    if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
     else
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
     
     return FALSE;
 }
@@ -186,6 +183,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)
 
 void wxDialog::Init()
 {
+    m_returnCode = 0;
     m_sizeSet = FALSE;
     m_modalShowing = FALSE;
 }

src/gtk1/dnd.cpp

@@ -702,8 +702,8 @@ wxDropSource::wxDropSource( wxWindow *win, const wxIcon &go, const wxIcon &stop
     m_waiting = TRUE;
 
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
 
     m_data = (wxDataBroker*) NULL;
     m_retValue = wxDragCancel;
@@ -722,8 +722,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
     m_waiting = TRUE;
 
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
     m_retValue = wxDragCancel;
 
     if (data)
@@ -748,8 +748,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
 wxDropSource::wxDropSource( wxDataBroker *data, wxWindow *win )
 {
     m_window = win;
-    m_widget = win->m_widget;
+    m_widget = win->GetWidget();
-    if (win->m_wxwindow) m_widget = win->m_wxwindow;
+    if (win->GetWxWindow()) m_widget = win->GetWxWindow();
     m_retValue = wxDragCancel;
 
     m_data = data;

src/gtk1/filedlg.cpp

@@ -57,7 +57,7 @@ void gtk_filedialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFileDialog *dial
 
     int style = dialog->GetStyle();
 
-    GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->m_widget);
+    GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->GetHandle());
     char *filename = gtk_file_selection_get_filename(filedlg);
 
     if ( (style & wxSAVE) && ( style & wxOVERWRITE_PROMPT ) )

src/gtk1/font.cpp

@@ -159,12 +159,12 @@ wxFont& wxFont::operator = ( const wxFont& font )
     return *this;
 }
 
-bool wxFont::operator == ( const wxFont& font )
+bool wxFont::operator == ( const wxFont& font ) const
 {
     return m_refData == font.m_refData;
 }
 
-bool wxFont::operator != ( const wxFont& font )
+bool wxFont::operator != ( const wxFont& font ) const
 {
     return m_refData != font.m_refData;
 }

src/gtk1/frame.cpp

@@ -73,11 +73,9 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
     printf( ".\n" );
 */
 
-   if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
+   if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
    {
-       win->m_sizeSet = FALSE;
+       win->InternalSetSize( alloc->width, alloc->height );
-       win->m_width = alloc->width;
-       win->m_height = alloc->height;
    }
 }
 
@@ -112,7 +110,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->HasVMT()) return;
     
     win->m_menuBarDetached = FALSE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -126,7 +124,7 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->HasVMT()) return;
     
     win->m_menuBarDetached = TRUE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -140,7 +138,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
     if (!win->HasVMT()) return;
     
     win->m_toolBarDetached = FALSE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -154,7 +152,7 @@ static void gtk_toolbar_detached_callback( GtkWidget *widget, GtkWidget *WXUNUSE
     if (!win->HasVMT()) return;
     
     win->m_toolBarDetached = TRUE;
-    win->m_sizeSet = FALSE;
+    win->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -167,10 +165,9 @@ static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventC
 
     if (!win->HasVMT()) return FALSE;
 
-    win->m_x = event->x;
+    win->InternalSetPosition(event->x, event->y);
-    win->m_y = event->y;
 
-    wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
+    wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
     mevent.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( mevent );
 
@@ -194,38 +191,38 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
     long decor = (long) GDK_DECOR_BORDER;
     long func = (long) GDK_FUNC_MOVE;
     
-    if ((win->m_windowStyle & wxCAPTION) != 0)
+    if ((win->GetWindowStyle() & wxCAPTION) != 0)
         decor |= GDK_DECOR_TITLE;
-    if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
+    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
     {
        decor |= GDK_DECOR_MENU;
        func |= GDK_FUNC_CLOSE;
     }
-    if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MINIMIZE;
         decor |= GDK_DECOR_MINIMIZE;
     }
-    if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
+    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
     {
         func |= GDK_FUNC_MAXIMIZE;
         decor |= GDK_DECOR_MAXIMIZE;
     }
-    if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
     {
        func |= GDK_FUNC_RESIZE;
        decor |= GDK_DECOR_RESIZEH;
     }
 
     
-    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+    gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
-    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+    gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
       
     /* GTK's shrinking/growing policy */
-    if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
+    if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
     else
-        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
+        gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
     
     /* reset the icon */
     if (win->m_icon != wxNullIcon)
@@ -237,17 +234,17 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
     
     /* we set the focus to the child that accepts the focus. this
        doesn't really have to be done in "realize" but why not? */
-    wxNode *node = win->m_children.First();
+    wxWindowList::Node *node = win->GetChildren().GetFirst();
     while (node)
     {
-        wxWindow *child = (wxWindow*) node->Data();
+        wxWindow *child = node->GetData();
         if (child->AcceptsFocus())
         {
             child->SetFocus();
             break;
         }
         
-        node = node->Next();
+        node = node->GetNext();
     }
     
     return FALSE;
@@ -272,23 +269,23 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
         /* these are outside the client area */
         wxFrame* frame = (wxFrame*) parent;
         gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
-                         GTK_WIDGET(child->m_widget),
+                         GTK_WIDGET(child->GetHandle()),
-                         child->m_x,
+                         child->GetX(),
-                         child->m_y,
+                         child->GetY(),
-			 child->m_width,
+                         child->GetWidth(),
-			 child->m_height );
+                         child->GetHeight() );
                          
         /* we connect to these events for recalculating the client area
            space when the toolbar is floating */
         if (wxIS_KIND_OF(child,wxToolBar))
         {
             wxToolBar *toolBar = (wxToolBar*) child;
-	    if (toolBar->m_windowStyle & wxTB_DOCKABLE)
+            if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
             {
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
+                gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_attached",
                     GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
                     
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
+                gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_detached",
                     GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
             }
         }
@@ -296,16 +293,16 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
     else
     {
         /* these are inside the client area */
-        gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+        gtk_myfixed_put( GTK_MYFIXED(parent->GetWxWindow()),
-                         GTK_WIDGET(child->m_widget),
+                         GTK_WIDGET(child->GetHandle()),
-                         child->m_x,
+                         child->GetX(),
-                         child->m_y,
+                         child->GetY(),
-			 child->m_width,
+                         child->GetWidth(),
-			 child->m_height );
+                         child->GetHeight() );
     }
 
     /* resize on OnInternalIdle */
-    parent->m_sizeSet = FALSE;
+    parent->UpdateSize();
 }
 
 //-----------------------------------------------------------------------------
@@ -671,12 +668,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
             int ww = m_width  - 2*m_miniEdge;
             int hh = wxMENU_HEIGHT;
             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
-            m_frameMenuBar->m_x = xx;
+            m_frameMenuBar->InternalSetPosition(xx, yy);
-            m_frameMenuBar->m_y = yy;
+            m_frameMenuBar->InternalSetSize(ww, hh);
-            m_frameMenuBar->m_width = ww;
-            m_frameMenuBar->m_height = hh;
             gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-	                          m_frameMenuBar->m_widget, 
+                                  m_frameMenuBar->GetHandle(), 
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
@@ -693,14 +688,17 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
                     yy += wxPLACE_HOLDER;
             }
             int ww = m_width - 2*m_miniEdge;
-            int hh = m_frameToolBar->m_height;
+            int hh = m_frameToolBar->GetHeight();
-	    if (m_toolBarDetached) hh = wxPLACE_HOLDER; 
+            // VZ: according to earlier comments in this file, the tbar height
-            m_frameToolBar->m_x = xx;
+            //     shouldn't be changed, so I comment out the next line
-            m_frameToolBar->m_y = yy;
+            //     (09.05.99)
-            /* m_frameToolBar->m_height = hh;   don't change the toolbar's height */
+            //if (m_toolBarDetached) hh = wxPLACE_HOLDER; 
-            m_frameToolBar->m_width = ww;
+
+            m_frameToolBar->InternalSetPosition(xx, yy);
+            m_frameToolBar->InternalSetSize(ww, hh);
+
             gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-	                          m_frameToolBar->m_widget, 
+                                  m_frameToolBar->GetHandle(), 
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
@@ -725,12 +723,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
         int ww = m_width - 2*m_miniEdge;
         int hh = wxSTATUS_HEIGHT;
-        m_frameStatusBar->m_x = xx;
+        m_frameStatusBar->InternalSetPosition(xx, yy);
-        m_frameStatusBar->m_y = yy;
+        m_frameStatusBar->InternalSetSize(ww, hh);
-        m_frameStatusBar->m_width = ww;
-        m_frameStatusBar->m_height = hh;
         gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow), 
-	                      m_frameStatusBar->m_widget, 
+                              m_frameStatusBar->GetHandle(), 
                               xx, yy, ww, hh );
     }
 
@@ -747,7 +743,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
     /* send size event to status bar */
     if (m_frameStatusBar)
     {
-        wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
+        wxSizeEvent event2( wxSize(m_frameStatusBar->GetWidth(),m_frameStatusBar->GetHeight()), m_frameStatusBar->GetId() );
         event2.SetEventObject( m_frameStatusBar );
         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
     }
@@ -812,7 +808,7 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
     
 #if (GTK_MINOR_VERSION > 0)
     /* support for native hot keys  */
-    gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->m_widget));
+    gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->GetHandle()));
 #endif
 
     wxNode *node = menu->GetItems().First();
@@ -847,22 +843,22 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
             node = node->Next();
         }
 
-        if (m_frameMenuBar->m_parent != this)
+        if (m_frameMenuBar->GetParent() != this)
         {
-            m_frameMenuBar->m_parent = this;
+            m_frameMenuBar->SetParent(this);
             gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
-                m_frameMenuBar->m_widget, 
+                m_frameMenuBar->GetHandle(), 
-		m_frameMenuBar->m_x, 
+                m_frameMenuBar->GetX(), 
-		m_frameMenuBar->m_y,
+                m_frameMenuBar->GetY(),
-		m_frameMenuBar->m_width,
+                m_frameMenuBar->GetWidth(),
-		m_frameMenuBar->m_height );
+                m_frameMenuBar->GetHeight() );
         
-	    if (menuBar->m_windowStyle & wxMB_DOCKABLE)
+            if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
             {
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
+                gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_attached",
                     GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
                     
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
+                gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_detached",
                     GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
             }
         }

src/gtk1/gauge.cpp

@@ -37,9 +37,7 @@ bool wxGauge::Create( wxWindow *parent, wxWindowID id,  int range,
   
   m_widget = gtk_progress_bar_new();
   
-  m_parent->AddChild( this );
+  m_parent->DoAddChild( this );
-
-  (m_parent->m_insertCallback)( m_parent, this );
   
   PostCreation();
   

src/gtk1/listbox.cpp

@@ -282,9 +282,7 @@ bool wxListBox::Create( wxWindow *parent, wxWindowID id,
         gtk_widget_show( list_item );
     }
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -419,7 +417,7 @@ void wxListBox::AppendCommon( const wxString &item )
     gtk_signal_connect( GTK_OBJECT(list_item), "select",
       GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 
-    if (GetWindowStyleFlag() & wxLB_MULTIPLE)
+    if (HasFlag(wxLB_MULTIPLE))
         gtk_signal_connect( GTK_OBJECT(list_item), "deselect",
           GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 
@@ -454,7 +452,7 @@ void wxListBox::AppendCommon( const wxString &item )
 #endif
 
 #if wxUSE_TOOLTIPS
-        if (m_toolTip) m_toolTip->Apply( this );
+        if (m_tooltip) m_tooltip->Apply( this );
 #endif
     }
 }
@@ -858,10 +856,13 @@ void wxListBox::ApplyWidgetStyle()
     if (m_backgroundColour.Ok())
     {
         GdkWindow *window = GTK_WIDGET(m_list)->window;
+        if ( window )
+        {
             m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
             gdk_window_set_background( window, m_backgroundColour.GetColor() );
             gdk_window_clear( window );
         }
+    }
 
     GList *child = m_list->children;
     while (child)

src/gtk1/mdi.cpp

@@ -90,14 +90,12 @@ void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
 
     wxMenuBar *menu_bar = child_frame->m_menuBar;
     if (!menu_bar) return;
-    if (!menu_bar->m_widget) return;
+    if (!menu_bar->GetHandle()) return;
 
-    menu_bar->m_x = 0;
+    menu_bar->InternalSetPosition(0, 0);
-    menu_bar->m_y = 0;
+    menu_bar->InternalSetSize(m_width, wxMENU_HEIGHT);
-    menu_bar->m_width = m_width;
-    menu_bar->m_height = wxMENU_HEIGHT;
     gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget), 
-                          menu_bar->m_widget, 
+                          menu_bar->GetHandle(), 
                           0, 0, m_width, wxMENU_HEIGHT );
 }
 
@@ -110,7 +108,7 @@ void wxMDIParentFrame::OnInternalIdle()
 
     if (m_justInserted)
     {
-        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
+        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
         gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 );
 
         m_justInserted = FALSE;
@@ -122,7 +120,7 @@ void wxMDIParentFrame::OnInternalIdle()
     wxMDIChildFrame *active_child_frame = GetActiveChild();
     bool visible_child_menu = FALSE;
 
-    wxNode *node = m_clientWindow->m_children.First();
+    wxNode *node = m_clientWindow->GetChildren().First();
     while (node)
     {
         wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -130,11 +128,11 @@ void wxMDIParentFrame::OnInternalIdle()
         {
             if (child_frame == active_child_frame)
             {
-               gtk_widget_show( child_frame->m_menuBar->m_widget );
+               gtk_widget_show( child_frame->m_menuBar->GetHandle() );
                visible_child_menu = TRUE;
             }
             else
-               gtk_widget_hide( child_frame->m_menuBar->m_widget );
+               gtk_widget_hide( child_frame->m_menuBar->GetHandle() );
         }
         node = node->Next();
     }
@@ -152,7 +150,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
 {
     if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
     if (!notebook) return (wxMDIChildFrame*) NULL;
 
 #if (GTK_MINOR_VERSION > 0)
@@ -165,7 +163,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
     GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
     if (!page) return (wxMDIChildFrame*) NULL;
 
-    wxNode *node = m_clientWindow->m_children.First();
+    wxNode *node = m_clientWindow->GetChildren().First();
     while (node)
     {
         wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -191,13 +189,13 @@ wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
 void wxMDIParentFrame::ActivateNext()
 {
     if (m_clientWindow)
-      gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
+      gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
 }
 
 void wxMDIParentFrame::ActivatePrevious()
 {
     if (m_clientWindow)
-      gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
+      gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
 }
 
 void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
@@ -279,9 +277,9 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
 
     if (m_menuBar)
     {
-        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
+        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
 
-       if (m_menuBar->m_parent != this)
+       if (m_menuBar->GetParent() != this)
        {
             wxNode *node = m_menuBar->GetMenus().First();
             while (node)
@@ -291,16 +289,16 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
                 node = node->Next();
             }
 
-            m_menuBar->m_parent = mdi_frame;
+            m_menuBar->SetParent( mdi_frame );
         }
 
         /* the menu bar of the child window is shown in idle time as needed */
-        gtk_widget_hide( m_menuBar->m_widget );
+        gtk_widget_hide( m_menuBar->GetHandle() );
 
         /* insert the invisible menu bar into the _parent_ mdi frame */
         gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget), 
-	                 m_menuBar->m_widget, 
+                         m_menuBar->GetHandle(), 
-			 0, 0,  mdi_frame->m_width, wxMENU_HEIGHT );
+                         0, 0,  mdi_frame->GetWidth(), wxMENU_HEIGHT );
     }
 }
 
@@ -325,11 +323,11 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    if ((win->m_x == alloc->x) &&
+    if ((win->GetX() == alloc->x) &&
-        (win->m_y == alloc->y) &&
+        (win->GetY() == alloc->y) &&
-        (win->m_width == alloc->width) &&
+        (win->GetWidth() == alloc->width) &&
-        (win->m_height == alloc->height) &&
+        (win->GetHeight() == alloc->height) &&
-        (win->m_sizeSet))
+        (win->IsSizeSet()))
     {
         return;
     }
@@ -349,16 +347,16 @@ static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* chil
     GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
     gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
 
-    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
+    gtk_signal_connect( GTK_OBJECT(child->GetHandle()), "size_allocate",
       GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetHandle());
 
-    gtk_notebook_append_page( notebook, child->m_widget, label_widget );
+    gtk_notebook_append_page( notebook, child->GetHandle(), label_widget );
 
     child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
 
-    wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->m_parent;
+    wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->GetParent();
     parent_frame->m_justInserted = TRUE;
 }
 
@@ -393,9 +391,7 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
 
     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -404,5 +400,3 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
     return TRUE;
 }
 
-
-

src/gtk1/minifram.cpp

@@ -73,23 +73,23 @@ static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
                      GTK_STATE_NORMAL,
                      GTK_SHADOW_OUT,
                      0, 0,
-		     win->m_width, win->m_height );
+                     win->GetWidth(), win->GetHeight() );
 
     if (!win->m_title.IsEmpty() &&
-        ((win->m_windowStyle & wxCAPTION) || 
+        ((win->GetWindowStyle() & wxCAPTION) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_HORIZ) || 
+         (win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_VERT)))
+         (win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
     {
         GdkGC *gc = gdk_gc_new( widget->window );
         GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
         int x = 2;
-	if (win->m_windowStyle & wxSYSTEM_MENU) x = 18;
+        if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
         
         gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
         gdk_draw_rectangle( widget->window, gc, TRUE, 
                             x, 
                             3, 
-			    win->m_width - 4 - x,
+                            win->GetWidth() - 4 - x,
                             font->ascent + font->descent+1 );
                             
         gdk_gc_set_foreground( gc, &widget->style->white );
@@ -117,23 +117,23 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
                      GTK_STATE_NORMAL,
                      GTK_SHADOW_OUT,
                      0, 0,
-		     win->m_width, win->m_height );
+                     win->GetWidth(), win->GetHeight() );
                      
     if (!win->m_title.IsEmpty() &&
-        ((win->m_windowStyle & wxCAPTION) || 
+        ((win->GetWindowStyle() & wxCAPTION) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_HORIZ) || 
+         (win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) || 
-	 (win->m_windowStyle & wxTINY_CAPTION_VERT)))
+         (win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
     {
         GdkGC *gc = gdk_gc_new( widget->window );
         GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
         int x = 2;
-	if (win->m_windowStyle & wxSYSTEM_MENU) x = 17;
+        if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
         
         gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
         gdk_draw_rectangle( widget->window, gc, TRUE, 
                             x, 
                             3, 
-			    win->m_width - 4 - x,
+                            win->GetWidth() - 4 - x,
                             font->ascent + font->descent+1 );
                             
         gdk_gc_set_foreground( gc, &widget->style->white );
@@ -174,7 +174,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
                      
     win->m_diffX = (int)gdk_event->x;
     win->m_diffY = (int)gdk_event->y;
-    DrawFrame( widget, 0, 0, win->m_width, win->m_height );
+    DrawFrame( widget, 0, 0, win->GetWidth(), win->GetHeight() );
     win->m_oldX = 0;
     win->m_oldY = 0;
     
@@ -202,16 +202,15 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     int x = (int)gdk_event->x;
     int y = (int)gdk_event->y;
     
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
     int org_x = 0;    
     int org_y = 0;
     gdk_window_get_origin( widget->window, &org_x, &org_y );
     x += org_x - win->m_diffX;
     y += org_y - win->m_diffY;
-    win->m_x = x;
+    win->InternalSetPosition(x, y);
-    win->m_y = y;
+    gtk_widget_set_uposition( win->GetWidget(), x, y );
-    gtk_widget_set_uposition( win->m_widget, x, y );
 
     return TRUE;
 }
@@ -241,10 +240,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
        gdk_event->state = state;
     }
 
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     win->m_oldX = (int)gdk_event->x - win->m_diffX;
     win->m_oldY = (int)gdk_event->y - win->m_diffY;
-    DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
+    DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
     
     return TRUE;
 }

src/gtk1/notebook.cpp

@@ -125,10 +125,10 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 {
     if (g_isIdle) wxapp_install_idle_handler();
     
-    if ((win->m_x == alloc->x) &&
+    if ((win->GetX() == alloc->x) &&
-        (win->m_y == alloc->y) &&
+        (win->GetY() == alloc->y) &&
-        (win->m_width == alloc->width) &&
+        (win->GetWidth() == alloc->width) &&
-        (win->m_height == alloc->height))
+        (win->GetHeight() == alloc->height))
     {
         return;
     }
@@ -188,16 +188,16 @@ static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
     page->m_box = gtk_hbox_new (FALSE, 0);
     gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
 
-    GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
+    GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetWidget());
 
     page->m_client = child;
-    gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
+    gtk_notebook_append_page( notebook, child->GetWidget(), page->m_box );
 
     page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
 
     page->m_parent = notebook;
 
-    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
+    gtk_signal_connect( GTK_OBJECT(child->GetWidget()), "size_allocate",
       GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
 
     wxASSERT_MSG( page->m_page, _T("Notebook page creation error") );
@@ -267,9 +267,7 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
                   GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
                   (gpointer)this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );

src/gtk1/radiobox.cpp

@@ -68,7 +68,7 @@ BEGIN_EVENT_TABLE(wxRadioBox, wxControl)
     EVT_SIZE(wxRadioBox::OnSize)
 END_EVENT_TABLE()
 
-wxRadioBox::wxRadioBox(void)
+wxRadioBox::wxRadioBox()
 {
 }
 
@@ -108,7 +108,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
         gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
            GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
 
-        gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow), 
+        gtk_myfixed_put( GTK_MYFIXED(m_parent->GetWxWindow()), 
                          GTK_WIDGET(m_radio), 
                          m_x+10, m_y+10+(i*24), 10, 10 );
     }
@@ -120,9 +120,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
     if (newSize.y == -1) newSize.y = ls.y;
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -137,7 +135,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
     return TRUE;
 }
 
-wxRadioBox::~wxRadioBox(void)
+wxRadioBox::~wxRadioBox()
 {
     wxNode *node = m_boxes.First();
     while (node)
@@ -150,9 +148,9 @@ wxRadioBox::~wxRadioBox(void)
 
 void wxRadioBox::OnSize( wxSizeEvent &event )
 {
-    wxControl::OnSize( event );
-
     LayoutItems();
+
+    event.Skip();
 }
 
 wxSize wxRadioBox::LayoutItems()
@@ -181,7 +179,7 @@ wxSize wxRadioBox::LayoutItems()
                 int len = 22+gdk_string_measure( font, label->label );
                 if (len > max_len) max_len = len;
 
-                gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
+                gtk_myfixed_move( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y );
                 y += 20;
 
                 node = node->Next();
@@ -195,7 +193,7 @@ wxSize wxRadioBox::LayoutItems()
             {
                 GtkWidget *button = GTK_WIDGET( node->Data() );
 
-                gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
+                gtk_myfixed_resize( GTK_MYFIXED(m_parent->GetWxWindow()), button, max_len, 20 );
 
                 node = node->Next();
                 if (!node) break;
@@ -231,7 +229,7 @@ wxSize wxRadioBox::LayoutItems()
         {
             GtkWidget *button = GTK_WIDGET( node->Data() );
 
-            gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
+            gtk_myfixed_set_size( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y, max, 20 );
             x += max;
 
             node = node->Next();
@@ -389,9 +387,10 @@ void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
     wxFAIL_MSG(_T("wxRadioBox::SetLabel not implemented."));
 }
 
-void wxRadioBox::Enable( bool enable )
+bool wxRadioBox::Enable( bool enable )
 {
-    wxControl::Enable( enable );
+    if ( !wxControl::Enable( enable ) )
+        return FALSE;
 
     wxNode *node = m_boxes.First();
     while (node)
@@ -402,6 +401,8 @@ void wxRadioBox::Enable( bool enable )
         gtk_widget_set_sensitive( label, enable );
         node = node->Next();
     }
+
+    return TRUE;
 }
 
 void wxRadioBox::Enable( int item, bool enable )

src/gtk1/radiobut.cpp

@@ -91,9 +91,7 @@ bool wxRadioButton::Create( wxWindow *parent, wxWindowID id, const wxString& lab
     gtk_signal_connect( GTK_OBJECT(m_widget), "clicked", 
       GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
        
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 
@@ -138,13 +136,14 @@ bool wxRadioButton::GetValue(void) const
     return GTK_TOGGLE_BUTTON(m_widget)->active;
 }
 
-void wxRadioButton::Enable( bool enable )
+bool wxRadioButton::Enable( bool enable )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid radiobutton") );
+    if ( !wxControl::Enable( enable ) )
-  
+        return FALSE;
-    wxControl::Enable( enable );
   
     gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
+
+    return TRUE;
 }
 
 void wxRadioButton::ApplyWidgetStyle()

src/gtk1/scrolbar.cpp

@@ -53,7 +53,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
     float line_step = win->m_adjust->step_increment;
     float page_step = win->m_adjust->page_increment;
   
-    if (win->m_isScrolling)
+    if (win->IsScrolling())
     {
         command = wxEVT_SCROLL_THUMBTRACK;
     }
@@ -70,8 +70,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
 
     int value = (int)(win->m_adjust->value+0.5);
       
-    int orient = wxHORIZONTAL;
+    int orient = win->HasFlag(wxSB_VERTICAL) ? wxVERTICAL : wxHORIZONTAL;
-    if (win->GetWindowStyleFlag() & wxSB_VERTICAL == wxSB_VERTICAL) orient = wxVERTICAL;
   
     wxScrollEvent event( command, win->GetId(), value, orient );
     event.SetEventObject( win );
@@ -94,7 +93,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    win->m_isScrolling = TRUE;
+    win->SetScrolling(TRUE);
 //  g_blockEventsOnScroll = TRUE;  doesn't work in DialogEd
   
     return FALSE;
@@ -110,7 +109,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    win->m_isScrolling = FALSE;
+    win->SetScrolling(FALSE);
 //  g_blockEventsOnScroll = FALSE;
   
     gtk_signal_emit_by_name( GTK_OBJECT(win->m_adjust), "value_changed" );
@@ -163,9 +162,7 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
                         (GtkSignalFunc)gtk_scrollbar_button_release_callback, 
                         (gpointer) this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk1/slider.cpp

@@ -144,9 +144,7 @@ bool wxSlider::Create(wxWindow *parent, wxWindowID id,
     SetRange( minValue, maxValue );
     SetValue( value );
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk1/spinbutt.cpp

@@ -111,9 +111,7 @@ bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, c
                         (GtkSignalFunc) gtk_spinbutt_callback,
                         (gpointer) this );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk1/statbmp.cpp

@@ -60,9 +60,7 @@ bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
         m_widget = gtk_label_new( "Bitmap" );
     }
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk1/statbox.cpp

@@ -45,9 +45,7 @@ bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label
     
     m_widget = gtk_frame_new(m_label.mbc_str());
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 

src/gtk1/statline.cpp

@@ -46,9 +46,7 @@ bool wxStaticLine::Create( wxWindow *parent, wxWindowID id,
     else
         m_widget = gtk_hseparator_new();
   
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
   

src/gtk1/stattext.cpp

@@ -76,9 +76,7 @@ bool wxStaticText::Create(wxWindow *parent,
 
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 

src/gtk1/tbargtk.cpp

@@ -209,9 +209,7 @@ bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
     m_xMargin = 0;
     m_yMargin = 0;
     
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
   
     PostCreation();
 

src/gtk1/textctrl.cpp

@@ -46,11 +46,11 @@ gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
 {
     if (g_isIdle) wxapp_install_idle_handler();
 
-    if (!win->m_hasVMT) return;
+    if (!win->HasVMT()) return;
 
     win->SetModified();
 
-    wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
+    wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
     event.SetString( win->GetValue() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
@@ -67,7 +67,7 @@ gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
 
     win->CalculateScrollbar();
     
-    if (!win->m_hasVMT) return;
+    if (!win->HasVMT()) return;
 }
 
 //-----------------------------------------------------------------------------
@@ -152,7 +152,6 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
         /* ... and put into the upper left hand corner of the table */
         m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
         GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-
         gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
@@ -160,13 +159,11 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
 
         /* always wrap words */
         gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
-
         /* put the horizontal scrollbar in the lower left hand corner */
         if (bHasHScrollbar)
         {
             GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
             GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
-
             gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
                        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
                        GTK_FILL,
@@ -178,11 +175,9 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
             gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
 #endif
         }
-
         /* finally, put the vertical scrollbar in the upper right corner */
         m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
         GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
-
         gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
                      GTK_FILL,
                      (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
@@ -200,9 +195,7 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
     if (newSize.y == -1) newSize.y = 26;
     SetSize( newSize.x, newSize.y );
 
-    m_parent->AddChild( this );
+    m_parent->DoAddChild( this );
-
-    (m_parent->m_insertCallback)( m_parent, this );
 
     PostCreation();
 
@@ -948,46 +941,53 @@ bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
         return (window == GTK_ENTRY(m_text)->text_area);
 }
 
-void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
+bool wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     // doesn't work
+    return FALSE;
 }
 
-void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
+bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     // doesn't work
+    return FALSE;
 }
 
-void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
+bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
 {
-    wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
+    wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
 
     wxControl::SetBackgroundColour( colour );
 
-    if (!m_widget->window) return;
+    if (!m_widget->window)
+        return FALSE;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (sysbg.Red() == colour.Red() &&
         sysbg.Green() == colour.Green() &&
         sysbg.Blue() == colour.Blue())
     {
-        return;
+        return FALSE; // FIXME or TRUE?
     }
 
-    if (!m_backgroundColour.Ok()) return;
+    if (!m_backgroundColour.Ok())
+        return FALSE;
 
     if (m_windowStyle & wxTE_MULTILINE)
     {
         GdkWindow *window = GTK_TEXT(m_text)->text_area;
-        if (!window) return;
+        if (!window)
+            return FALSE;
         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
         gdk_window_set_background( window, m_backgroundColour.GetColor() );
         gdk_window_clear( window );
     }
+
+    return TRUE;
 }
 
 void wxTextCtrl::ApplyWidgetStyle()

src/gtk1/treectrl.cpp

@@ -133,9 +133,7 @@ printf("5\n");
   SetValidator(validator);
 
 printf("Robert's new insertion code :-)\n");
-  m_parent->AddChild( this );
+  m_parent->DoAddChild( this );
-  (m_parent->m_insertCallback)( m_parent, this );
-
 printf("postcreate\n");
   PostCreation();