]> git.saurik.com Git - wxWidgets.git/commitdiff
1. wxWindow::IsTopLevel() added and documented
authorVadim Zeitlin <vadim@wxwidgets.org>
Mon, 7 Jun 1999 18:26:42 +0000 (18:26 +0000)
committerVadim Zeitlin <vadim@wxwidgets.org>
Mon, 7 Jun 1999 18:26:42 +0000 (18:26 +0000)
2. wxDynamicClass() added and documented
3. first Motif fixes (doesn't compile yet)

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

13 files changed:
docs/latex/wx/function.tex
docs/latex/wx/truntime.tex
docs/latex/wx/window.tex
include/wx/defs.h
include/wx/motif/private.h
include/wx/motif/toolbar.h
include/wx/motif/window.h
include/wx/msw/window.h
include/wx/object.h
include/wx/window.h
src/common/wincmn.cpp
src/motif/window.cpp
src/msw/window.cpp

index 72167440743bb0dd3b66650abdf48ff188ac6970..6bf8961e4746ccc7468cfd339729e7b73b2c48bf 100644 (file)
@@ -1596,23 +1596,6 @@ Returns a pointer to the wxClassInfo object associated with this class.
 
 <wx/object.h>
 
 
 <wx/object.h>
 
-\membersection{WXDEBUG\_NEW}\label{debugnew}
-
-\func{}{WXDEBUG\_NEW}{arg}
-
-This is defined in debug mode to be call the redefined new operator
-with filename and line number arguments. The definition is:
-
-\begin{verbatim}
-#define WXDEBUG_NEW new(__FILE__,__LINE__)
-\end{verbatim}
-
-In non-debug mode, this is defined as the normal new operator.
-
-\wxheading{Include files}
-
-<wx/object.h>
-
 \membersection{DECLARE\_ABSTRACT\_CLASS}
 
 \func{}{DECLARE\_ABSTRACT\_CLASS}{className}
 \membersection{DECLARE\_ABSTRACT\_CLASS}
 
 \func{}{DECLARE\_ABSTRACT\_CLASS}{className}
@@ -1810,8 +1793,59 @@ base classes.
 
 <wx/object.h>
 
 
 <wx/object.h>
 
+\membersection{WXDEBUG\_NEW}\label{debugnew}
+
+\func{}{WXDEBUG\_NEW}{arg}
+
+This is defined in debug mode to be call the redefined new operator
+with filename and line number arguments. The definition is:
+
+\begin{verbatim}
+#define WXDEBUG_NEW new(__FILE__,__LINE__)
+\end{verbatim}
+
+In non-debug mode, this is defined as the normal new operator.
+
+\wxheading{Include files}
+
+<wx/object.h>
+
+\membersection{wxDynamicCast}\label{wxdynamiccast}
+
+\func{}{wxDynamicCast}{ptr, classname}
+
+This macro returns the pointer {\it ptr} cast to the type {\it classname *} if
+the pointer is of this type (the check is done during the run-time) or NULL
+otherwise. Usage of this macro is prefered over obsoleted wxObject::IsKindOf()
+function.
+
+The {\it ptr} argument may be NULL, in which case NULL will be returned.
+
+Example:
+
+\begin{verbatim}
+    wxWindow *win = wxWindow::FindFocus();
+    wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
+    if ( text )
+    {
+        // a text control has the focus...
+    }
+    else
+    {
+        // no window has the focus or it's not a text control
+    }
+\end{verbatim}
+
+\wxheading{See also}
+
+\helpref{RTTI overview}{runtimeclassoverview}
+
 \membersection{WXTRACE}\label{trace}
 
 \membersection{WXTRACE}\label{trace}
 
+\wxheading{Include files}
+
+<wx/object.h>
+
 \func{}{WXTRACE}{formatString, ...}
 
 Calls wxTrace with printf-style variable argument syntax. Output
 \func{}{WXTRACE}{formatString, ...}
 
 Calls wxTrace with printf-style variable argument syntax. Output
index b6c9e8e746d9f46341b33a6ee3171edb05b745ce..df443465ea1e16b8ff181a7f51bd67b1d8f82ff9 100644 (file)
@@ -2,13 +2,25 @@
 
 Classes: \helpref{wxObject}{wxobject}, \helpref{wxClassInfo}{wxclassinfo}.
 
 
 Classes: \helpref{wxObject}{wxobject}, \helpref{wxClassInfo}{wxclassinfo}.
 
-One of the failings of C++ is that no run-time information is provided
+One of the failings of C++ used to be that no run-time information was provided
 about a class and its position in the inheritance hierarchy.
 about a class and its position in the inheritance hierarchy.
-Another is that instances of a class cannot be created just by knowing the name of a class,
-which makes facilities such as persistent storage hard to implement.
+Another, which still persists, is that instances of a class cannot be created
+just by knowing the name of a class, which makes facilities such as persistent
+storage hard to implement.
 
 Most C++ GUI frameworks overcome these limitations by means of a set of
 
 Most C++ GUI frameworks overcome these limitations by means of a set of
-macros and functions and wxWindows is no exception.
+macros and functions and wxWindows is no exception. As it originated before the
+addition of RTTI to the standard C++ and as support for it still missing from
+some (albeit old) compilers, wxWindows doesn't (yet) use it, but provides its
+own macro-based RTTI system.
+
+In the future, the standard C++ RTTI will be used though and you're encouraged
+to use whenever possible \helpref{wxDynamicCast()}{wxdynamiccast} macro which,
+for the implementations that support it, is defined just as dynamic\_cast<> and
+uses wxWindows RTTI for all the others. This macro is limited to wxWindows
+classes only and only works with pointers (unlike the real dynamic\_cast<> which
+also accepts referencies).
+
 Each class that you wish to be known the type system should have
 a macro such as DECLARE\_DYNAMIC\_CLASS just inside the class declaration.
 The macro IMPLEMENT\_DYNAMIC\_CLASS should be in the implementation file.
 Each class that you wish to be known the type system should have
 a macro such as DECLARE\_DYNAMIC\_CLASS just inside the class declaration.
 The macro IMPLEMENT\_DYNAMIC\_CLASS should be in the implementation file.
@@ -31,9 +43,9 @@ dynamic object of the class in question. A pointer to this function is
 stored in wxClassInfo, and is used when an object should be created
 dynamically.
 
 stored in wxClassInfo, and is used when an object should be created
 dynamically.
 
-wxObject::IsKindOf uses the linked list of wxClassInfo. It takes
-a wxClassInfo argument, so use CLASSINFO(className) to return an
-appropriate wxClassInfo pointer to use in this function.
+\helpref{wxObject::IsKindOf}{wxobjectiskindof} uses the linked list of
+wxClassInfo. It takes a wxClassInfo argument, so use CLASSINFO(className)
+to return an appropriate wxClassInfo pointer to use in this function.
 
 The function \helpref{wxCreateDynamicObject}{wxcreatedynamicobject} can be used
 to construct a new object of a given type, by supplying a string name.
 
 The function \helpref{wxCreateDynamicObject}{wxcreatedynamicobject} can be used
 to construct a new object of a given type, by supplying a string name.
@@ -68,26 +80,27 @@ See also \helpref{wxObject}{wxobject} and \helpref{wxCreateDynamicObject}{wxcrea
 
 \subsection{Example}
 
 
 \subsection{Example}
 
-In a header file wx\_frame.h:
+In a header file frame.h:
 
 \begin{verbatim}
 
 \begin{verbatim}
-class wxFrame: public wxWindow
+class wxFrame : public wxWindow
 {
 {
-  DECLARE_DYNAMIC_CLASS(wxFrame)
+DECLARE_DYNAMIC_CLASS(wxFrame)
+
+private:
+    wxString m_title;
 
 
- private:
-  char *frameTitle;
- public:
-  ...
+public:
+    ...
 };
 \end{verbatim}
 
 };
 \end{verbatim}
 
-In a C++ file wx\_frame.cc:
+In a C++ file frame.cpp:
 
 \begin{verbatim}
 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
 
 
 \begin{verbatim}
 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
 
-wxFrame::wxFrame(void)
+wxFrame::wxFrame()
 {
 ...
 }
 {
 ...
 }
index 5c4410bfb2489bcb485562c34baab93dbd40e803..32d23e45ec807fd213b636a77d9e0bc19eb790e1 100644 (file)
@@ -253,9 +253,9 @@ implements the following methods:\par
 
 Additionally, the following helper functions are defined:\par
 \indented{2cm}{\begin{twocollist}
 
 Additionally, the following helper functions are defined:\par
 \indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{wxDLG_PNT(win, point)}}{Converts a wxPoint from dialog
+\twocolitem{\bf{wxDLG\_PNT(win, point)}}{Converts a wxPoint from dialog
 units to pixels}
 units to pixels}
-\twocolitem{\bf{wxDLG_SZE(win, size)}}{Converts a wxSize from dialog
+\twocolitem{\bf{wxDLG\_SZE(win, size)}}{Converts a wxSize from dialog
 units to pixels}
 \end{twocollist}}
 }
 units to pixels}
 \end{twocollist}}
 }
@@ -757,6 +757,14 @@ Retained windows are only available on X platforms.
 
 Returns TRUE if the window is shown, FALSE if it has been hidden.
 
 
 Returns TRUE if the window is shown, FALSE if it has been hidden.
 
+\membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
+
+\constfunc{bool}{IsTopLevel}{\void}
+
+Returns TRUE if the given window is a top-level one. Currently all frames and
+dialogs are considered to be top-level windows (even if they have a parent
+window).
+
 \membersection{wxWindow::Layout}\label{wxwindowlayout}
 
 \func{void}{Layout}{\void}
 \membersection{wxWindow::Layout}\label{wxwindowlayout}
 
 \func{void}{Layout}{\void}
index 58e4c51cc43528ed09742cdc4a684d96be6a7cdc..0f823ffd1143d432a397f6b82a4b8ded11cc5eea 100644 (file)
@@ -523,9 +523,13 @@ typedef  wxUint16        wxWord;
 #define wxWANTS_CHARS       0x00040000
 
 // Orientations
 #define wxWANTS_CHARS       0x00040000
 
 // Orientations
-#define wxHORIZONTAL     0x01
-#define wxVERTICAL       0x02
-#define wxBOTH           (wxVERTICAL|wxHORIZONTAL)
+enum wxOrientation
+{
+    wxHORIZONTAL = 0x01,
+    wxVERTICAL   = 0x02,
+    wxBOTH       = (wxVERTICAL | wxHORIZONTAL)
+};
+
 #define wxCENTER_FRAME   0x04  /* centering into frame rather than screen */
 
 /*
 #define wxCENTER_FRAME   0x04  /* centering into frame rather than screen */
 
 /*
index 0a974d01a5e2ecdd4de4e666f7171db2662c83e8..f8dbeba90dc2ed5115320a9307bf07e3229dd246 100644 (file)
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        private.h
 /////////////////////////////////////////////////////////////////////////////
 // Name:        private.h
-// Purpose:     Private declarations
+// Purpose:     Private declarations for wxMotif port
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:    wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_PRIVATE_H_
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_PRIVATE_H_
 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 
-class WXDLLEXPORT wxMouseEvent;
-class WXDLLEXPORT wxKeyEvent;
+class wxMouseEvent;
+class wxKeyEvent;
 
 
-/* Put any private declarations here.
- */
+// Put any private declarations here: native Motif types may be used because
+// this header is included after Xm/Xm.h
 
 
+// ----------------------------------------------------------------------------
+// common callbacks
+// ----------------------------------------------------------------------------
+
+// All widgets should have this as their resize proc.
 extern void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args);
 
 extern void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args);
 
-extern wxHashTable *wxWidgetHashTable;
+// For repainting arbitrary windows
+void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *);
+
+// ----------------------------------------------------------------------------
+// we maintain a hash table which contains the mapping from Widget to wxWindow
+// corresponding to the window for this widget
+// ----------------------------------------------------------------------------
+
 extern void wxDeleteWindowFromTable(Widget w);
 extern wxWindow *wxGetWindowFromTable(Widget w);
 extern bool wxAddWindowToTable(Widget w, wxWindow *win);
 extern void wxDeleteWindowFromTable(Widget w);
 extern wxWindow *wxGetWindowFromTable(Widget w);
 extern bool wxAddWindowToTable(Widget w, wxWindow *win);
+
 extern char wxFindMnemonic(const char* s);
 extern char * wxFindAccelerator (char *s);
 extern XmString wxFindAcceleratorText (char *s);
 extern int wxCharCodeXToWX(KeySym keySym);
 extern KeySym wxCharCodeWXToX(int id);
 extern char wxFindMnemonic(const char* s);
 extern char * wxFindAccelerator (char *s);
 extern XmString wxFindAcceleratorText (char *s);
 extern int wxCharCodeXToWX(KeySym keySym);
 extern KeySym wxCharCodeWXToX(int id);
-bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent);
-bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent);
+
+// ----------------------------------------------------------------------------
+// TranslateXXXEvent() functions - translate Motif event to wxWindow one
+// ----------------------------------------------------------------------------
+extern bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent);
+extern bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent);
+
 int wxGetBestMatchingPixel(Display *display, XColor *desiredColor, Colormap cmap);
 Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap );
 int wxGetBestMatchingPixel(Display *display, XColor *desiredColor, Colormap cmap);
 Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap );
+
 extern XColor g_itemColors[];
 extern int wxComputeColours (Display *display, wxColour * back, wxColour * fore);
 
 extern void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour);
 extern void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
 
 extern XColor g_itemColors[];
 extern int wxComputeColours (Display *display, wxColour * back, wxColour * fore);
 
 extern void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour);
 extern void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
 
-// For repainting arbitrary windows
-void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *);
-
-#define        wxNO_COLORS   0x00
+#define wxNO_COLORS   0x00
 #define wxBACK_COLORS 0x01
 #define wxFORE_COLORS 0x02
 
 #define wxBACK_COLORS 0x01
 #define wxFORE_COLORS 0x02
 
index f93c142d219564883c2ee9390cd233df7221bfcc..5b26b9357ab22d9a399f568e6cfa6cfc97a3a4ef 100644 (file)
@@ -64,7 +64,7 @@ class WXDLLEXPORT wxToolBar: public wxToolBarBase
 
   // Add all the buttons
   virtual bool CreateTools();
 
   // Add all the buttons
   virtual bool CreateTools();
-  virtual void Layout() {}
+  virtual void LayoutTools() {}
 
   // The post-tool-addition call. TODO: do here whatever's
   // necessary for completing the toolbar construction.
 
   // The post-tool-addition call. TODO: do here whatever's
   // necessary for completing the toolbar construction.
index b90689159437a55c742e6c475a80985285b0a983..10e64022599064d9f277aa1f0d6746a86a23adf4 100644 (file)
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:    wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
 #ifdef __GNUG__
-#pragma interface "window.h"
+    #pragma interface "window.h"
 #endif
 
 #endif
 
-#include "wx/gdicmn.h"
-#include "wx/icon.h"
-#include "wx/cursor.h"
-#include "wx/pen.h"
-#include "wx/font.h"
-#include "wx/validate.h"
-#include "wx/event.h"
-#include "wx/string.h"
-#include "wx/list.h"
-#include "wx/region.h"
-#include "wx/accel.h"
-#include "wx/intl.h"
-
-#define wxKEY_SHIFT     1
-#define wxKEY_CTRL      2
-
-/*
- * Base class for frame, panel, canvas, panel items, dialog box.
- *
- */
-
-/*
- * Event handler: windows have themselves as their event handlers
- * by default, but their event handlers could be set to another
- * object entirely. This separation can reduce the amount of
- * derivation required, and allow alteration of a window's functionality
- * (e.g. by a resource editor that temporarily switches event handlers).
- */
-
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxEvent;
-class WXDLLEXPORT wxCommandEvent;
-class WXDLLEXPORT wxKeyEvent;
-class WXDLLEXPORT wxControl;
-class WXDLLEXPORT wxCursor;
-class WXDLLEXPORT wxColourMap;
-class WXDLLEXPORT wxFont;
-class WXDLLEXPORT wxMenu;
-class WXDLLEXPORT wxRect;
-class WXDLLEXPORT wxBitmap;
-class WXDLLEXPORT wxSizer;
-class WXDLLEXPORT wxList;
-class WXDLLEXPORT wxLayoutConstraints;
-class WXDLLEXPORT wxMouseEvent;
-class WXDLLEXPORT wxButton;
-class WXDLLEXPORT wxColour;
-class WXDLLEXPORT wxBrush;
-class WXDLLEXPORT wxPen;
-class WXDLLEXPORT wxIcon;
-class WXDLLEXPORT wxDC;
-class WXDLLEXPORT wxValidator;
+// ----------------------------------------------------------------------------
+// wxWindow class for Motif - see also wxWindowBase
+// ----------------------------------------------------------------------------
 
 
-#if wxUSE_DRAG_AND_DROP
-class WXDLLEXPORT wxDropTarget;
-#endif
-
-#if wxUSE_WX_RESOURCES
-class WXDLLEXPORT wxResourceTable;
-class WXDLLEXPORT wxItemResource;
-#endif
-
-WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr;
-
-WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
-WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
-
-//-----------------------------------------------------------------------------
-// wxClientData
-//-----------------------------------------------------------------------------
-
-class wxClientData
-{
-public:
-    wxClientData() { }
-    virtual ~wxClientData() { }
-};
-
-//-----------------------------------------------------------------------------
-// wxStringClientData
-//-----------------------------------------------------------------------------
-
-class wxStringClientData: public wxClientData
-{
-public:
-    wxStringClientData() { }
-    wxStringClientData( wxString &data ) { m_data = data; }
-    void SetData( wxString &data ) { m_data = data; }
-    wxString GetData() const { return m_data; }
-    
-private:
-    wxString  m_data;
-};
-
-class WXDLLEXPORT wxWindow : public wxEvtHandler
+class wxWindow : public wxWindowBase
 {
 {
-    DECLARE_ABSTRACT_CLASS(wxWindow)
+DECLARE_DYNAMIC_CLASS(wxWindow)
 
 
-    friend class WXDLLEXPORT wxDC;
-    friend class WXDLLEXPORT wxWindowDC;
+friend class WXDLLEXPORT wxDC;
+friend class WXDLLEXPORT wxWindowDC;
 
 public:
 
 public:
-    wxWindow();
-    wxWindow(wxWindow *parent, wxWindowID id,
-            const wxPoint& pos = wxDefaultPosition,
-            const wxSize& size = wxDefaultSize,
-            long style = 0,
-            const wxString& name = wxPanelNameStr)
+    wxWindow() { Init(); }
+
+    wxWindow(wxWindow *parent,
+             wxWindowID id,
+             const wxPoint& pos = wxDefaultPosition,
+             const wxSize& size = wxDefaultSize,
+             long style = 0,
+             const wxString& name = wxPanelNameStr)
     {
     {
-        m_children = new wxList;
+        Init();
         Create(parent, id, pos, size, style, name);
     }
 
     virtual ~wxWindow();
 
         Create(parent, id, pos, size, style, name);
     }
 
     virtual ~wxWindow();
 
-    bool Create(wxWindow *parent, wxWindowID id,
-            const wxPoint& pos = wxDefaultPosition,
-            const wxSize& size = wxDefaultSize,
-            long style = 0,
-            const wxString& name = wxPanelNameStr);
-
-    // Fit the window around the items
-    virtual void Fit();
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxString& name = wxPanelNameStr);
 
 
-    // Show or hide the window
-    virtual bool Show(bool show);
+    // implement base class pure virtuals
+    virtual void SetTitle( const wxString& title);
+    virtual wxString GetTitle() const;
 
 
-    // Is the window shown?
-    virtual bool IsShown() const;
-
-    // Raise the window to the top of the Z order
     virtual void Raise();
     virtual void Raise();
-
-    // Lower the window to the bottom of the Z order
     virtual void Lower();
 
     virtual void Lower();
 
-    // Is the window enabled?
-    virtual bool IsEnabled() const;
-
-    // For compatibility
-    bool Enabled() const { return IsEnabled(); }
-
-    // Dialog support: override these and call
-    // base class members to add functionality
-    // that can't be done using validators.
+    virtual bool Show( bool show = TRUE );
+    virtual bool Enable( bool enable = TRUE );
 
 
-    // Transfer values to controls. If returns FALSE,
-    // it's an application error (pops up a dialog)
-    virtual bool TransferDataToWindow();
-
-    // Transfer values from controls. If returns FALSE,
-    // transfer failed: don't quit
-    virtual bool TransferDataFromWindow();
-
-    // Validate controls. If returns FALSE,
-    // validation failed: don't quit
-    virtual bool Validate();
+    virtual void SetFocus();
 
 
-    // Return code for dialogs
-    inline void SetReturnCode(int retCode);
-    inline int GetReturnCode();
+    virtual void WarpPointer(int x, int y);
+    virtual void CaptureMouse();
+    virtual void ReleaseMouse();
 
 
-    // Set the cursor
-    virtual void SetCursor(const wxCursor& cursor);
-    virtual wxCursor *GetCursor() const { return (wxCursor *)& m_windowCursor; };
+    virtual void Refresh( bool eraseBackground = TRUE,
+                          const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
 
 
-    // Get the window with the focus
-    static wxWindow *FindFocus();
+    virtual bool SetCursor( const wxCursor &cursor );
+    virtual bool SetFont( const wxFont &font );
 
 
-    // Get character size
     virtual int GetCharHeight() const;
     virtual int GetCharWidth() const;
     virtual int GetCharHeight() const;
     virtual int GetCharWidth() const;
-
-    // moving/resizing
-    // ---------------
-
-        // set the window size and/or position
-    void SetSize( int x, int y, int width, int height,
-                  int sizeFlags = wxSIZE_AUTO )
-        {  DoSetSize(x, y, width, height, sizeFlags); }
-
-    void SetSize( int width, int height )
-        { DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
-
-    void SetSize( const wxSize& size )
-        { SetSize( size.x, size.y); }
-
-    void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
-        { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
-
-    void Move( int x, int y )
-        { DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); }
-
-    void Move(const wxPoint& pt)
-        { Move(pt.x, pt.y); }
-
-        // client size is the size of area available for subwindows
-    void SetClientSize( int width, int height )
-        { DoSetClientSize(width, height); }
-
-    void SetClientSize( const wxSize& size )
-        { DoSetClientSize(size.x, size.y); }
-
-    void SetClientSize(const wxRect& rect)
-        { SetClientSize( rect.width, rect.height ); }
-
-        // get the window position and/or size
-    virtual void GetPosition( int *x, int *y ) const;
-    wxPoint GetPosition() const
-    {
-        int w, h;
-        GetPosition(& w, & h);
-
-        return wxPoint(w, h);
-    }
-
-    virtual void GetSize( int *width, int *height ) const;
-
-    wxSize GetSize() const
-    {
-        int w, h;
-        GetSize(& w, & h);
-        return wxSize(w, h);
-    }
-
-    wxRect GetRect() const
-    {
-        int x, y, w, h;
-        GetPosition(& x, & y);
-        GetSize(& w, & h);
-
-        return wxRect(x, y, w, h);
-    }
-
-    virtual void GetClientSize( int *width, int *height ) const;
-    wxSize GetClientSize() const
-    {
-        int w, h;
-        GetClientSize(& w, & h);
-        return wxSize(w, h);
-    }
-
-    // Convert client to screen coordinates
-    virtual void ClientToScreen(int *x, int *y) const;
-    virtual wxPoint ClientToScreen(const wxPoint& pt) const
-    { int x = pt.x; int y = pt.y; ClientToScreen(& x, & y); return wxPoint(x, y); }
-
-    // Convert screen to client coordinates
-    virtual void ScreenToClient(int *x, int *y) const;
-    virtual wxPoint ScreenToClient(const wxPoint& pt) const
-    { int x = pt.x; int y = pt.y; ScreenToClient(& x, & y); return wxPoint(x, y); }
-
-    // Set the focus to this window
-    virtual void SetFocus();
-
-    // Capture/release mouse
-    virtual void CaptureMouse();
-    virtual void ReleaseMouse();
-
-    // Enable or disable the window
-    virtual void Enable(bool enable);
+    virtual void GetTextExtent(const wxString& string,
+                               int *x, int *y,
+                               int *descent = (int *) NULL,
+                               int *externalLeading = (int *) NULL,
+                               const wxFont *theFont = (const wxFont *) NULL)
+                               const;
+
+    virtual bool PopupMenu( wxMenu *menu, int x, int y );
+
+    virtual void SetScrollbar( int orient, int pos, int thumbVisible,
+                               int range, bool refresh = TRUE );
+    virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
+    virtual int GetScrollPos( int orient ) const;
+    virtual int GetScrollThumb( int orient ) const;
+    virtual int GetScrollRange( int orient ) const;
+    virtual void ScrollWindow( int dx, int dy,
+                               const wxRect* rect = (wxRect *) NULL );
 
 #if wxUSE_DRAG_AND_DROP
 
 #if wxUSE_DRAG_AND_DROP
-    // Associate a drop target with this window (if the window already had a drop
-    // target, it's deleted!) and return the current drop target (may be NULL).
-    void          SetDropTarget(wxDropTarget *pDropTarget);
-    wxDropTarget *GetDropTarget() const { return m_pDropTarget; }
-#endif
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
+#endif // wxUSE_DRAG_AND_DROP
 
     // Accept files for dragging
     virtual void DragAcceptFiles(bool accept);
 
 
     // Accept files for dragging
     virtual void DragAcceptFiles(bool accept);
 
-    // tooltips
-    // create a tooltip with this text
-    void SetToolTip(const wxString& tip);
-
-    // TODO
-#if wxUSE_TOOLTIPS
-    // pointer may be NULL to remove the tooltip
-    void SetToolTip(wxToolTip *tooltip);
-    // get the current tooltip (may return NULL if none)
-    wxToolTip* GetToolTip() const { return m_tooltip; }
-#endif
-
-    // Update region access
-    virtual wxRegion& GetUpdateRegion() const;
-    virtual bool IsExposed(int x, int y, int w, int h) const;
-    virtual bool IsExposed(const wxPoint& pt) const;
-    virtual bool IsExposed(const wxRect& rect) const;
-
-    // Set/get the window title
-    virtual void SetTitle(const wxString& WXUNUSED(title)) {};
-    virtual wxString GetTitle() const { return wxString(""); };
-    // Most windows have the concept of a label; for frames, this is the
-    // title; for items, this is the label or button text.
-    virtual wxString GetLabel() const { return GetTitle(); }
-
-    // Set/get the window name (used for resource setting in X)
-    virtual wxString GetName() const;
-    virtual void SetName(const wxString& name);
-
-    // Centre the window
-    virtual void Centre(int direction) ;
-    void Center(int direction = wxHORIZONTAL) { Centre(direction); }
-
-    // Popup a menu
-    virtual bool PopupMenu(wxMenu *menu, int x, int y);
-
-    // Send the window a refresh event
-    virtual void Refresh(bool eraseBack = TRUE, const wxRect *rect = NULL);
-
-    // New functions that will replace the above.
-    virtual void SetScrollbar(int orient, int pos, int thumbVisible,
-            int range, bool refresh = TRUE);
-
-    // Helper functions for Motif
-    void CreateScrollbar(int orientation);
-    void DestroyScrollbar(int orientation);
-
-    virtual void SetScrollPos(int orient, int pos, bool refresh = TRUE);
-    virtual int GetScrollPos(int orient) const;
-    virtual int GetScrollRange(int orient) const;
-    virtual int GetScrollThumb(int orient) const;
-
-    virtual void ScrollWindow(int dx, int dy, const wxRect *rect = NULL);
-
-    // Caret manipulation
-    virtual void CreateCaret(int w, int h);
-    virtual void CreateCaret(const wxBitmap *bitmap);
-    virtual void DestroyCaret();
-    virtual void ShowCaret(bool show);
-    virtual void SetCaretPos(int x, int y);
-    virtual void GetCaretPos(int *x, int *y) const;
-
-    // Tell window how much it can be sized
-    virtual void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1);
-
-    // Set/get the window's identifier
-    inline int GetId() const;
-    inline void SetId(int id);
-
-    virtual void SetAcceleratorTable(const wxAcceleratorTable& accel);
-    virtual wxAcceleratorTable& GetAcceleratorTable() const { return (wxAcceleratorTable&) m_acceleratorTable; }
-
-    // Make the window modal (all other windows unresponsive)
-    virtual void MakeModal(bool modal);
-
-    // Get the private handle (platform-dependent)
-    inline void *GetHandle() const;
-
-    // Set/get the window's relatives
-    inline wxWindow *GetParent() const;
-    inline void SetParent(wxWindow *p) ;
-    inline wxWindow *GetGrandParent() const;
-    inline wxList& GetChildren() const;
-    // Reparents this window to have the new parent.
-    virtual bool Reparent(wxWindow* parent);
-
-    // Set/get the window's font
-    virtual void SetFont(const wxFont& f);
-    virtual wxFont& GetFont() const;
-
-    // Set/get the window's validator
-    void SetValidator(const wxValidator& validator);
-    inline wxValidator *GetValidator() const;
-
-    virtual void SetClientObject( wxClientData *data );
-    virtual wxClientData *GetClientObject();
-
-    virtual void SetClientData( void *data );
-    virtual void *GetClientData();
-
-    // Set/get the window's style
-    inline void SetWindowStyleFlag(long flag);
-    inline long GetWindowStyleFlag() const;
-
-    // Handle a control command
-    virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
-
-    // Set/get event handler
-    inline void SetEventHandler(wxEvtHandler *handler);
-    inline wxEvtHandler *GetEventHandler() const;
-
-    // Push/pop event handler (i.e. allow a chain of event handlers
-    // be searched)
-    void PushEventHandler(wxEvtHandler *handler) ;
-    wxEvtHandler *PopEventHandler(bool deleteHandler = FALSE) ;
-
-    // Close the window by calling OnClose, posting a deletion
-    virtual bool Close(bool force = FALSE);
-
-    // Destroy the window (delayed, if a managed window)
-    virtual bool Destroy() ;
-
-    // Mode for telling default OnSize members to
-    // call Layout(), if not using Sizers, just top-down constraints
-    inline void SetAutoLayout(bool a);
-    inline bool GetAutoLayout() const;
-
-    // Set/get constraints
-    inline wxLayoutConstraints *GetConstraints() const;
-    void SetConstraints(wxLayoutConstraints *c);
-
-    // Set/get window background colour
-    virtual void SetBackgroundColour(const wxColour& col);
-    virtual wxColour GetBackgroundColour() const;
-
-    // Set/get window foreground colour
-    virtual void SetForegroundColour(const wxColour& col);
-    virtual wxColour GetForegroundColour() const;
-
-    // Get the default button, if there is one
-    virtual wxButton *GetDefaultItem() const;
-    virtual void SetDefaultItem(wxButton *but);
-
-    // Override to define new behaviour for default action (e.g. double clicking
-    // on a listbox)
-    virtual void OnDefaultAction(wxControl *initiatingItem);
-
-    // Resource loading
-#if wxUSE_WX_RESOURCES
-    virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL);
-    virtual wxControl *CreateItem(const wxItemResource* childResource, const wxItemResource* parentResource,
-            const wxResourceTable *table = (const wxResourceTable *) NULL);
-#endif
-
-    virtual void GetTextExtent(const wxString& string, int *x, int *y,
-            int *descent = NULL,
-            int *externalLeading = NULL,
-            const wxFont *theFont = NULL, bool use16 = FALSE) const;
-
-    // Is the window retained?
-    inline bool IsRetained() const;
-
-    // Warp the pointer the given position
-    virtual void WarpPointer(int x_pos, int y_pos) ;
-
-    // Clear the window
-    virtual void Clear();
-
-    // Find a window by id or name
-    virtual wxWindow *FindWindow(long id);
-    virtual wxWindow *FindWindow(const wxString& name);
-
-    // Constraint operations
-    bool Layout();
-    void SetSizer(wxSizer *sizer);    // Adds sizer child to this window
-    inline wxSizer *GetSizer() const ;
-    inline wxWindow *GetSizerParent() const ;
-    inline void SetSizerParent(wxWindow *win);
-
-    // Do Update UI processing for controls
-    void UpdateWindowUI();
-
-    void OnEraseBackground(wxEraseEvent& event);
-    void OnChar(wxKeyEvent& event);
-    void OnKeyDown(wxKeyEvent& event);
-    void OnKeyUp(wxKeyEvent& event);
-    void OnPaint(wxPaintEvent& event);
+protected:
+    // event handlers (not virtual by design)
     void OnIdle(wxIdleEvent& event);
 
     void OnIdle(wxIdleEvent& event);
 
-    // Does this window want to accept keyboard focus?
-    virtual bool AcceptsFocus() const;
-
-    virtual void PrepareDC( wxDC & WXUNUSED(dc) ) {};
-
-
-public:
-    ////////////////////////////////////////////////////////////////////////
-    //// IMPLEMENTATION
-
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;
@@ -494,106 +112,60 @@ public:
     // a toolbar that it manages itself).
     virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
 
     // a toolbar that it manages itself).
     virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
 
-    // Executes the default message
-    virtual long Default();
-
-    /* TODO: you may need something like this
-    // Determine whether 3D effects are wanted
-    virtual WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D);
-     */
-
     virtual void AddChild(wxWindow *child);         // Adds reference to the child object
     virtual void RemoveChild(wxWindow *child);   // Removes reference to child
     virtual void AddChild(wxWindow *child);         // Adds reference to the child object
     virtual void RemoveChild(wxWindow *child);   // Removes reference to child
-    // (but doesn't delete the child object)
     virtual void DestroyChildren();  // Removes and destroys all children
 
     virtual void DestroyChildren();  // Removes and destroys all children
 
-    bool IsBeingDeleted() const { return FALSE; } // TODO: Should probably eliminate this
-
-    // Constraint implementation
-    void UnsetConstraints(wxLayoutConstraints *c);
-    inline wxList *GetConstraintsInvolvedIn() const ;
-    // Back-pointer to other windows we're involved with, so if we delete
-    // this window, we must delete any constraints we're involved with.
-    void AddConstraintReference(wxWindow *otherWin);
-    void RemoveConstraintReference(wxWindow *otherWin);
-    void DeleteRelatedConstraints();
-
-    virtual void ResetConstraints();
-    virtual void SetConstraintSizes(bool recurse = TRUE);
-    virtual bool LayoutPhase1(int *noChanges);
-    virtual bool LayoutPhase2(int *noChanges);
-    virtual bool DoPhase(int);
-    // Transforms from sizer coordinate space to actual
-    // parent coordinate space
-    virtual void TransformSizerToActual(int *x, int *y) const ;
-
-    // Set size with transformation to actual coordinates if nec.
-    virtual void SizerSetSize(int x, int y, int w, int h);
-    virtual void SizerMove(int x, int y);
-
-    // Only set/get the size/position of the constraint (if any)
-    virtual void SetSizeConstraint(int x, int y, int w, int h);
-    virtual void MoveConstraint(int x, int y);
-    virtual void GetSizeConstraint(int *w, int *h) const ;
-    virtual void GetClientSizeConstraint(int *w, int *h) const ;
-    virtual void GetPositionConstraint(int *x, int *y) const ;
-
-    // Dialog units translations. Implemented in wincmn.cpp.
-    wxPoint ConvertPixelsToDialog(const wxPoint& pt) ;
-    wxPoint ConvertDialogToPixels(const wxPoint& pt) ;
-    inline wxSize ConvertPixelsToDialog(const wxSize& sz)
-    { wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
-    inline wxSize ConvertDialogToPixels(const wxSize& sz)
-    { wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
-
-    wxObject *GetChild(int number) const ;
-
-    // Generates a new id for controls
-    static int NewControlId();
+    wxWindow *GetChild(int number) const
+        { return GetChildren().Item(number)->GetData(); }
 
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
 
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
-    // Transfers data to any child controls
-    void OnInitDialog(wxInitDialogEvent& event);
-
-    // Sends an OnInitDialog event, which in turns transfers data to
-    // to the window via validators.
-    virtual void InitDialog();
-
-    /// Motif-specific
+    // Motif-specific
 
 
+        // empties the m_updateRects list
     void ClearUpdateRects();
     void ClearUpdateRects();
+
+        // CanvasXXXSiize functions
     void CanvasGetSize(int* width, int* height) const; // If have drawing area
     void CanvasGetClientSize(int *width, int *height) const;
     void CanvasGetPosition(int *x, int *y) const; // If have drawing area
     void CanvasSetClientSize(int width, int size);
     void CanvasSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
 
     void CanvasGetSize(int* width, int* height) const; // If have drawing area
     void CanvasGetClientSize(int *width, int *height) const;
     void CanvasGetPosition(int *x, int *y) const; // If have drawing area
     void CanvasSetClientSize(int width, int size);
     void CanvasSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
 
-    // Gives window a chance to do something in response to a size
-    // message, e.g. arrange status bar, toolbar etc.
+    // Gives window a chance to do something in response to a size message, e.g.
+    // arrange status bar, toolbar etc.
     virtual bool PreResize() { return TRUE; }
 
     virtual bool PreResize() { return TRUE; }
 
+    // accessors
+    // ---------
+
     // Get main widget for this window, e.g. a text widget
     virtual WXWidget GetMainWidget() const;
     // Get the widget that corresponds to the label (for font setting, label setting etc.)
     // Get main widget for this window, e.g. a text widget
     virtual WXWidget GetMainWidget() const;
     // Get the widget that corresponds to the label (for font setting, label setting etc.)
-    virtual WXWidget GetLabelWidget() const { return GetMainWidget(); }
-    // Get the client widget for this window (something we can
-    // create other windows on)
+    virtual WXWidget GetLabelWidget() const;
+    // Get the client widget for this window (something we can create other
+    // windows on)
     virtual WXWidget GetClientWidget() const;
     virtual WXWidget GetClientWidget() const;
-    // Get the top widget for this window, e.g. the scrolled widget parent
-    // of a multi-line text widget. Top means, top in the window hierarchy
-    // that implements this window.
+    // Get the top widget for this window, e.g. the scrolled widget parent of a
+    // multi-line text widget. Top means, top in the window hierarchy that
+    // implements this window.
     virtual WXWidget GetTopWidget() const;
     virtual WXWidget GetTopWidget() const;
-    virtual void SetMainWidget(WXWidget w) { m_mainWidget = w; }
+
+    // base class pure virtual
+    virtual WXWidget GetHandle() const { return GetMainWidget(); }
+
+    void SetMainWidget(WXWidget w) { m_mainWidget = w; }
+
     bool CanAddEventHandler() const { return m_canAddEventHandler; }
     void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }
 
     // Get the underlying X window and display
     bool CanAddEventHandler() const { return m_canAddEventHandler; }
     void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }
 
     // Get the underlying X window and display
-    virtual WXWindow GetXWindow() const;
-    virtual WXDisplay *GetXDisplay() const;
+    WXWindow GetXWindow() const;
+    WXDisplay *GetXDisplay() const;
 
 
-    virtual WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
+    WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
     int GetPixmapWidth() const { return m_pixmapWidth; }
     int GetPixmapHeight() const { return m_pixmapHeight; }
 
     int GetPixmapWidth() const { return m_pixmapWidth; }
     int GetPixmapHeight() const { return m_pixmapHeight; }
 
@@ -601,91 +173,68 @@ public:
     virtual void ChangeFont(bool keepOriginalSize = TRUE);             // Change to the current font (often overridden)
     virtual void DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour);
     virtual void DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
     virtual void ChangeFont(bool keepOriginalSize = TRUE);             // Change to the current font (often overridden)
     virtual void DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour);
     virtual void DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
-    // These to be overridden as needed (may change several widgets)
-    virtual void ChangeBackgroundColour(); // Change background and foreground colour using current
-    // background colour setting (Motif generates
-    // foreground based on background)
-    virtual void ChangeForegroundColour(); // Change foreground colour using current
-    // foreground colour setting
+
+    // Change background and foreground colour using current background colour
+    // setting (Motif generates foreground based on background)
+    virtual void ChangeBackgroundColour();
+    // Change foreground colour using current foreground colour setting
+    virtual void ChangeForegroundColour();
 
     // Adds the widget to the hash table and adds event handlers.
 
     // Adds the widget to the hash table and adds event handlers.
-    bool AttachWidget (wxWindow* parent, WXWidget mainWidget,
-            WXWidget formWidget, int x, int y, int width, int height);
+    bool AttachWidget(wxWindow* parent, WXWidget mainWidget,
+                      WXWidget formWidget, int x, int y, int width, int height);
     bool DetachWidget(WXWidget widget);
 
     // Generates a paint event
     virtual void DoPaint();
 
     bool DetachWidget(WXWidget widget);
 
     // Generates a paint event
     virtual void DoPaint();
 
-    // How to implement accelerators. If we find a key event,
-    // translate to wxWindows wxKeyEvent form. Find a widget for the window.
-    // Now find a wxWindow for the widget. If there isn't one, go up the widget hierarchy
+    // How to implement accelerators. If we find a key event, translate to
+    // wxWindows wxKeyEvent form. Find a widget for the window. Now find a
+    // wxWindow for the widget. If there isn't one, go up the widget hierarchy
     // trying to find one. Once one is found, call ProcessAccelerator for the
     // window. If it returns TRUE (processed the event), skip the X event,
     // trying to find one. Once one is found, call ProcessAccelerator for the
     // window. If it returns TRUE (processed the event), skip the X event,
-    // otherwise carry on up the wxWindows window hierarchy calling ProcessAccelerator.
-    // If all return FALSE, process the X event as normal.
-    // Eventually we can implement OnCharHook the same way, but concentrate on accelerators
-    // for now.
-    // ProcessAccelerator must look at the current accelerator table, and try to find
-    // what menu id or window (beneath it) has this ID. Then construct an appropriate command
+    // otherwise carry on up the wxWindows window hierarchy calling
+    // ProcessAccelerator. If all return FALSE, process the X event as normal.
+    // Eventually we can implement OnCharHook the same way, but concentrate on
+    // accelerators for now. ProcessAccelerator must look at the current
+    // accelerator table, and try to find what menu id or window (beneath it)
+    // has this ID. Then construct an appropriate command
     // event and send it.
     virtual bool ProcessAccelerator(wxKeyEvent& event);
 
     // event and send it.
     virtual bool ProcessAccelerator(wxKeyEvent& event);
 
-    ////////////////////////////////////////////////////////////////////////
-    //// PROTECTED DATA
 protected:
 protected:
-    int                   m_windowId;
-    long                  m_windowStyle;                       // Store the window's style
-    wxEvtHandler *        m_windowEventHandler;        // Usually is 'this'
-    wxLayoutConstraints * m_constraints;           // Constraints for this window
-    wxList *              m_constraintsInvolvedIn; // List of constraints we're involved in
-    wxSizer *             m_windowSizer;                       // Window's top-level sizer (if any)
-    wxWindow *            m_sizerParent;                      // Window's parent sizer (if any)
-    bool                  m_autoLayout;                            // Whether to call Layout() in OnSize
-    wxWindow *            m_windowParent;                     // Each window always knows its parent
-    wxValidator *         m_windowValidator;
-    int                   m_minSizeX;
-    int                   m_minSizeY;
-    int                   m_maxSizeX;
-    int                   m_maxSizeY;
-
-    // Caret data
-    int                   m_caretWidth;
-    int                   m_caretHeight;
-    bool                  m_caretEnabled;
-    bool                  m_caretShown;
-    wxFont                m_windowFont;                               // Window's font
-    wxCursor              m_windowCursor;                        // Window's cursor
-    wxString              m_windowName;                            // Window name
-
-    wxButton *            m_defaultItem;
-
-    wxColour              m_backgroundColour ;
-    wxColour              m_foregroundColour ;
-    wxAcceleratorTable    m_acceleratorTable;
-    wxClientData*         m_clientObject;
-    void*                 m_clientData;
+    // unmanage and destroy an X widget f it's !NULL (passing NULL is ok)
+    void UnmanageAndDestroy(WXWidget widget);
 
 
-#if wxUSE_DRAG_AND_DROP
-    wxDropTarget         *m_pDropTarget;    // the current drop target or NULL
-#endif  //USE_DRAG_AND_DROP
+    // map or unmap an X widget (passing NULL is ok), returns TRUE if widget was
+    // mapped/unmapped
+    bool MapOrUnmap(WXWidget widget, bool map);
 
 
-public:
-    wxRegion              m_updateRegion;
-    wxList *              m_children;                           // Window's children
-    int                   m_returnCode;
+    // get either hor or vert scrollbar widget
+    WXWidget GetScrollbar(wxOrientation orient) const
+        { return orient == wxHORIZONTAL ? m_hScrollBar : m_vScrollBar; }
+
+    // set the scroll pos
+    void SetInternalScrollPos(wxOrientation orient, int pos)
+    {
+        if ( orient == wxHORIZONTAL )
+            m_scrollPosX = pos;
+        else
+            m_scrollPosY = pos;
+    }
+
+    // Motif-specific flags
+    bool m_needsRefresh:1;          // repaint backing store?
+    bool m_canAddEventHandler:1;    // ???
+    bool m_button1Pressed:1;
+    bool m_button2Pressed:1;
+    bool m_button3Pressed:1;
 
 
-public:
-    /// Motif-specific
-    bool                  m_needsRefresh; // Do we need to repaint the backing store?
-    bool                  m_canAddEventHandler;
-    bool                  m_button1Pressed;
-    bool                  m_button2Pressed;
-    bool                  m_button3Pressed;
     // For double-click detection
     // For double-click detection
-    long                  m_lastTS;      // last timestamp
-    int                   m_lastButton;  // last pressed button
-    wxList                m_updateRects;     // List of wxRects representing damaged region
-    bool                  m_isShown;
+    long   m_lastTS;         // last timestamp
+    int    m_lastButton;     // last pressed button
+    wxList m_updateRects;    // List of wxRects representing damaged region
+
 protected:
     WXWidget              m_mainWidget;
     WXWidget              m_hScrollBar;
 protected:
     WXWidget              m_mainWidget;
     WXWidget              m_hScrollBar;
@@ -701,66 +250,41 @@ protected:
     int                   m_pixmapHeight;
     int                   m_pixmapOffsetX;
     int                   m_pixmapOffsetY;
     int                   m_pixmapHeight;
     int                   m_pixmapOffsetX;
     int                   m_pixmapOffsetY;
-    int                   m_scrollPosX; // Store the last scroll pos,
-    int                   m_scrollPosY; // since in wxWin the pos isn't
-    // set automatically by system
 
 
-    // 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
+    // Store the last scroll pos, since in wxWin the pos isn't set automatically
+    // by system
+    int                   m_scrollPosX;
+    int                   m_scrollPosY;
+
+    // implement the base class pure virtuals
+    virtual void DoClientToScreen( int *x, int *y ) const;
+    virtual void DoScreenToClient( int *x, int *y ) const;
+    virtual void DoGetPosition( int *x, int *y ) const;
+    virtual void DoGetSize( int *width, int *height ) const;
+    virtual void DoGetClientSize( int *width, int *height ) const;
     virtual void DoSetSize(int x, int y,
                            int width, int height,
                            int sizeFlags = wxSIZE_AUTO);
     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);
 
     virtual void DoSetClientSize(int width, int height);
 
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip( wxToolTip *tip );
+#endif // wxUSE_TOOLTIPS
+
 private:
 private:
+    // common part of all ctors
+    void Init();
+
+    DECLARE_NO_COPY_CLASS(wxWindow);
     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_EVENT_TABLE()
 };
 
-////////////////////////////////////////////////////////////////////////
-//// INLINES
-
-inline void *wxWindow::GetHandle() const { return (void *)NULL; }
-inline int wxWindow::GetId() const { return m_windowId; }
-inline void wxWindow::SetId(int id) { m_windowId = id; }
-inline wxWindow *wxWindow::GetParent() const { return m_windowParent; }
-inline void wxWindow::SetParent(wxWindow *p) { m_windowParent = p; }
-inline wxWindow *wxWindow::GetGrandParent() const { return (m_windowParent ? m_windowParent->m_windowParent : (wxWindow*) NULL); }
-inline wxList& wxWindow::GetChildren() const { return (wxList&) * m_children; }
-inline wxFont& wxWindow::GetFont() const { return (wxFont&) m_windowFont; }
-inline wxString wxWindow::GetName() const { return m_windowName; }
-inline void wxWindow::SetName(const wxString& name) { m_windowName = name; }
-inline long wxWindow::GetWindowStyleFlag() const { return m_windowStyle; }
-inline void wxWindow::SetWindowStyleFlag(long flag) { m_windowStyle = flag; }
-inline void wxWindow::SetEventHandler(wxEvtHandler *handler) { m_windowEventHandler = handler; }
-inline wxEvtHandler *wxWindow::GetEventHandler() const { return m_windowEventHandler; }
-inline void wxWindow::SetAutoLayout(bool a) { m_autoLayout = a; }
-inline bool wxWindow::GetAutoLayout() const { return m_autoLayout; }
-inline wxLayoutConstraints *wxWindow::GetConstraints() const { return m_constraints; }
-inline wxColour wxWindow::GetBackgroundColour() const { return m_backgroundColour; };
-inline wxColour wxWindow::GetForegroundColour() const { return m_foregroundColour; };
-
-inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; }
-inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; }
-inline bool wxWindow::IsRetained() const { return ((m_windowStyle & wxRETAINED) == wxRETAINED); }
-
-inline wxList *wxWindow::GetConstraintsInvolvedIn() const { return m_constraintsInvolvedIn; }
-inline wxSizer *wxWindow::GetSizer() const { return m_windowSizer; }
-inline wxWindow *wxWindow::GetSizerParent() const { return m_sizerParent; }
-inline void wxWindow::SetSizerParent(wxWindow *win) { m_sizerParent = win; }
-inline wxValidator *wxWindow::GetValidator() const { return m_windowValidator; }
-inline void wxWindow::SetReturnCode(int retCode) { m_returnCode = retCode; }
-inline int wxWindow::GetReturnCode() { return m_returnCode; }
-
-// Get the active window.
-wxWindow* WXDLLEXPORT wxGetActiveWindow();
-
-WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
-
+// ----------------------------------------------------------------------------
 // A little class to switch off size optimization while an instance of the object
 // exists
 // A little class to switch off size optimization while an instance of the object
 // exists
+//
+// TODO what is it for??
+// ----------------------------------------------------------------------------
 class WXDLLEXPORT wxNoOptimize: public wxObject
 {
 public:
 class WXDLLEXPORT wxNoOptimize: public wxObject
 {
 public:
index b04aa898514ebc9a27c3e3d95db80dcaad8c7fca..be06f8d8b7644a3016d420b45c6a2945fe7b27a3 100644 (file)
@@ -144,7 +144,7 @@ public:
     virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { }
 #endif // WXWIN_COMPATIBILITY
 
     virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { }
 #endif // WXWIN_COMPATIBILITY
 
-#if wxUSE_CARET
+#if wxUSE_CARET && WXWIN_COMPATIBILITY
     // caret manipulation (old MSW only functions, see wxCaret class for the
     // new API)
     void CreateCaret(int w, int h);
     // caret manipulation (old MSW only functions, see wxCaret class for the
     // new API)
     void CreateCaret(int w, int h);
index 61c34c41ecfd9f4757cef9c57931ba45a8fa7b12..3f7faec6b27a5c675794c226ae67aa9be3a4a74e 100644 (file)
@@ -138,19 +138,19 @@ wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \
 // Single inheritance with one base class
 #define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
  wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename), \
 // Single inheritance with one base class
 #define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
  wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename), \
-                (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) NULL);
+         (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) NULL);
 
 // Multiple inheritance with two base classes
 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
  wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename1), \
 
 // Multiple inheritance with two base classes
 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
  wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename1), \
-                (wxChar *) _T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);
+         (wxChar *) _T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);
 
 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
 
 #define CLASSINFO(name) (&name::sm_class##name)
 
 
 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
 
 #define CLASSINFO(name) (&name::sm_class##name)
 
-#else
+#else // !wxUSE_DYNAMIC_CLASSES
 
 // No dynamic class system: so stub out the macros
 #define DECLARE_DYNAMIC_CLASS(name)
 
 // No dynamic class system: so stub out the macros
 #define DECLARE_DYNAMIC_CLASS(name)
@@ -163,20 +163,26 @@ wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \
 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
 
 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
 
-#endif
+#endif // wxUSE_DYNAMIC_CLASSES/!wxUSE_DYNAMIC_CLASSES
 
 #define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::sm_class##className)
 
 // Just seems a bit nicer-looking (pretend it's not a macro)
 #define wxIsKindOf(obj, className) obj->IsKindOf(&className::sm_class##className)
 
 
 #define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::sm_class##className)
 
 // Just seems a bit nicer-looking (pretend it's not a macro)
 #define wxIsKindOf(obj, className) obj->IsKindOf(&className::sm_class##className)
 
+// to be replaced by dynamic_cast<> in the future
+#define wxDynamicCast(obj, className) \
+        ((obj) && ((obj)->IsKindOf(&className::sm_class##className)) \
+        ? (className *)(obj) \
+        : (className *)0)
+
 // Unfortunately Borland seems to need this include.
 #ifdef __BORLANDC__
 // Unfortunately Borland seems to need this include.
 #ifdef __BORLANDC__
-#if wxUSE_IOSTREAMH
-#include <iostream.h>
-#else
-#include <iostream>
-#endif
+    #if wxUSE_IOSTREAMH
+        #include <iostream.h>
+    #else
+        #include <iostream>
+    #endif
 #endif
 
 class WXDLLEXPORT wxObjectRefData;
 #endif
 
 class WXDLLEXPORT wxObjectRefData;
index a805172231e958e7f4927d162998e7e795b40b55..3fdcd5acf00e6297a99930c83c15aa1639562c1b 100644 (file)
@@ -324,7 +324,7 @@ public:
     inline wxWindow *GetGrandParent() const;
 
         // is this window a top level one?
     inline wxWindow *GetGrandParent() const;
 
         // is this window a top level one?
-    bool IsTopLevel() const { return m_parent != 0; }
+    bool IsTopLevel() const;
 
         // it doesn't really change parent, use ReParent() instead
     void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
 
         // it doesn't really change parent, use ReParent() instead
     void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
index 92b73efe7915423b350324eb282aa34cbb1877de..cd92991e22f1c9e037377a76640944d67302bf87 100644 (file)
@@ -326,10 +326,9 @@ void wxWindowBase::Fit()
     while ( node )
     {
         wxWindow *win = node->GetData();
     while ( node )
     {
         wxWindow *win = node->GetData();
-        if ( win->IsKindOf(CLASSINFO(wxFrame)) ||
-             win->IsKindOf(CLASSINFO(wxDialog)) )
+        if ( win->IsTopLevel() )
         {
         {
-            // dialogs and frames line in different top level windows - don't
+            // dialogs and frames lie in different top level windows - don't
             // deal with them here
             continue;
         }
             // deal with them here
             continue;
         }
@@ -392,6 +391,14 @@ bool wxWindowBase::Enable(bool enable)
         return FALSE;
     }
 }
         return FALSE;
     }
 }
+// ----------------------------------------------------------------------------
+// RTTI
+// ----------------------------------------------------------------------------
+
+bool wxWindowBase::IsTopLevel() const
+{
+    return wxDynamicCast(this, wxFrame) || wxDynamicCast(this, wxDialog);
+}
 
 // ----------------------------------------------------------------------------
 // reparenting the window
 
 // ----------------------------------------------------------------------------
 // reparenting the window
@@ -618,9 +625,21 @@ wxWindow *wxWindowBase::FindWindow( const wxString& name )
 // dialog oriented functions
 // ----------------------------------------------------------------------------
 
 // dialog oriented functions
 // ----------------------------------------------------------------------------
 
-void wxWindowBase::MakeModal(bool WXUNUSED(modal))
+void wxWindowBase::MakeModal(bool modal)
 {
 {
-    wxFAIL_MSG(_T("TODO"));
+    // Disable all other windows
+    if ( IsTopLevel() )
+    {
+        wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
+        while (node)
+        {
+            wxWindow *win = node->GetData();
+            if (win != this)
+                win->Enable(!modal);
+
+            node = node->GetNext();
+        }
+    }
 }
 
 bool wxWindowBase::Validate()
 }
 
 bool wxWindowBase::Validate()
@@ -914,7 +933,7 @@ bool wxWindowBase::DoPhase(int phase)
         while (node)
         {
             wxWindow *child = node->GetData();
         while (node)
         {
             wxWindow *child = node->GetData();
-            if ( !child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)) )
+            if ( !child->IsTopLevel() )
             {
                 wxLayoutConstraints *constr = child->GetConstraints();
                 if ( constr )
             {
                 wxLayoutConstraints *constr = child->GetConstraints();
                 if ( constr )
@@ -958,7 +977,7 @@ void wxWindowBase::ResetConstraints()
     while (node)
     {
         wxWindow *win = node->GetData();
     while (node)
     {
         wxWindow *win = node->GetData();
-        if ( !win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)) )
+        if ( !win->IsTopLevel() )
             win->ResetConstraints();
         node = node->GetNext();
     }
             win->ResetConstraints();
         node = node->GetNext();
     }
@@ -1015,7 +1034,7 @@ void wxWindowBase::SetConstraintSizes(bool recurse)
         while (node)
         {
             wxWindow *win = node->GetData();
         while (node)
         {
             wxWindow *win = node->GetData();
-            if ( !win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)) )
+            if ( !win->IsTopLevel() )
                 win->SetConstraintSizes();
             node = node->GetNext();
         }
                 win->SetConstraintSizes();
             node = node->GetNext();
         }
@@ -1026,8 +1045,7 @@ void wxWindowBase::SetConstraintSizes(bool recurse)
 // this window.
 void wxWindowBase::TransformSizerToActual(int *x, int *y) const
 {
 // this window.
 void wxWindowBase::TransformSizerToActual(int *x, int *y) const
 {
-    if ( !m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog) ) ||
-            m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
+    if ( !m_sizerParent || m_sizerParent->IsTopLevel() )
         return;
 
     int xp, yp;
         return;
 
     int xp, yp;
@@ -1159,22 +1177,28 @@ void wxWindowBase::UpdateWindowUI()
             if ( event.GetSetEnabled() )
                 Enable(event.GetEnabled());
 
             if ( event.GetSetEnabled() )
                 Enable(event.GetEnabled());
 
-            if ( event.GetSetText() && IsKindOf(CLASSINFO(wxControl)) )
-                ((wxControl*)this)->SetLabel(event.GetText());
+            if ( event.GetSetText() )
+            {
+                wxControl *control = wxDynamicCast(this, wxControl);
+                if ( control )
+                    control->SetLabel(event.GetText());
+            }
 
 #if wxUSE_CHECKBOX
 
 #if wxUSE_CHECKBOX
-            if ( IsKindOf(CLASSINFO(wxCheckBox)) )
+            wxCheckBox *checkbox = wxDynamicCast(this, wxCheckBox);
+            if ( checkbox )
             {
                 if ( event.GetSetChecked() )
             {
                 if ( event.GetSetChecked() )
-                    ((wxCheckBox *)this)->SetValue(event.GetChecked());
+                    checkbox->SetValue(event.GetChecked());
             }
 #endif // wxUSE_CHECKBOX
 
 #if wxUSE_RADIOBUTTON
             }
 #endif // wxUSE_CHECKBOX
 
 #if wxUSE_RADIOBUTTON
-            if ( IsKindOf(CLASSINFO(wxRadioButton)) )
+            wxRadioButton *radiobtn = wxDynamicCast(this, wxRadioButton);
+            if ( radiobtn )
             {
                 if ( event.GetSetChecked() )
             {
                 if ( event.GetSetChecked() )
-                    ((wxRadioButton *) this)->SetValue(event.GetChecked());
+                    radiobtn->SetValue(event.GetChecked());
             }
 #endif // wxUSE_RADIOBUTTON
         }
             }
 #endif // wxUSE_RADIOBUTTON
         }
index 620a925f4e36f1329a1665c38f65c860ffa2e9b4..d4da1486be5f35fab6f653ee68d8eeac55af3756 100644 (file)
@@ -6,11 +6,19 @@
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:    wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
 #ifdef __GNUG__
-#pragma implementation "window.h"
+    #pragma implementation "window.h"
 #endif
 
 #include "wx/setup.h"
 #endif
 
 #include "wx/setup.h"
@@ -33,7 +41,7 @@
 #include "wx/log.h"
 
 #if  wxUSE_DRAG_AND_DROP
 #include "wx/log.h"
 
 #if  wxUSE_DRAG_AND_DROP
-#include "wx/dnd.h"
+    #include "wx/dnd.h"
 #endif
 
 #include <Xm/Xm.h>
 #endif
 
 #include <Xm/Xm.h>
 
 #include <string.h>
 
 
 #include <string.h>
 
-#define SCROLL_MARGIN 4
-void wxCanvasRepaintProc (Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
-void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
-void wxCanvasMotionEvent (Widget, XButtonEvent * event);
-void wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+static const int SCROLL_MARGIN = 4;
+
+// ----------------------------------------------------------------------------
+// global variables for this module
+// ----------------------------------------------------------------------------
+
+static wxHashTable *gs_wxWidgetHashTable;
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static void wxCanvasRepaintProc(Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
+static void wxCanvasInputEvent(Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
+static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
+static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
 static void wxScrollBarCallback(Widget widget, XtPointer clientData,
                                 XmScaleCallbackStruct *cbs);
 static void wxScrollBarCallback(Widget widget, XtPointer clientData,
                                 XmScaleCallbackStruct *cbs);
-void wxPanelItemEventHandler (Widget    wid,
-                              XtPointer client_data,
-                              XEvent*   event,
-                              Boolean *continueToDispatch);
+static void wxPanelItemEventHandler(Widget    wid,
+                                    XtPointer client_data,
+                                    XEvent*   event,
+                                    Boolean  *continueToDispatch);
+
+// unused for now
+#if 0
+
+// Helper function for 16-bit fonts
+static int str16len(const char *s)
+{
+    int count = 0;
+
+    while (s[0] && s[1]) {
+        count++;
+        s += 2;
+    }
+
+    return count;
+}
+
+#endif // 0
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
 
 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
 
 
 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
 
-extern wxList wxPendingDelete;
+// ----------------------------------------------------------------------------
+// event tables
+// ----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY
 
 #if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
-
-BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
-EVT_CHAR(wxWindow::OnChar)
-EVT_KEY_DOWN(wxWindow::OnKeyDown)
-EVT_KEY_UP(wxWindow::OnKeyUp)
-EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
-EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-EVT_IDLE(wxWindow::OnIdle)
-END_EVENT_TABLE()
+    IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
 
 
-#endif
+    BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
+        EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
+        EVT_IDLE(wxWindow::OnIdle)
+    END_EVENT_TABLE()
+#endif // USE_SHARED_LIBRARY
 
 
+// ============================================================================
+// implementation
+// ============================================================================
 
 
-// Constructor
-wxWindow::wxWindow()
-{
-    // Generic
-    m_isWindow = TRUE; // An optimization
-    m_windowId = 0;
-    m_windowStyle = 0;
-    m_windowParent = NULL;
-    m_windowEventHandler = this;
-    m_windowName = "";
-    m_windowCursor = *wxSTANDARD_CURSOR;
-    m_children = new wxList;
-    m_constraints = NULL;
-    m_constraintsInvolvedIn = NULL;
-    m_windowSizer = NULL;
-    m_sizerParent = NULL;
-    m_autoLayout = FALSE;
-    m_windowValidator = NULL;
-    m_defaultItem = NULL;
-    m_returnCode = 0;
-    m_caretWidth = 0; m_caretHeight = 0;
-    m_caretEnabled = FALSE;
-    m_caretShown = FALSE;
-    // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
-    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
-    m_foregroundColour = *wxBLACK;
-    
-#if  wxUSE_DRAG_AND_DROP
-    m_pDropTarget = NULL;
-#endif
-    m_clientObject = (wxClientData*) NULL;
-    m_clientData = NULL;
-    
-    /// Motif-specific
-    m_needsRefresh = TRUE;
-    m_mainWidget = (WXWidget) 0;
-    m_button1Pressed = FALSE;
-    m_button2Pressed = FALSE;
-    m_button3Pressed = FALSE;
-    m_winCaptured = FALSE;
-    m_isShown = TRUE;
-    m_hScrollBar = (WXWidget) 0;
-    m_vScrollBar = (WXWidget) 0;
-    m_borderWidget = (WXWidget) 0;
-    m_scrolledWindow = (WXWidget) 0;
-    m_drawingArea = (WXWidget) 0;
-    m_hScroll = FALSE;
-    m_vScroll = FALSE;
-    m_backingPixmap = (WXPixmap) 0;
-    m_pixmapWidth = 0;
-    m_pixmapHeight = 0;
-    m_pixmapOffsetX = 0;
-    m_pixmapOffsetY = 0;
-    m_lastTS = 0;
-    m_lastButton = 0;
-    m_canAddEventHandler = FALSE;
-    m_scrollPosX = 0;
-    m_scrollPosY = 0;
-}
+// ----------------------------------------------------------------------------
+// helper functions
+// ----------------------------------------------------------------------------
 
 
-// Destructor
-wxWindow::~wxWindow()
+void wxWindow::UnmanageAndDestroy(WXWidget widget)
 {
 {
-    //// Motif-specific
-    
-    if (GetMainWidget())
-        DetachWidget(GetMainWidget()); // Removes event handlers
-    
-    // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
-    if (m_drawingArea)
-    {
-        // Destroy children before destroying self
-        DestroyChildren();
-        
-        if (m_backingPixmap)
-            XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
-        
-        Widget w = (Widget) m_drawingArea;
-        wxDeleteWindowFromTable(w);
-        
-        if (w)
-            XtDestroyWidget(w);
-        m_mainWidget = (WXWidget) 0;
-        
-        // Only if we're _really_ a canvas (not a dialog box/panel)
-        if (m_scrolledWindow)
-        {
-            wxDeleteWindowFromTable((Widget) m_scrolledWindow);
-        }
-        
-        if (m_hScrollBar)
-        {
-            XtUnmanageChild ((Widget) m_hScrollBar);
-            XtDestroyWidget ((Widget) m_hScrollBar);
-        }
-        if (m_vScrollBar)
-        {
-            XtUnmanageChild ((Widget) m_vScrollBar);
-            XtDestroyWidget ((Widget) m_vScrollBar);
-        }
-        if (m_scrolledWindow)
-        {
-            XtUnmanageChild ((Widget) m_scrolledWindow);
-            XtDestroyWidget ((Widget) m_scrolledWindow);
-        }
-        
-        if (m_borderWidget)
-        {
-            XtDestroyWidget ((Widget) m_borderWidget);
-            m_borderWidget = (WXWidget) 0;
-        }
-    }
-    
-    //// Generic stuff
-    
-    // Have to delete constraints/sizer FIRST otherwise
-    // sizers may try to look at deleted windows as they
-    // delete themselves.
-#if wxUSE_CONSTRAINTS
-    DeleteRelatedConstraints();
-    if (m_constraints)
-    {
-        // This removes any dangling pointers to this window
-        // in other windows' constraintsInvolvedIn lists.
-        UnsetConstraints(m_constraints);
-        delete m_constraints;
-        m_constraints = NULL;
-    }
-    if (m_windowSizer)
-    {
-        delete m_windowSizer;
-        m_windowSizer = NULL;
-    }
-    // If this is a child of a sizer, remove self from parent
-    if (m_sizerParent)
-        m_sizerParent->RemoveChild((wxWindow *)this);
-#endif
-    
-    if (m_windowParent)
-        m_windowParent->RemoveChild(this);
-    
-    DestroyChildren();
-    
-    // Destroy the window
-    if (GetMainWidget())
+    Widget w = (Widget)widget;
+    if ( w )
     {
     {
-        // If this line (XtDestroyWidget) causes a crash, you may comment it out.
-        // Child widgets will get destroyed automatically when a frame
-        // or dialog is destroyed, but before that you may get some memory
-        // leaks and potential layout problems if you delete and then add
-        // child windows.
-        XtDestroyWidget((Widget) GetMainWidget());
-        SetMainWidget((WXWidget) NULL);
+        XtUnmanageChild(w);
+        XtDestroyWidget(w);
     }
     }
-    
-    delete m_children;
-    m_children = NULL;
-    
-    // Just in case the window has been Closed, but
-    // we're then deleting immediately: don't leave
-    // dangling pointers.
-    wxPendingDelete.DeleteObject(this);
-    
-    if ( m_windowValidator ) delete m_windowValidator;
-    if (m_clientObject) delete m_clientObject;
-    
-    ClearUpdateRects();
 }
 
 }
 
-// Destroy the window (delayed, if a managed window)
-bool wxWindow::Destroy()
+bool wxWindow::MapOrUnmap(WXWidget widget, bool map)
 {
 {
-    delete this;
+    Widget w = (Widget)widget;
+    if ( !w )
+        return FALSE;
+
+    if ( map )
+        XtMapWidget(w);
+    else
+        XtUnmapWidget(w);
+
     return TRUE;
 }
 
     return TRUE;
 }
 
-// Constructor
-bool wxWindow::Create(wxWindow *parent, wxWindowID id,
-                      const wxPoint& pos,
-                      const wxSize& size,
-                      long style,
-                      const wxString& name)
+// ----------------------------------------------------------------------------
+// constructors
+// ----------------------------------------------------------------------------
+
+void wxWindow::Init()
 {
 {
-    // Generic
-    m_isWindow = TRUE; // An optimization
-    m_windowId = 0;
-    m_windowStyle = 0;
-    m_windowParent = NULL;
-    m_windowEventHandler = this;
-    m_windowName = "";
-    m_windowCursor = *wxSTANDARD_CURSOR;
-    m_constraints = NULL;
-    m_constraintsInvolvedIn = NULL;
-    m_windowSizer = NULL;
-    m_sizerParent = NULL;
-    m_autoLayout = FALSE;
-    m_windowValidator = NULL;
-#if wxUSE_DRAG_AND_DROP
-    m_pDropTarget = NULL;
-#endif
-    m_caretWidth = 0; m_caretHeight = 0;
-    m_caretEnabled = FALSE;
-    m_caretShown = FALSE;
-    m_minSizeX = -1;
-    m_minSizeY = -1;
-    m_maxSizeX = -1;
-    m_maxSizeY = -1;
-    m_defaultItem = NULL;
-    m_windowParent = NULL;
-    m_clientObject = (wxClientData*) NULL;
-    m_clientData = NULL;
-    
+    // generic initializations first
+    InitBase();
+
     // Motif-specific
     m_needsRefresh = TRUE;
     // Motif-specific
     m_needsRefresh = TRUE;
-    m_canAddEventHandler = FALSE;
     m_mainWidget = (WXWidget) 0;
     m_mainWidget = (WXWidget) 0;
-    m_button1Pressed = FALSE;
-    m_button2Pressed = FALSE;
+
+    m_button1Pressed =
+    m_button2Pressed =
     m_button3Pressed = FALSE;
     m_button3Pressed = FALSE;
+
     m_winCaptured = FALSE;
     m_winCaptured = FALSE;
+
     m_isShown = TRUE;
     m_isShown = TRUE;
-    m_hScrollBar = (WXWidget) 0;
-    m_vScrollBar = (WXWidget) 0;
-    m_borderWidget = (WXWidget) 0;
-    m_scrolledWindow = (WXWidget) 0;
+
+    m_hScrollBar =
+    m_vScrollBar =
+    m_borderWidget =
+    m_scrolledWindow =
     m_drawingArea = (WXWidget) 0;
     m_drawingArea = (WXWidget) 0;
-    m_hScroll = FALSE;
+
+    m_hScroll =
     m_vScroll = FALSE;
     m_vScroll = FALSE;
+
+    m_scrollPosX =
+    m_scrollPosY = 0;
+
     m_backingPixmap = (WXPixmap) 0;
     m_backingPixmap = (WXPixmap) 0;
-    m_pixmapWidth = 0;
+    m_pixmapWidth =
     m_pixmapHeight = 0;
     m_pixmapHeight = 0;
-    m_pixmapOffsetX = 0;
+
+    m_pixmapOffsetX =
     m_pixmapOffsetY = 0;
     m_pixmapOffsetY = 0;
-    m_scrollPosX = 0;
-    m_scrollPosY = 0;
-    
-    if (!parent)
-        return FALSE;
-    
-    if (parent) parent->AddChild(this);
-    
-    m_returnCode = 0;
-    
-    SetName(name);
-    
-    if ( id == -1 )
-        m_windowId = (int)NewControlId();
-    else
-        m_windowId = id;
-    
-    // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
-    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
+
+    m_lastTS = 0;
+    m_lastButton = 0;
+    m_canAddEventHandler = FALSE;
+}
+
+// real construction (Init() must have been called before!)
+bool wxWindow::Create(wxWindow *parent, wxWindowID id,
+                      const wxPoint& pos,
+                      const wxSize& size,
+                      long style,
+                      const wxString& name)
+{
+    wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
+
+    CreateBase(parent, id, pos, size, style, name);
+
+    parent->AddChild(this);
+
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
     m_foregroundColour = *wxBLACK;
     m_foregroundColour = *wxBLACK;
-    
-    m_windowStyle = style;
-    
-    if ( id == -1 )
-        m_windowId = (int)NewControlId();
-    else
-        m_windowId = id;
-    
+
     //// TODO: we should probably optimize by only creating a
     //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
     //// But for now, let's simplify things by always creating the
     //// drawing area, since otherwise the translations are different.
     //// TODO: we should probably optimize by only creating a
     //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
     //// But for now, let's simplify things by always creating the
     //// drawing area, since otherwise the translations are different.
-    
+
     // New translations for getting mouse motion feedback
     // New translations for getting mouse motion feedback
-    String translations =
-    "<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
+    static const String translations =
+"<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 <BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
@@ -364,106 +236,192 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 <EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 <LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 <Key>: DrawingAreaInput()";
 <EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 <LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 <Key>: DrawingAreaInput()";
-    
+
     XtActionsRec actions[1];
     actions[0].string = "wxCanvasMotionEvent";
     actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
     XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
     XtActionsRec actions[1];
     actions[0].string = "wxCanvasMotionEvent";
     actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
     XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
-    
-    Widget parentWidget = (Widget) parent->GetClientWidget(); 
+
+    Widget parentWidget = (Widget) parent->GetClientWidget();
     if (style & wxBORDER)
     if (style & wxBORDER)
-        m_borderWidget = (WXWidget) XtVaCreateManagedWidget ("canvasBorder",
-        xmFrameWidgetClass, parentWidget,
-        XmNshadowType, XmSHADOW_IN,
-        NULL);
-    
-    m_scrolledWindow = (WXWidget) XtVaCreateManagedWidget ("scrolledWindow",
-        xmScrolledWindowWidgetClass, m_borderWidget ? (Widget) m_borderWidget : parentWidget,
-        XmNresizePolicy, XmRESIZE_NONE,
-        XmNspacing, 0,
-        XmNscrollingPolicy, XmAPPLICATION_DEFINED,
-        //                                  XmNscrollBarDisplayPolicy, XmAS_NEEDED,
-        NULL);
-    
-    XtTranslations ptr;
-    m_drawingArea = (WXWidget) XtVaCreateWidget ((char*) (const char*) name,
-        xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
-        XmNunitType, XmPIXELS,
-        //                                      XmNresizePolicy, XmRESIZE_ANY,
-        XmNresizePolicy, XmRESIZE_NONE,
-        XmNmarginHeight, 0,
-        XmNmarginWidth, 0,
-        XmNtranslations, ptr = XtParseTranslationTable (translations),
-        NULL);
-        /*
-        if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
-        {
-        XtFree ((char *) ptr);
+    {
+        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
+                                   (
+                                    "canvasBorder",
+                                    xmFrameWidgetClass, parentWidget,
+                                    XmNshadowType, XmSHADOW_IN,
+                                    NULL
+                                   );
+    }
+
+    m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
+                                 (
+                                  "scrolledWindow",
+                                  xmScrolledWindowWidgetClass,
+                                  m_borderWidget ? (Widget) m_borderWidget
+                                                 : parentWidget,
+                                  XmNresizePolicy, XmRESIZE_NONE,
+                                  XmNspacing, 0,
+                                  XmNscrollingPolicy, XmAPPLICATION_DEFINED,
+                                  //XmNscrollBarDisplayPolicy, XmAS_NEEDED,
+                                  NULL
+                                 );
+
+    XtTranslations ptr = XtParseTranslationTable(translations);
+    m_drawingArea = (WXWidget)XtVaCreateWidget
+                              (
+                               name,
+                               xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
+                               XmNunitType, XmPIXELS,
+                               // XmNresizePolicy, XmRESIZE_ANY,
+                               XmNresizePolicy, XmRESIZE_NONE,
+                               XmNmarginHeight, 0,
+                               XmNmarginWidth, 0,
+                               XmNtranslations, ptr,
+                               NULL
+                              );
+    XtFree((char *) ptr);
+
+#if 0
+    if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
+    {
         ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
         XtOverrideTranslations ((Widget) m_drawingArea, ptr);
         XtFree ((char *) ptr);
         ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
         XtOverrideTranslations ((Widget) m_drawingArea, ptr);
         XtFree ((char *) ptr);
-        }
-    */
-    
+    }
+#endif // 0
+
     wxAddWindowToTable((Widget) m_drawingArea, this);
     wxAddWindowToTable((Widget) m_scrolledWindow, this);
     wxAddWindowToTable((Widget) m_drawingArea, this);
     wxAddWindowToTable((Widget) m_scrolledWindow, this);
-    
-    /*
-    * This order is very important in Motif 1.2.1
-    *
-    */
-    
+
+    // This order is very important in Motif 1.2.1
     XtRealizeWidget ((Widget) m_scrolledWindow);
     XtRealizeWidget ((Widget) m_drawingArea);
     XtManageChild ((Widget) m_drawingArea);
     XtRealizeWidget ((Widget) m_scrolledWindow);
     XtRealizeWidget ((Widget) m_drawingArea);
     XtManageChild ((Widget) m_drawingArea);
-    
-    XtOverrideTranslations ((Widget) m_drawingArea,
-        ptr = XtParseTranslationTable ("<Configure>: resize()"));
+
+    ptr = XtParseTranslationTable("<Configure>: resize()");
+    XtOverrideTranslations((Widget) m_drawingArea, ptr);
     XtFree ((char *) ptr);
     XtFree ((char *) ptr);
-    
+
     XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
     XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
     XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
     XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
-    
-    /* TODO?
+
+    // TODO?
+#if 0
     display = XtDisplay (scrolledWindow);
     xwindow = XtWindow (drawingArea);
     display = XtDisplay (scrolledWindow);
     xwindow = XtWindow (drawingArea);
-    */
-    
-    XtAddEventHandler ((Widget) m_drawingArea, PointerMotionHintMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask,
-        False, (XtEventHandler) wxCanvasEnterLeave, (XtPointer) this);
-    
-    // Scrolled widget needs to have its colour changed or we get
-    // a little blue square where the scrollbars abutt
+#endif // 0
+
+    XtAddEventHandler(
+                      (Widget)m_drawingArea,
+                       PointerMotionHintMask | EnterWindowMask |
+                       LeaveWindowMask | FocusChangeMask,
+                       False,
+                       (XtEventHandler) wxCanvasEnterLeave,
+                       (XtPointer) this
+                     );
+
+    // Scrolled widget needs to have its colour changed or we get a little blue
+    // square where the scrollbars abutt
     wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
     DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
     DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
     wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
     DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
     DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
-    
-    XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) 0, (Widget) 0, (Widget) m_drawingArea);
-    
-    /*
+
+    XmScrolledWindowSetAreas(
+                             (Widget)m_scrolledWindow,
+                             (Widget) 0, (Widget) 0,
+                             (Widget) m_drawingArea);
+
+#if 0
     if (m_hScrollBar)
     if (m_hScrollBar)
-    XtRealizeWidget ((Widget) m_hScrollBar);
+        XtRealizeWidget ((Widget) m_hScrollBar);
     if (m_vScrollBar)
     if (m_vScrollBar)
-    XtRealizeWidget ((Widget) m_vScrollBar);
-    */
-    
-    // Without this, the cursor may not be restored properly
-    // (e.g. in splitter sample).
+        XtRealizeWidget ((Widget) m_vScrollBar);
+#endif // 0
+
+    // Without this, the cursor may not be restored properly (e.g. in splitter
+    // sample).
     SetCursor(*wxSTANDARD_CURSOR);
     SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
     SetSize(pos.x, pos.y, size.x, size.y);
     SetCursor(*wxSTANDARD_CURSOR);
     SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
     SetSize(pos.x, pos.y, size.x, size.y);
-    
+
     return TRUE;
 }
 
     return TRUE;
 }
 
+// Destructor
+wxWindow::~wxWindow()
+{
+    // Motif-specific actions first
+    WXWidget wMain = GetMainWidget();
+    if ( wMain )
+    {
+        // Removes event handlers
+        DetachWidget(wMain);
+    }
+
+    ClearUpdateRects();
+
+    // If m_drawingArea, we're a fully-fledged window with drawing area,
+    // scrollbars etc. (what wxCanvas used to be)
+    if ( m_drawingArea )
+    {
+        // Destroy children before destroying self
+        DestroyChildren();
+
+        if (m_backingPixmap)
+            XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
+
+        Widget w = (Widget) m_drawingArea;
+        wxDeleteWindowFromTable(w);
+
+        if (w)
+        {
+            XtDestroyWidget(w);
+        }
+
+        m_mainWidget = (WXWidget) 0;
+
+        // Only if we're _really_ a canvas (not a dialog box/panel)
+        if (m_scrolledWindow)
+        {
+            wxDeleteWindowFromTable((Widget) m_scrolledWindow);
+        }
+
+        UnmanageAndDestroy(m_hScrollBar);
+        UnmanageAndDestroy(m_vScrollBar);
+        UnmanageAndDestroy(m_scrolledWindow);
+
+        if (m_borderWidget)
+        {
+            XtDestroyWidget ((Widget) m_borderWidget);
+            m_borderWidget = (WXWidget) 0;
+        }
+    }
+
+    // Destroy the window
+    if (GetMainWidget())
+    {
+        // If this line (XtDestroyWidget) causes a crash, you may comment it out.
+        // Child widgets will get destroyed automatically when a frame
+        // or dialog is destroyed, but before that you may get some memory
+        // leaks and potential layout problems if you delete and then add
+        // child windows.
+        XtDestroyWidget((Widget) GetMainWidget());
+        SetMainWidget((WXWidget) NULL);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// scrollbar management
+// ----------------------------------------------------------------------------
+
 // Helper function
 void wxWindow::CreateScrollbar(int orientation)
 {
 // Helper function
 void wxWindow::CreateScrollbar(int orientation)
 {
-    if (!m_drawingArea)
-        return;
-    
+    wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
+
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
-    
+
     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
     {
     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
     {
@@ -471,7 +429,7 @@ void wxWindow::CreateScrollbar(int orientation)
             xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
             XmNorientation, XmHORIZONTAL,
             NULL);
             xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
             XmNorientation, XmHORIZONTAL,
             NULL);
-        //       XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+        //      XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
@@ -479,33 +437,33 @@ void wxWindow::CreateScrollbar(int orientation)
         XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
         XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
-        
+
         XtVaSetValues (hScrollBar,
             XmNincrement, 1,
             XmNvalue, 0,
             NULL);
         XtVaSetValues (hScrollBar,
             XmNincrement, 1,
             XmNvalue, 0,
             NULL);
-        
+
         m_hScrollBar = (WXWidget) hScrollBar;
         m_hScrollBar = (WXWidget) hScrollBar;
-        
+
         wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
         DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
         wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
         DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
-        
+
         XtRealizeWidget(hScrollBar);
         XtRealizeWidget(hScrollBar);
-        
+
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) m_hScrollBar,
             NULL);
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) m_hScrollBar,
             NULL);
-        
+
         m_hScroll = TRUE;
     }
         m_hScroll = TRUE;
     }
-    
+
     if (orientation == wxVERTICAL)
     {
         Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
             xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
             XmNorientation, XmVERTICAL,
             NULL);
     if (orientation == wxVERTICAL)
     {
         Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
             xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
             XmNorientation, XmVERTICAL,
             NULL);
-        //       XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+        //      XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
@@ -513,32 +471,32 @@ void wxWindow::CreateScrollbar(int orientation)
         XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
         XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
-        
+
         XtVaSetValues (vScrollBar,
             XmNincrement, 1,
             XmNvalue, 0,
             NULL);
         XtVaSetValues (vScrollBar,
             XmNincrement, 1,
             XmNvalue, 0,
             NULL);
-        
+
         m_vScrollBar = (WXWidget) vScrollBar;
         wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
         DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
         m_vScrollBar = (WXWidget) vScrollBar;
         wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
         DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
-        
+
         XtRealizeWidget(vScrollBar);
         XtRealizeWidget(vScrollBar);
-        
+
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) m_vScrollBar,
             NULL);
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) m_vScrollBar,
             NULL);
-        
+
         m_vScroll = TRUE;
     }
         m_vScroll = TRUE;
     }
-    
+
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
 }
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
 }
+
 void wxWindow::DestroyScrollbar(int orientation)
 {
 void wxWindow::DestroyScrollbar(int orientation)
 {
-    if (!m_drawingArea)
-        return;
-    
+    wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
+
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
@@ -549,13 +507,13 @@ void wxWindow::DestroyScrollbar(int orientation)
         }
         m_hScrollBar = (WXWidget) 0;
         m_hScroll = FALSE;
         }
         m_hScrollBar = (WXWidget) 0;
         m_hScroll = FALSE;
-        
+
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) 0,
             NULL);
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) 0,
             NULL);
-        
+
     }
     }
-    
+
     if (orientation == wxVERTICAL)
     {
         if (m_vScrollBar)
     if (orientation == wxVERTICAL)
     {
         if (m_vScrollBar)
@@ -564,758 +522,316 @@ void wxWindow::DestroyScrollbar(int orientation)
         }
         m_vScrollBar = (WXWidget) 0;
         m_vScroll = TRUE;
         }
         m_vScrollBar = (WXWidget) 0;
         m_vScroll = TRUE;
-        
+
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) 0,
             NULL);
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) 0,
             NULL);
-        
+
     }
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
 }
 
     }
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
 }
 
+// ---------------------------------------------------------------------------
+// basic operations
+// ---------------------------------------------------------------------------
+
 void wxWindow::SetFocus()
 {
 void wxWindow::SetFocus()
 {
-    XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
+    Widget wMain = (Widget) GetMainWidget();
+    XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
     XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
 }
 
     XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
 }
 
-void wxWindow::Enable(bool enable)
+// Get the window with the focus
+wxWindow *wxWindow::FindFocus()
 {
 {
-    if (GetMainWidget())
+    // TODO Problems:
+    // (1) Can there be multiple focussed widgets in an application?
+    // In which case we need to find the top-level window that's
+    // currently active.
+    // (2) The widget with the focus may not be in the widget table
+    // depending on which widgets I put in the table
+    wxWindow *winFocus = (wxWindow *)NULL;
+    for ( wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
+          node;
+          node = node->GetNext() )
     {
     {
-        XtSetSensitive((Widget) GetMainWidget(), enable);
-        XmUpdateDisplay((Widget) GetMainWidget());
+        wxWindow *win = node->GetData();
+
+        Widget w = XmGetFocusWidget ((Widget) win->GetTopWidget());
+
+        if (w != (Widget) NULL)
+        {
+            winFocus = wxGetWindowFromTable(w);
+            if ( winFocus )
+                break;
+        }
     }
     }
-}
 
 
-void wxWindow::CaptureMouse()
-{
-    if (m_winCaptured)
-        return;
-    
-    if (GetMainWidget())
-        XtAddGrab((Widget) GetMainWidget(), TRUE, FALSE);
-    
-    m_winCaptured = TRUE;
+    return winFocus;
 }
 
 }
 
-void wxWindow::ReleaseMouse()
+void wxWindow::Enable(bool enable)
 {
 {
-    if (!m_winCaptured)
-        return;
-    
-    if (GetMainWidget())
-        XtRemoveGrab((Widget) GetMainWidget());
-    m_winCaptured = FALSE;
-}
+    if ( !wxWindowBase::Enable(enable) )
+        return FALSE;
 
 
-// Push/pop event handler (i.e. allow a chain of event handlers
-// be searched)
-void wxWindow::PushEventHandler(wxEvtHandler *handler)
-{
-    handler->SetNextHandler(GetEventHandler());
-    SetEventHandler(handler);
+    Widget wMain = GetMainWidget();
+    if ( wMain )
+    {
+        XtSetSensitive(wMain, enable);
+        XmUpdateDisplay(wMain);
+    }
+
+    return TRUE;
 }
 
 }
 
-wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
+bool wxWindow::Show(bool show)
 {
 {
-    if ( GetEventHandler() )
+    if ( !wxWindowBase::Show(show) )
+        return FALSE;
+
+    if (m_borderWidget || m_scrolledWindow)
     {
     {
-        wxEvtHandler *handlerA = GetEventHandler();
-        wxEvtHandler *handlerB = handlerA->GetNextHandler();
-        handlerA->SetNextHandler(NULL);
-        SetEventHandler(handlerB);
-        if ( deleteHandler )
-        {
-            delete handlerA;
-            return NULL;
-        }
-        else
-            return handlerA;
+        MapOrUnmap(m_drawingArea, show);
+        MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
     }
     else
     }
     else
-        return NULL;
-}
+    {
+        if ( !MapOrUnmap(GetTopWidget(), show) )
+            MapOrUnmap(GetMainWidget(), show);
+    }
+
+#if 0
+    Window xwin = (Window) GetXWindow();
+    Display *xdisp = (Display*) GetXDisplay();
+    if (show)
+        XMapWindow(xdisp, xwin);
+    else
+        XUnmapWindow(xdisp, xwin);
+#endif
 
 
-#if    wxUSE_DRAG_AND_DROP
+    return TRUE;
+}
 
 
-void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
+// Raise the window to the top of the Z order
+void wxWindow::Raise()
 {
 {
-    if ( m_pDropTarget != 0 ) {
-        delete m_pDropTarget;
-    }
-    
-    m_pDropTarget = pDropTarget;
-    if ( m_pDropTarget != 0 )
-    {
-        // TODO
-    }
+    Widget wTop = (Widget) GetTopWidget();
+    Window window = XtWindow(wTop);
+    XRaiseWindow(XtDisplay(wTop), window);
 }
 
 }
 
-#endif
+// Lower the window to the bottom of the Z order
+void wxWindow::Lower()
+{
+    Widget wTop = (Widget) GetTopWidget();
+    Window window = XtWindow(wTop);
+    XLowerWindow(XtDisplay(wTop), window);
+}
 
 
-// Old style file-manager drag&drop
-void wxWindow::DragAcceptFiles(bool accept)
+void wxWindow::SetTitle( const wxString& title)
 {
 {
-    // TODO
+    SetWindowText(GetHwnd(), title.c_str());
 }
 
 }
 
-// Get total size
-void wxWindow::GetSize(int *x, int *y) const
+wxString wxWindow::GetTitle() const
 {
 {
-    if (m_drawingArea)
-    {
-        CanvasGetSize(x, y);
-        return;
-    }
-    
-    Widget widget = (Widget) GetTopWidget();
-    Dimension xx, yy;
-    XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
-    *x = xx; *y = yy;
+    return wxGetWindowText(GetHWND());
 }
 
 }
 
-void wxWindow::GetPosition(int *x, int *y) const
+void wxWindow::CaptureMouse()
 {
 {
-    if (m_drawingArea)
-    {
-        CanvasGetPosition(x, y);
+    if ( m_winCaptured )
         return;
         return;
-    }
-    Widget widget = (Widget) GetTopWidget();
-    Position xx, yy;
-    XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
-    
-    // We may be faking the client origin.
-    // So a window that's really at (0, 30) may appear
-    // (to wxWin apps) to be at (0, 0).
-    if (GetParent())
-    {
-        wxPoint pt(GetParent()->GetClientAreaOrigin());
-        xx -= pt.x;
-        yy -= pt.y;
-    }
-    
-    *x = xx; *y = yy;
+
+    Widget wMain = GetMainWidget();
+    if ( wMain )
+        XtAddGrab(wMain, TRUE, FALSE);
+
+    m_winCaptured = TRUE;
 }
 
 }
 
-void wxWindow::ScreenToClient(int *x, int *y) const
+void wxWindow::ReleaseMouse()
 {
 {
-    Widget widget = (Widget) GetClientWidget();
-    Display *display = XtDisplay((Widget) GetMainWidget());
-    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
-    Window thisWindow = XtWindow(widget);
-    
-    Window childWindow;
-    int xx = *x;
-    int yy = *y;
-    XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
+    if ( !m_winCaptured )
+        return;
+
+    Widget wMain = GetMainWidget();
+    if ( wMain )
+        XtRemoveGrab(wMain);
+
+    m_winCaptured = FALSE;
 }
 
 }
 
-void wxWindow::ClientToScreen(int *x, int *y) const
+bool wxWindow::SetFont(const wxFont& font)
 {
 {
-    Widget widget = (Widget) GetClientWidget();
-    Display *display = XtDisplay(widget);
-    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
-    Window thisWindow = XtWindow(widget);
-    
-    Window childWindow;
-    int xx = *x;
-    int yy = *y;
-    XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
+    if ( !wxWindowBase::SetFont(font) )
+    {
+        // nothing to do
+        return FALSE;
+    }
+
+    ChangeFont();
+
+    return TRUE;
 }
 
 }
 
-void wxWindow::SetCursor(const wxCursor& cursor)
+bool wxWindow::SetCursor(const wxCursor& cursor)
 {
 {
-    m_windowCursor = cursor;
-    if (m_windowCursor.Ok())
+    if ( !wxWindowBase::SetCursor(cursor) )
     {
     {
-        WXDisplay *dpy = GetXDisplay();
-        WXCursor x_cursor = ((wxCursor&)cursor).GetXCursor(dpy);
-        
-        Widget w = (Widget) GetMainWidget();
-        Window win = XtWindow(w);
-        XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
+        // no change
+        return FALSE;
     }
     }
-}
 
 
+    wxASSERT_MSG( m_cursor.Ok(),
+                  _T("cursor must be valid after call to the base version"));
 
 
-// Get size *available for subwindows* i.e. excluding menu bar etc.
-void wxWindow::GetClientSize(int *x, int *y) const
+    WXDisplay *dpy = GetXDisplay();
+    WXCursor x_cursor = m_cursor.GetXCursor(dpy);
+
+    Widget w = (Widget) GetMainWidget();
+    Window win = XtWindow(w);
+    XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
+}
+
+// Coordinates relative to the window
+void wxWindow::WarpPointer (int x, int y)
 {
 {
-    Widget widget = (Widget) GetClientWidget();
-    Dimension xx, yy;
-    XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
-    *x = xx; *y = yy;
+    Widget wClient = (Widget)GetClientWidget();
+
+    XWarpPointer(XtDisplay(wClient), None, XtWindow(wClient), 0, 0, 0, 0, x, y);
 }
 
 }
 
-void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+// ---------------------------------------------------------------------------
+// scrolling stuff
+// ---------------------------------------------------------------------------
+
+int wxWindow::GetScrollPos(int orient) const
 {
 {
-    // A bit of optimization to help sort out the flickers.
-    int oldX, oldY, oldW, oldH;
-    GetSize(& oldW, & oldH);
-    GetPosition(& oldX, & oldY);
-    
-    bool useOldPos = FALSE;
-    bool useOldSize = FALSE;
-    
-    if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
-        useOldPos = TRUE;
-    else if (x == oldX && y == oldY)
-        useOldPos = TRUE;
-    
-    if ((width == -1) && (height == -1))
-        useOldSize = TRUE;
-    else if (width == oldW && height == oldH)
-        useOldSize = TRUE;
-    
-    if (!wxNoOptimize::CanOptimize())
-    {
-        useOldSize = FALSE; useOldPos = FALSE;
-    }
-    
-    if (useOldPos && useOldSize)
-        return;
-    
-    if (m_drawingArea)
-    {
-        CanvasSetSize(x, y, width, height, sizeFlags);
-        return;
-    }
-    Widget widget = (Widget) GetTopWidget();
-    if (!widget)
-        return;
-    
-    bool managed = XtIsManaged( widget );
-    if (managed)
-        XtUnmanageChild(widget);
-    
-    int xx = x; int yy = y;
-    AdjustForParentClientOrigin(xx, yy, sizeFlags);
-    
-    if (!useOldPos)
-    {
-        if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-            XtVaSetValues(widget, XmNx, xx, NULL);
-        if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-            XtVaSetValues(widget, XmNy, yy, NULL);
-    }
-    if (!useOldSize)
+    if (orient == wxHORIZONTAL)
+        return m_scrollPosX;
+    else
+        return m_scrollPosY;
+
+#if 0
+    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
+    if (scrollBar)
     {
     {
-        if (width > -1)
-            XtVaSetValues(widget, XmNwidth, width, NULL);
-        if (height > -1)
-            XtVaSetValues(widget, XmNheight, height, NULL);
+        int pos;
+        XtVaGetValues(scrollBar, XmNvalue, &pos, NULL);
+        return pos;
     }
     }
-    
-    if (managed)
-        XtManageChild(widget);
-    
-    // How about this bit. Maybe we don't need to generate size events
-    // all the time -- they'll be generated when the window is sized anyway.
-    /*
-    wxSizeEvent sizeEvent(wxSize(width, height), GetId());
-    sizeEvent.SetEventObject(this);
-    
-      GetEventHandler()->ProcessEvent(sizeEvent);
-    */
+    else
+        return 0;
+#endif // 0
 }
 
 }
 
-void wxWindow::DoSetClientSize(int width, int height)
+// This now returns the whole range, not just the number of positions that we
+// can scroll.
+int wxWindow::GetScrollRange(int orient) const
 {
 {
-    if (m_drawingArea)
-    {
-        CanvasSetClientSize(width, height);
-        return;
-    }
-    
-    Widget widget = (Widget) GetTopWidget();
-    
-    if (width > -1)
-        XtVaSetValues(widget, XmNwidth, width, NULL);
-    if (height > -1)
-        XtVaSetValues(widget, XmNheight, height, NULL);
-    
-    wxSizeEvent sizeEvent(wxSize(width, height), GetId());
-    sizeEvent.SetEventObject(this);
-    
-    GetEventHandler()->ProcessEvent(sizeEvent);
+    Widget scrollBar = (Widget)GetScrollbar(orient);
+    wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
+
+    int range;
+    XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
+    return range;
 }
 
 }
 
-// For implementation purposes - sometimes decorations make the client area
-// smaller
-wxPoint wxWindow::GetClientAreaOrigin() const
+int wxWindow::GetScrollThumb(int orient) const
 {
 {
-    return wxPoint(0, 0);
+    Widget scrollBar = (Widget)GetScrollbar(orient);
+    wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
+
+    int thumb;
+    XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
+    return thumb;
 }
 
 }
 
-// Makes an adjustment to the window position (for example, a frame that has
-// a toolbar that it manages itself).
-void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
+void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
 {
 {
-    if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
+    Widget scrollBar = (Widget)GetScrollbar(orient);
+
+    if ( scrollBar )
     {
     {
-        wxPoint pt(GetParent()->GetClientAreaOrigin());
-        x += pt.x; y += pt.y;
+        XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
     }
     }
+
+    SetInternalScrollPos(orient, pos);
 }
 
 }
 
-bool wxWindow::Show(bool show)
+// New function that will replace some of the above.
+void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
+                            int range, bool WXUNUSED(refresh))
 {
 {
-    if (show)
+    int oldW, oldH;
+    GetSize(& oldW, & oldH);
+
+    if (range == 0)
+        range = 1;
+    if (thumbVisible == 0)
+        thumbVisible = 1;
+
+    if (thumbVisible > range)
+        thumbVisible = range;
+
+    // Save the old state to see if it changed
+    WXWidget oldScrollBar = GetScrollbar(orient);
+
+    if (orient == wxHORIZONTAL)
     {
     {
-        if (m_borderWidget || m_scrolledWindow)
+        if (thumbVisible == range)
         {
         {
-            if (m_drawingArea)
-                XtMapWidget((Widget) m_drawingArea);
-            XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
+            if (m_hScrollBar)
+                DestroyScrollbar(wxHORIZONTAL);
         }
         else
         {
         }
         else
         {
-            WXWidget topWidget = GetTopWidget();
-            if (GetTopWidget())
-                XtMapWidget((Widget) GetTopWidget());
-            else if (GetMainWidget())
-                XtMapWidget((Widget) GetMainWidget());
+            if (!m_hScrollBar)
+                CreateScrollbar(wxHORIZONTAL);
         }
     }
         }
     }
-    else
+    if (orient == wxVERTICAL)
     {
     {
-        if (m_borderWidget || m_scrolledWindow)
+        if (thumbVisible == range)
         {
         {
-            if (m_drawingArea)
-                XtUnmapWidget((Widget) m_drawingArea);
-            XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
+            if (m_vScrollBar)
+                DestroyScrollbar(wxVERTICAL);
         }
         else
         {
         }
         else
         {
-            if (GetTopWidget())
-                XtUnmapWidget((Widget) GetTopWidget());
-            else if (GetMainWidget())
-                XtUnmapWidget((Widget) GetMainWidget());
+            if (!m_vScrollBar)
+                CreateScrollbar(wxVERTICAL);
         }
     }
         }
     }
-    
-    /*
-    Window xwin = (Window) GetXWindow();
-    Display *xdisp = (Display*) GetXDisplay();
-    if (show)
-    XMapWindow(xdisp, xwin);
-    else
-    XUnmapWindow(xdisp, xwin);
-    */
-    
-    m_isShown = show;
-    
-    return TRUE;
-}
-
-bool wxWindow::IsShown() const
-{
-    return m_isShown;
-}
+    WXWidget newScrollBar =  GetScrollbar(orient);
 
 
-int wxWindow::GetCharHeight() const
-{
-    if (!m_windowFont.Ok())
-        return 0;
-    
-    WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
-    
-    int direction, ascent, descent;
-    XCharStruct overall;
-    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
-        &descent, &overall);
-    //  return (overall.ascent + overall.descent);
-    return (ascent + descent);
-}
-
-int wxWindow::GetCharWidth() const
-{
-    if (!m_windowFont.Ok())
-        return 0;
-    
-    WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
-    
-    int direction, ascent, descent;
-    XCharStruct overall;
-    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
-        &descent, &overall);
-    return overall.width;
-}
-
-/* Helper function for 16-bit fonts */
-static int str16len(const char *s)
-{
-    int count = 0;
-    
-    while (s[0] && s[1]) {
-        count++;
-        s += 2;
-    }
-    
-    return count;
-}
-
-void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
-                             int *descent, int *externalLeading, const wxFont *theFont, bool use16) const
-{
-    wxFont *fontToUse = (wxFont *)theFont;
-    if (!fontToUse)
-        fontToUse = (wxFont *) & m_windowFont;
-    
-    if (!fontToUse->Ok())
-        return;
-    
-    WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
-    
-    int direction, ascent, descent2;
-    XCharStruct overall;
-    int slen;
-    
-    if (use16) slen = str16len(string); else slen = strlen(string);
-    
-    if (use16)
-        XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
-        &ascent, &descent2, &overall);
-    else
-        XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
-        &ascent, &descent2, &overall);
-    
-    *x = (overall.width);
-    *y = (ascent + descent2);
-    if (descent)
-        *descent = descent2;
-    if (externalLeading)
-        *externalLeading = 0;
-}
-
-void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
-{
-    m_needsRefresh = TRUE;
-    Display *display = XtDisplay((Widget) GetMainWidget());
-    Window thisWindow = XtWindow((Widget) GetMainWidget());
-    
-    XExposeEvent dummyEvent;
-    int width, height;
-    GetSize(&width, &height);
-    
-    dummyEvent.type = Expose;
-    dummyEvent.display = display;
-    dummyEvent.send_event = True;
-    dummyEvent.window = thisWindow;
-    if (rect)
-    {
-        dummyEvent.x = rect->x;
-        dummyEvent.y = rect->y;
-        dummyEvent.width = rect->width;
-        dummyEvent.height = rect->height;
-    }
-    else
-    {
-        dummyEvent.x = 0;
-        dummyEvent.y = 0;
-        dummyEvent.width = width;
-        dummyEvent.height = height;
-    }
-    dummyEvent.count = 0;
-    
-    if (eraseBack)
-    {
-        wxClientDC dc(this);
-        wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
-        dc.SetBackground(backgroundBrush);
-        if (rect)
-            dc.Clear(*rect);
-        else
-            dc.Clear();
-    }
-    
-    XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
-}
-
-// Responds to colour changes: passes event on to children.
-void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
-{
-    wxNode *node = GetChildren().First();
-    while ( node )
-    {
-        // Only propagate to non-top-level windows
-        wxWindow *win = (wxWindow *)node->Data();
-        if ( win->GetParent() )
-        {
-            wxSysColourChangedEvent event2;
-            event.m_eventObject = win;
-            win->GetEventHandler()->ProcessEvent(event2);
-        }
-        
-        node = node->Next();
-    }
-}
-
-// This can be called by the app (or wxWindows) to do default processing for the current
-// event. Save message/event info in wxWindow so they can be used in this function.
-long wxWindow::Default()
-{
-    // TODO
-    return 0;
-}
-
-void wxWindow::InitDialog()
-{
-    wxInitDialogEvent event(GetId());
-    event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent(event);
-}
-
-// Default init dialog behaviour is to transfer data to window
-void wxWindow::OnInitDialog(wxInitDialogEvent& event)
-{
-    TransferDataToWindow();
-}
-
-// Caret manipulation
-void wxWindow::CreateCaret(int w, int h)
-{
-    m_caretWidth = w;
-    m_caretHeight = h;
-    m_caretEnabled = TRUE;
-}
-
-void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
-{
-    // TODO
-}
-
-void wxWindow::ShowCaret(bool show)
-{
-    // TODO
-}
-
-void wxWindow::DestroyCaret()
-{
-    // TODO
-    m_caretEnabled = FALSE;
-}
-
-void wxWindow::SetCaretPos(int x, int y)
-{
-    // TODO
-}
-
-void wxWindow::GetCaretPos(int *x, int *y) const
-{
-    // TODO
-}
-
-wxWindow *wxGetActiveWindow()
-{
-    // TODO
-    return NULL;
-}
-
-void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
-{
-    m_minSizeX = minW;
-    m_minSizeY = minH;
-    m_maxSizeX = maxW;
-    m_maxSizeY = maxH;
-    
-    if (!this->IsKindOf(CLASSINFO(wxFrame)))
-        return;
-    
-    wxFrame *frame = (wxFrame *)this;
-    Widget widget = (Widget) frame->GetShellWidget();
-    
-    if (minW > -1)
-        XtVaSetValues(widget, XmNminWidth, minW, NULL);
-    if (minH > -1)
-        XtVaSetValues(widget, XmNminHeight, minH, NULL);
-    if (maxW > -1)
-        XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
-    if (maxH > -1)
-        XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
-    if (incW > -1)
-        XtVaSetValues(widget, XmNwidthInc, incW, NULL);
-    if (incH > -1)
-        XtVaSetValues(widget, XmNheightInc, incH, NULL);
-}
-
-void wxWindow::Centre(int direction)
-{
-    int x, y, width, height, panel_width, panel_height, new_x, new_y;
-    
-    wxWindow *father = (wxWindow *)GetParent();
-    if (!father)
-        return;
-    
-    father->GetClientSize(&panel_width, &panel_height);
-    GetSize(&width, &height);
-    GetPosition(&x, &y);
-    
-    new_x = -1;
-    new_y = -1;
-    
-    if (direction & wxHORIZONTAL)
-        new_x = (int)((panel_width - width)/2);
-    
-    if (direction & wxVERTICAL)
-        new_y = (int)((panel_height - height)/2);
-    
-    SetSize(new_x, new_y, -1, -1);
-    
-}
-
-// Coordinates relative to the window
-void wxWindow::WarpPointer (int x, int y)
-{
-    XWarpPointer (XtDisplay((Widget) GetClientWidget()), None, XtWindow((Widget) GetClientWidget()), 0, 0, 0, 0, x, y);
-}
-
-void wxWindow::OnEraseBackground(wxEraseEvent& event)
-{
-    // TODO
-    Default();
-}
-
-int wxWindow::GetScrollPos(int orient) const
-{
-    if (orient == wxHORIZONTAL)
-        return m_scrollPosX;
-    else
-        return m_scrollPosY;
-        /*
-        Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
-        if (scrollBar)
-        {
-        int pos;
-        XtVaGetValues(scrollBar,
-        XmNvalue, &pos, NULL);
-        return pos;
-        }
-        else
-        return 0;
-    */
-}
-
-// This now returns the whole range, not just the number
-// of positions that we can scroll.
-int wxWindow::GetScrollRange(int orient) const
-{
-    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
-    if (scrollBar)
-    {
-        int range;
-        XtVaGetValues(scrollBar,
-            XmNmaximum, &range, NULL);
-        return range;
-    }
-    else
-        return 0;
-}
-
-int wxWindow::GetScrollThumb(int orient) const
-{
-    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
-    if (scrollBar)
-    {
-        int thumb;
-        XtVaGetValues(scrollBar,
-            XmNsliderSize, &thumb, NULL);
-        return thumb;
-    }
-    else
-        return 0;
-}
-
-void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
-{
-    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
-    if (scrollBar)
-    {
-        XtVaSetValues (scrollBar,
-            XmNvalue, pos,
-            NULL);
-    }
-    if (orient == wxHORIZONTAL)
-        m_scrollPosX = pos;
-    else
-        m_scrollPosY = pos;
-    
-}
-
-// New function that will replace some of the above.
-void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
-                            int range, bool WXUNUSED(refresh))
-{
-    int oldW, oldH;
-    GetSize(& oldW, & oldH);
-    
-    if (range == 0)
-        range = 1;
-    if (thumbVisible == 0)
-        thumbVisible = 1;
-    
-    if (thumbVisible > range)
-        thumbVisible = range;
-    
-    // Save the old state to see if it changed
-    WXWidget oldScrollBar =  ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
-    
-    if (orient == wxHORIZONTAL)
-    {
-        if (thumbVisible == range)
-        {
-            if (m_hScrollBar)
-                DestroyScrollbar(wxHORIZONTAL);
-        }
-        else
-        {
-            if (!m_hScrollBar)
-                CreateScrollbar(wxHORIZONTAL);
-        }
-    }
-    if (orient == wxVERTICAL)
-    {
-        if (thumbVisible == range)
-        {
-            if (m_vScrollBar)
-                DestroyScrollbar(wxVERTICAL);
-        }
-        else
-        {
-            if (!m_vScrollBar)
-                CreateScrollbar(wxVERTICAL);
-        }
-    }
-    WXWidget newScrollBar =  ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
-    
     if (oldScrollBar != newScrollBar)
     {
     if (oldScrollBar != newScrollBar)
     {
-        // This is important! Without it, scrollbars misbehave
-        // badly.
+        // This is important! Without it, scrollbars misbehave badly.
         XtUnrealizeWidget((Widget) m_scrolledWindow);
         XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
         XtRealizeWidget((Widget) m_scrolledWindow);
         XtManageChild((Widget) m_scrolledWindow);
     }
         XtUnrealizeWidget((Widget) m_scrolledWindow);
         XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
         XtRealizeWidget((Widget) m_scrolledWindow);
         XtManageChild((Widget) m_scrolledWindow);
     }
-    
+
     if (newScrollBar)
     if (newScrollBar)
+    {
         XtVaSetValues((Widget) newScrollBar,
         XmNvalue, pos,
         XmNminimum, 0,
         XmNmaximum, range,
         XmNsliderSize, thumbVisible,
         NULL);
         XtVaSetValues((Widget) newScrollBar,
         XmNvalue, pos,
         XmNminimum, 0,
         XmNmaximum, range,
         XmNsliderSize, thumbVisible,
         NULL);
-    
-    if (orient == wxHORIZONTAL)
-        m_scrollPosX = pos;
-    else
-        m_scrollPosY = pos;
-    
+    }
+
+    SetInternalScrollPos(orient, pos);
+
     int newW, newH;
     GetSize(& newW, & newH);
     int newW, newH;
     GetSize(& newW, & newH);
-    
+
     // Adjusting scrollbars can resize the canvas accidentally
     if (newW != oldW || newH != oldH)
         SetSize(-1, -1, oldW, oldH);
     // Adjusting scrollbars can resize the canvas accidentally
     if (newW != oldW || newH != oldH)
         SetSize(-1, -1, oldW, oldH);
@@ -1324,7 +840,6 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
 // Does a physical scroll
 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 {
 // Does a physical scroll
 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 {
-    //  cerr << "Scrolling. delta = " << dx << ", " << dy << endl;
     int x, y, w, h;
     if (rect)
     {
     int x, y, w, h;
     if (rect)
     {
@@ -1337,36 +852,33 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         x = 0; y = 0;
         GetClientSize(& w, & h);
     }
         x = 0; y = 0;
         GetClientSize(& w, & h);
     }
-    
-    int x1 = (dx >= 0) ? x : x - dx ;
+
+    int x1 = (dx >= 0) ? x : x - dx;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);
     int h1 = h - abs(dy);
     int x2 = (dx >= 0) ? x + dx : x;
     int y2 = (dy >= 0) ? y + dy : y;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);
     int h1 = h - abs(dy);
     int x2 = (dx >= 0) ? x + dx : x;
     int y2 = (dy >= 0) ? y + dy : y;
-    
+
     wxClientDC dc(this);
     wxClientDC dc(this);
-    
+
     dc.SetLogicalFunction (wxCOPY);
     dc.SetLogicalFunction (wxCOPY);
-    
+
     Widget widget = (Widget) GetMainWidget();
     Window window = XtWindow(widget);
     Display* display = XtDisplay(widget);
     Widget widget = (Widget) GetMainWidget();
     Window window = XtWindow(widget);
     Display* display = XtDisplay(widget);
-    
-    XCopyArea(display, window,
-        window, (GC) dc.GetGC(),
-        x1, y1,
-        w1, h1,
-        x2, y2);
-    
+
+    XCopyArea(display, window, window, (GC) dc.GetGC(),
+              x1, y1, w1, h1, x2, y2);
+
     dc.SetAutoSetting(TRUE);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetAutoSetting(TRUE);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
-    dc.SetBrush(brush); // ??
-    
-    // We'll add rectangles to the list of update rectangles
-    // according to which bits we've exposed.
+    dc.SetBrush(brush); // FIXME: needed?
+
+    // We'll add rectangles to the list of update rectangles according to which
+    // bits we've exposed.
     wxList updateRects;
     wxList updateRects;
-    
+
     if (dx > 0)
     {
         wxRect *rect = new wxRect;
     if (dx > 0)
     {
         wxRect *rect = new wxRect;
@@ -1374,103 +886,103 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->y = y;
         rect->width = dx;
         rect->height = h;
         rect->y = y;
         rect->width = dx;
         rect->height = h;
-        
+
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
-        
+
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
-        
+
         updateRects.Append((wxObject*) rect);
     }
     else if (dx < 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     else if (dx < 0)
     {
         wxRect *rect = new wxRect;
-        
+
         rect->x = x + w + dx;
         rect->y = y;
         rect->width = -dx;
         rect->height = h;
         rect->x = x + w + dx;
         rect->y = y;
         rect->width = -dx;
         rect->height = h;
-        
+
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width,
             rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width,
             rect->height);
-        
+
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
-        
+
         updateRects.Append((wxObject*) rect);
     }
     if (dy > 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     if (dy > 0)
     {
         wxRect *rect = new wxRect;
-        
+
         rect->x = x;
         rect->y = y;
         rect->width = w;
         rect->height = dy;
         rect->x = x;
         rect->y = y;
         rect->width = w;
         rect->height = dy;
-        
+
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
-        
+
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
-        
+
         updateRects.Append((wxObject*) rect);
     }
     else if (dy < 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     else if (dy < 0)
     {
         wxRect *rect = new wxRect;
-        
+
         rect->x = x;
         rect->y = y + h + dy;
         rect->width = w;
         rect->height = -dy;
         rect->x = x;
         rect->y = y + h + dy;
         rect->width = w;
         rect->height = -dy;
-        
+
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
-        
+
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
-        
+
         updateRects.Append((wxObject*) rect);
     }
     dc.SetBrush(wxNullBrush);
         updateRects.Append((wxObject*) rect);
     }
     dc.SetBrush(wxNullBrush);
-    
+
     // Now send expose events
     // Now send expose events
-    
+
     wxNode* node = updateRects.First();
     while (node)
     {
         wxRect* rect = (wxRect*) node->Data();
         XExposeEvent event;
     wxNode* node = updateRects.First();
     while (node)
     {
         wxRect* rect = (wxRect*) node->Data();
         XExposeEvent event;
-        
+
         event.type = Expose;
         event.display = display;
         event.send_event = True;
         event.window = window;
         event.type = Expose;
         event.display = display;
         event.send_event = True;
         event.window = window;
-        
+
         event.x = rect->x;
         event.y = rect->y;
         event.width = rect->width;
         event.height = rect->height;
         event.x = rect->x;
         event.y = rect->y;
         event.width = rect->width;
         event.height = rect->height;
-        
+
         event.count = 0;
         event.count = 0;
-        
+
         XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
         XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
-        
+
         node = node->Next();
         node = node->Next();
-        
+
     }
     }
-    
+
     // Delete the update rects
     node = updateRects.First();
     while (node)
     // Delete the update rects
     node = updateRects.First();
     while (node)
@@ -1483,864 +995,690 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
     XmUpdateDisplay((Widget) GetMainWidget());
 }
 
     XmUpdateDisplay((Widget) GetMainWidget());
 }
 
-void wxWindow::OnChar(wxKeyEvent& event)
-{
-    event.Skip();
-/* ??
-if ( event.KeyCode() == WXK_TAB ) {
-// propagate the TABs to the parent - it's up to it to decide what
-// to do with it
-if ( GetParent() ) {
-if ( GetParent()->ProcessEvent(event) )
-return;
-}
-}
-    */
-}
+// ---------------------------------------------------------------------------
+// drag and drop
+// ---------------------------------------------------------------------------
 
 
-void wxWindow::OnKeyDown(wxKeyEvent& event)
-{
-    event.Skip();
-}
+#if wxUSE_DRAG_AND_DROP
 
 
-void wxWindow::OnKeyUp(wxKeyEvent& event)
+void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
 {
 {
-    event.Skip();
+    // TODO
 }
 
 }
 
-void wxWindow::OnPaint(wxPaintEvent& event)
+#endif
+
+// Old style file-manager drag&drop
+void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
 {
 {
-    Default();
+    // TODO
 }
 
 }
 
-bool wxWindow::IsEnabled() const
+// ----------------------------------------------------------------------------
+// tooltips
+// ----------------------------------------------------------------------------
+
+#if wxUSE_TOOLTIPS
+
+void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
 {
 {
-    // TODO. Is this right?
-    // return XtGetSensitive((Widget) GetMainWidget());
-    return FALSE;
+    // TODO
 }
 
 }
 
-// Dialog support: override these and call
-// base class members to add functionality
-// that can't be done using validators.
-// NOTE: these functions assume that controls
-// are direct children of this window, not grandchildren
-// or other levels of descendant.
+#endif // wxUSE_TOOLTIPS
+
+// ---------------------------------------------------------------------------
+// moving and resizing
+// ---------------------------------------------------------------------------
 
 
-// Transfer values to controls. If returns FALSE,
-// it's an application error (pops up a dialog)
-bool wxWindow::TransferDataToWindow()
+bool wxWindow::PreResize()
 {
 {
-    wxNode *node = GetChildren().First();
-    while ( node )
-    {
-        wxWindow *child = (wxWindow *)node->Data();
-        if ( child->GetValidator() &&
-            !child->GetValidator()->TransferToWindow() )
-        {
-            wxLogError("Could not transfer data to window.");
-            return FALSE;
-        }
-        
-        node = node->Next();
-    }
     return TRUE;
 }
 
     return TRUE;
 }
 
-// Transfer values from controls. If returns FALSE,
-// validation failed: don't quit
-bool wxWindow::TransferDataFromWindow()
+// Get total size
+void wxWindow::GetSize(int *x, int *y) const
 {
 {
-    wxNode *node = GetChildren().First();
-    while ( node )
+    if (m_drawingArea)
     {
     {
-        wxWindow *child = (wxWindow *)node->Data();
-        if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
-        {
-            return FALSE;
-        }
-        
-        node = node->Next();
+        CanvasGetSize(x, y);
+        return;
     }
     }
-    return TRUE;
+
+    Widget widget = (Widget) GetTopWidget();
+    Dimension xx, yy;
+    XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
+    *x = xx; *y = yy;
 }
 
 }
 
-bool wxWindow::Validate()
+void wxWindow::GetPosition(int *x, int *y) const
 {
 {
-    wxNode *node = GetChildren().First();
-    while ( node )
+    if (m_drawingArea)
     {
     {
-        wxWindow *child = (wxWindow *)node->Data();
-        if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
-        {
-            return FALSE;
-        }
-        
-        node = node->Next();
+        CanvasGetPosition(x, y);
+        return;
     }
     }
-    return TRUE;
-}
-
-// Get the window with the focus
-wxWindow *wxWindow::FindFocus()
-{
-    // TODO Problems:
-    // (1) Can there be multiple focussed widgets in an application?
-    // In which case we need to find the top-level window that's
-    // currently active.
-    // (2) The widget with the focus may not be in the widget table
-    // depending on which widgets I put in the table
+    Widget widget = (Widget) GetTopWidget();
+    Position xx, yy;
+    XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
 
 
-    wxNode *node = wxTopLevelWindows.First();
-    while (node)
+    // We may be faking the client origin. So a window that's really at (0, 30)
+    // may appear (to wxWin apps) to be at (0, 0).
+    if (GetParent())
     {
     {
-        wxWindow *win = (wxWindow *)node->Data();
-
-        Widget w = XmGetFocusWidget ((Widget) win->GetTopWidget()) ;
-
-        if (w != (Widget) NULL)
-        {
-            wxWindow* focusWin = wxGetWindowFromTable(w);
-            if (focusWin)
-                return focusWin;
-        }
-
-        node = node->Next();
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        xx -= pt.x;
+        yy -= pt.y;
     }
     }
-    return (wxWindow*) NULL;
+
+    *x = xx; *y = yy;
 }
 
 }
 
-void wxWindow::AddChild(wxWindow *child)
+void wxWindow::ScreenToClient(int *x, int *y) const
 {
 {
-    GetChildren().Append(child);
-    child->m_windowParent = this;
+    Widget widget = (Widget) GetClientWidget();
+    Display *display = XtDisplay((Widget) GetMainWidget());
+    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
+    Window thisWindow = XtWindow(widget);
+
+    Window childWindow;
+    int xx = *x;
+    int yy = *y;
+    XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
 }
 
 }
 
-void wxWindow::RemoveChild(wxWindow *child)
+void wxWindow::ClientToScreen(int *x, int *y) const
 {
 {
-    GetChildren().DeleteObject(child);
-    child->m_windowParent = NULL;
+    Widget widget = (Widget) GetClientWidget();
+    Display *display = XtDisplay(widget);
+    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
+    Window thisWindow = XtWindow(widget);
+
+    Window childWindow;
+    int xx = *x;
+    int yy = *y;
+    XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
 }
 
 }
 
-// Reparents this window to have the new parent.
-bool wxWindow::Reparent(wxWindow* WXUNUSED(parent))
+
+// Get size *available for subwindows* i.e. excluding menu bar etc.
+void wxWindow::GetClientSize(int *x, int *y) const
 {
 {
-    // For now, we indicate that this isn't implemented.
-    return FALSE;
+    Widget widget = (Widget) GetClientWidget();
+    Dimension xx, yy;
+    XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
+    *x = xx; *y = yy;
 }
 
 }
 
-void wxWindow::DestroyChildren()
+void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 {
 {
-    wxNode *node = GetChildren().First();
-    while (node)
+    // A bit of optimization to help sort out the flickers.
+    int oldX, oldY, oldW, oldH;
+    GetSize(& oldW, & oldH);
+    GetPosition(& oldX, & oldY);
+
+    bool useOldPos = FALSE;
+    bool useOldSize = FALSE;
+
+    if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
+        useOldPos = TRUE;
+    else if (x == oldX && y == oldY)
+        useOldPos = TRUE;
+
+    if ((width == -1) && (height == -1))
+        useOldSize = TRUE;
+    else if (width == oldW && height == oldH)
+        useOldSize = TRUE;
+
+    if (!wxNoOptimize::CanOptimize())
     {
     {
-        wxNode* next = node->Next();
-        wxWindow* child = (wxWindow*) node->Data();
-        delete child;
-        node = next;
+        useOldSize = FALSE; useOldPos = FALSE;
+    }
+
+    if (useOldPos && useOldSize)
+        return;
+
+    if (m_drawingArea)
+    {
+        CanvasSetSize(x, y, width, height, sizeFlags);
+        return;
+    }
+    Widget widget = (Widget) GetTopWidget();
+    if (!widget)
+        return;
+
+    bool managed = XtIsManaged( widget );
+    if (managed)
+        XtUnmanageChild(widget);
+
+    int xx = x; int yy = y;
+    AdjustForParentClientOrigin(xx, yy, sizeFlags);
+
+    if (!useOldPos)
+    {
+        if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+            XtVaSetValues(widget, XmNx, xx, NULL);
+        if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+            XtVaSetValues(widget, XmNy, yy, NULL);
+    }
+    if (!useOldSize)
+    {
+        if (width > -1)
+            XtVaSetValues(widget, XmNwidth, width, NULL);
+        if (height > -1)
+            XtVaSetValues(widget, XmNheight, height, NULL);
     }
     }
-    GetChildren().Clear();
+
+    if (managed)
+        XtManageChild(widget);
+
+    // How about this bit. Maybe we don't need to generate size events
+    // all the time -- they'll be generated when the window is sized anyway.
 #if 0
 #if 0
-    wxNode *node;
-    while ((node = GetChildren().First()) != (wxNode *)NULL) {
-        wxWindow *child;
-        if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
-            delete child;
-            if ( GetChildren().Member(child) )
-                delete node;
-        }
-    } /* while */
-#endif
+    wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+    sizeEvent.SetEventObject(this);
+
+      GetEventHandler()->ProcessEvent(sizeEvent);
+#endif // 0
 }
 
 }
 
-void wxWindow::MakeModal(bool modal)
+void wxWindow::DoSetClientSize(int width, int height)
 {
 {
-    // Disable all other windows
-    if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
+    if (m_drawingArea)
     {
     {
-        wxNode *node = wxTopLevelWindows.First();
-        while (node)
-        {
-            wxWindow *win = (wxWindow *)node->Data();
-            if (win != this)
-                win->Enable(!modal);
-            
-            node = node->Next();
-        }
+        CanvasSetClientSize(width, height);
+        return;
     }
     }
+
+    Widget widget = (Widget) GetTopWidget();
+
+    if (width > -1)
+        XtVaSetValues(widget, XmNwidth, width, NULL);
+    if (height > -1)
+        XtVaSetValues(widget, XmNheight, height, NULL);
+
+    wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+    sizeEvent.SetEventObject(this);
+
+    GetEventHandler()->ProcessEvent(sizeEvent);
 }
 
 }
 
-// If nothing defined for this, try the parent.
-// E.g. we may be a button loaded from a resource, with no callback function
-// defined.
-void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
+// For implementation purposes - sometimes decorations make the client area
+// smaller
+wxPoint wxWindow::GetClientAreaOrigin() const
 {
 {
-    if (GetEventHandler()->ProcessEvent(event) )
-        return;
-    if (m_windowParent)
-        m_windowParent->GetEventHandler()->OnCommand(win, event);
+    return wxPoint(0, 0);
 }
 
 }
 
-void wxWindow::SetConstraints(wxLayoutConstraints *c)
+// Makes an adjustment to the window position (for example, a frame that has
+// a toolbar that it manages itself).
+void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 {
 {
-    if (m_constraints)
-    {
-        UnsetConstraints(m_constraints);
-        delete m_constraints;
-    }
-    m_constraints = c;
-    if (m_constraints)
+    if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
     {
     {
-        // Make sure other windows know they're part of a 'meaningful relationship'
-        if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
-            m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
-            m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
-            m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
-            m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
-            m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
-            m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
-            m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-        if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
-            m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        x += pt.x; y += pt.y;
     }
 }
 
     }
 }
 
-// This removes any dangling pointers to this window
-// in other windows' constraintsInvolvedIn lists.
-void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
+void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
 {
 {
-    if (c)
+    m_minWidth = minW;
+    m_minHeight = minH;
+    m_maxWidth = maxW;
+    m_maxHeight = maxH;
+
+    wxFrame *frame = wxDynamicCast(this, wxFrame);
+    if ( !frame )
     {
     {
-        if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
-            c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
-            c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
-            c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
-            c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
-            c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
-            c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
-            c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-        if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
-            c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+        // TODO what about dialogs?
+        return;
     }
     }
-}
 
 
-// Back-pointer to other windows we're involved with, so if we delete
-// this window, we must delete any constraints we're involved with.
-void wxWindow::AddConstraintReference(wxWindow *otherWin)
-{
-    if (!m_constraintsInvolvedIn)
-        m_constraintsInvolvedIn = new wxList;
-    if (!m_constraintsInvolvedIn->Member(otherWin))
-        m_constraintsInvolvedIn->Append(otherWin);
+    Widget widget = (Widget) frame->GetShellWidget();
+
+    if (minW > -1)
+        XtVaSetValues(widget, XmNminWidth, minW, NULL);
+    if (minH > -1)
+        XtVaSetValues(widget, XmNminHeight, minH, NULL);
+    if (maxW > -1)
+        XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
+    if (maxH > -1)
+        XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
+    if (incW > -1)
+        XtVaSetValues(widget, XmNwidthInc, incW, NULL);
+    if (incH > -1)
+        XtVaSetValues(widget, XmNheightInc, incH, NULL);
 }
 
 }
 
-// REMOVE back-pointer to other windows we're involved with.
-void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
+// ---------------------------------------------------------------------------
+// text metrics
+// ---------------------------------------------------------------------------
+
+int wxWindow::GetCharHeight() const
 {
 {
-    if (m_constraintsInvolvedIn)
-        m_constraintsInvolvedIn->DeleteObject(otherWin);
+    wxCHECK_MSG( m_windowFont.Ok(), 0, "valid window font needed" );
+
+    WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
+
+    int direction, ascent, descent;
+    XCharStruct overall;
+    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+
+    //  return (overall.ascent + overall.descent);
+    return (ascent + descent);
 }
 
 }
 
-// Reset any constraints that mention this window
-void wxWindow::DeleteRelatedConstraints()
+int wxWindow::GetCharWidth() const
 {
 {
-    if (m_constraintsInvolvedIn)
-    {
-        wxNode *node = m_constraintsInvolvedIn->First();
-        while (node)
-        {
-            wxWindow *win = (wxWindow *)node->Data();
-            wxNode *next = node->Next();
-            wxLayoutConstraints *constr = win->GetConstraints();
-            
-            // Reset any constraints involving this window
-            if (constr)
-            {
-                constr->left.ResetIfWin((wxWindow *)this);
-                constr->top.ResetIfWin((wxWindow *)this);
-                constr->right.ResetIfWin((wxWindow *)this);
-                constr->bottom.ResetIfWin((wxWindow *)this);
-                constr->width.ResetIfWin((wxWindow *)this);
-                constr->height.ResetIfWin((wxWindow *)this);
-                constr->centreX.ResetIfWin((wxWindow *)this);
-                constr->centreY.ResetIfWin((wxWindow *)this);
-            }
-            delete node;
-            node = next;
-        }
-        delete m_constraintsInvolvedIn;
-        m_constraintsInvolvedIn = NULL;
-    }
+    wxCHECK_MSG( m_windowFont.Ok(), 0, "valid window font needed" );
+
+    WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
+
+    int direction, ascent, descent;
+    XCharStruct overall;
+    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+
+    return overall.width;
 }
 
 }
 
-void wxWindow::SetSizer(wxSizer *sizer)
+void wxWindow::GetTextExtent(const wxString& string,
+                             int *x, int *y,
+                             int *descent, int *externalLeading,
+                             const wxFont *theFont) const
 {
 {
-    m_windowSizer = sizer;
-    if (sizer)
-        sizer->SetSizerParent((wxWindow *)this);
+    wxFont *fontToUse = (wxFont *)theFont;
+    if (!fontToUse)
+        fontToUse = (wxFont *) & m_windowFont;
+
+    wxCHECK_RET( fontToUse.Ok(), "valid window font needed" );
+
+    WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
+
+    int direction, ascent, descent2;
+    XCharStruct overall;
+    int slen;
+
+#if 0
+    if (use16)
+        XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
+        &ascent, &descent2, &overall);
+#endif
+
+    XTextExtents((XFontStruct*) pFontStruct, string, slen,
+                 &direction, &ascent, &descent2, &overall);
+
+    if ( x )
+        *x = (overall.width);
+    if ( y )
+        *y = (ascent + descent2);
+    if (descent)
+        *descent = descent2;
+    if (externalLeading)
+        *externalLeading = 0;
 }
 
 }
 
-/*
-* New version
-*/
+// ----------------------------------------------------------------------------
+// painting
+// ----------------------------------------------------------------------------
 
 
-bool wxWindow::Layout()
+void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
 {
 {
-    if (GetConstraints())
-    {
-        int w, h;
-        GetClientSize(&w, &h);
-        GetConstraints()->width.SetValue(w);
-        GetConstraints()->height.SetValue(h);
-    }
-    
-    // If top level (one sizer), evaluate the sizer's constraints.
-    if (GetSizer())
+    m_needsRefresh = TRUE;
+    Display *display = XtDisplay((Widget) GetMainWidget());
+    Window thisWindow = XtWindow((Widget) GetMainWidget());
+
+    XExposeEvent dummyEvent;
+    int width, height;
+    GetSize(&width, &height);
+
+    dummyEvent.type = Expose;
+    dummyEvent.display = display;
+    dummyEvent.send_event = True;
+    dummyEvent.window = thisWindow;
+    if (rect)
     {
     {
-        int noChanges;
-        GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
-        GetSizer()->LayoutPhase1(&noChanges);
-        GetSizer()->LayoutPhase2(&noChanges);
-        GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
-        return TRUE;
+        dummyEvent.x = rect->x;
+        dummyEvent.y = rect->y;
+        dummyEvent.width = rect->width;
+        dummyEvent.height = rect->height;
     }
     else
     {
     }
     else
     {
-        // Otherwise, evaluate child constraints
-        ResetConstraints();   // Mark all constraints as unevaluated
-        DoPhase(1);           // Just one phase need if no sizers involved
-        DoPhase(2);
-        SetConstraintSizes(); // Recursively set the real window sizes
+        dummyEvent.x = 0;
+        dummyEvent.y = 0;
+        dummyEvent.width = width;
+        dummyEvent.height = height;
     }
     }
-    return TRUE;
-}
-
+    dummyEvent.count = 0;
 
 
-// Do a phase of evaluating constraints:
-// the default behaviour. wxSizers may do a similar
-// thing, but also impose their own 'constraints'
-// and order the evaluation differently.
-bool wxWindow::LayoutPhase1(int *noChanges)
-{
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
+    if (eraseBack)
     {
     {
-        return constr->SatisfyConstraints((wxWindow *)this, noChanges);
+        wxClientDC dc(this);
+        wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
+        dc.SetBackground(backgroundBrush);
+        if (rect)
+            dc.Clear(*rect);
+        else
+            dc.Clear();
     }
     }
-    else
-        return TRUE;
-}
 
 
-bool wxWindow::LayoutPhase2(int *noChanges)
-{
-    *noChanges = 0;
-    
-    // Layout children
-    DoPhase(1);
-    DoPhase(2);
-    return TRUE;
+    XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
 }
 
 }
 
-// Do a phase of evaluating child constraints
-bool wxWindow::DoPhase(int phase)
+void wxWindow::Clear()
 {
 {
-    int noIterations = 0;
-    int maxIterations = 500;
-    int noChanges = 1;
-    int noFailures = 0;
-    wxList succeeded;
-    while ((noChanges > 0) && (noIterations < maxIterations))
-    {
-        noChanges = 0;
-        noFailures = 0;
-        wxNode *node = GetChildren().First();
-        while (node)
-        {
-            wxWindow *child = (wxWindow *)node->Data();
-            if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
-            {
-                wxLayoutConstraints *constr = child->GetConstraints();
-                if (constr)
-                {
-                    if (succeeded.Member(child))
-                    {
-                    }
-                    else
-                    {
-                        int tempNoChanges = 0;
-                        bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
-                        noChanges += tempNoChanges;
-                        if (success)
-                        {
-                            succeeded.Append(child);
-                        }
-                    }
-                }
-            }
-            node = node->Next();
-        }
-        noIterations ++;
-    }
-    return TRUE;
+    wxClientDC dc(this);
+    wxBrush brush(GetBackgroundColour(), wxSOLID);
+    dc.SetBackground(brush);
+    dc.Clear();
 }
 
 }
 
-void wxWindow::ResetConstraints()
+void wxWindow::ClearUpdateRects()
 {
 {
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
-    {
-        constr->left.SetDone(FALSE);
-        constr->top.SetDone(FALSE);
-        constr->right.SetDone(FALSE);
-        constr->bottom.SetDone(FALSE);
-        constr->width.SetDone(FALSE);
-        constr->height.SetDone(FALSE);
-        constr->centreX.SetDone(FALSE);
-        constr->centreY.SetDone(FALSE);
-    }
-    wxNode *node = GetChildren().First();
+    wxNode* node = m_updateRects.First();
     while (node)
     {
     while (node)
     {
-        wxWindow *win = (wxWindow *)node->Data();
-        if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
-            win->ResetConstraints();
+        wxRect* rect = (wxRect*) node->Data();
+        delete rect;
         node = node->Next();
     }
         node = node->Next();
     }
+    m_updateRects.Clear();
 }
 
 }
 
-// Need to distinguish between setting the 'fake' size for
-// windows and sizers, and setting the real values.
-void wxWindow::SetConstraintSizes(bool recurse)
+void wxWindow::DoPaint()
 {
 {
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr && constr->left.GetDone() && constr->right.GetDone() &&
-        constr->width.GetDone() && constr->height.GetDone())
-    {
-        int x = constr->left.GetValue();
-        int y = constr->top.GetValue();
-        int w = constr->width.GetValue();
-        int h = constr->height.GetValue();
-        
-        // If we don't want to resize this window, just move it...
-        if ((constr->width.GetRelationship() != wxAsIs) ||
-            (constr->height.GetRelationship() != wxAsIs))
-        {
-            // Calls Layout() recursively. AAAGH. How can we stop that.
-            // Simply take Layout() out of non-top level OnSizes.
-            SizerSetSize(x, y, w, h);
-        }
-        else
-        {
-            SizerMove(x, y);
-        }
-    }
-    else if (constr)
+    //TODO : make a temporary gc so we can do the XCopyArea below
+    if (m_backingPixmap && !m_needsRefresh)
     {
     {
-        char *windowClass = this->GetClassInfo()->GetClassName();
-        
-        wxString winName;
-        if (GetName() == "")
-            winName = "unnamed";
-        else
-            winName = GetName();
-        wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
-        if (!constr->left.GetDone())
-            wxDebugMsg("  unsatisfied 'left' constraint.\n");
-        if (!constr->right.GetDone())
-            wxDebugMsg("  unsatisfied 'right' constraint.\n");
-        if (!constr->width.GetDone())
-            wxDebugMsg("  unsatisfied 'width' constraint.\n");
-        if (!constr->height.GetDone())
-            wxDebugMsg("  unsatisfied 'height' constraint.\n");
-        wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
-    }
-    
-    if (recurse)
-    {
-        wxNode *node = GetChildren().First();
-        while (node)
-        {
-            wxWindow *win = (wxWindow *)node->Data();
-            if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
-                win->SetConstraintSizes();
-            node = node->Next();
-        }
-    }
-}
+      wxPaintDC dc(this);
 
 
-// This assumes that all sizers are 'on' the same
-// window, i.e. the parent of this window.
-void wxWindow::TransformSizerToActual(int *x, int *y) const
-{
-    if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
-        m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
-        return;
-    
-    int xp, yp;
-    m_sizerParent->GetPosition(&xp, &yp);
-    m_sizerParent->TransformSizerToActual(&xp, &yp);
-    *x += xp;
-    *y += yp;
-}
+      GC tempGC = (GC) dc.GetBackingGC();
 
 
-void wxWindow::SizerSetSize(int x, int y, int w, int h)
-{
-    int xx = x;
-    int yy = y;
-    TransformSizerToActual(&xx, &yy);
-    SetSize(xx, yy, w, h);
-}
+      Widget widget = (Widget) GetMainWidget();
 
 
-void wxWindow::SizerMove(int x, int y)
-{
-    int xx = x;
-    int yy = y;
-    TransformSizerToActual(&xx, &yy);
-    Move(xx, yy);
-}
+      int scrollPosX = 0;
+      int scrollPosY = 0;
 
 
-// Only set the size/position of the constraint (if any)
-void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
-{
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
+      // We have to test whether it's a wxScrolledWindow (hack!) because
+      // otherwise we don't know how many pixels have been scrolled. We might
+      // solve this in the future by defining virtual wxWindow functions to get
+      // the scroll position in pixels. Or, each kind of scrolled window has to
+      // implement backing stores itself, using generic wxWindows code.
+      wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
+      if ( scrolledWindow )
+      {
+          int x, y;
+          scrolledWindow->CalcScrolledPosition(0, 0, &x, &y);
+
+          scrollPosX = - x;
+          scrollPosY = - y;
+      }
+
+      // TODO: This could be optimized further by only copying the areas in the
+      //       current update region.
+
+      // Only blit the part visible in the client area. The backing pixmap
+      // always starts at 0, 0 but we may be looking at only a portion of it.
+      wxSize clientArea = GetClientSize();
+      int toBlitX = m_pixmapWidth - scrollPosX;
+      int toBlitY = m_pixmapHeight - scrollPosY;
+
+      // Copy whichever is samller, the amount of pixmap we have to copy,
+      // or the size of the client area.
+      toBlitX = wxMin(toBlitX, clientArea.x);
+      toBlitY = wxMin(toBlitY, clientArea.y);
+
+      // Make sure we're not negative
+      toBlitX = wxMax(0, toBlitX);
+      toBlitY = wxMax(0, toBlitY);
+
+      XCopyArea
+      (
+       XtDisplay(widget),
+       (Pixmap) m_backingPixmap,
+       XtWindow (widget),
+       tempGC,
+       scrollPosX, scrollPosY, // Start at the scroll position
+       toBlitX, toBlitY,       // How much of the pixmap to copy
+       0, 0                    // Destination
+      );
+    }
+    else
     {
     {
-        if (x != -1)
-        {
-            constr->left.SetValue(x);
-            constr->left.SetDone(TRUE);
-        }
-        if (y != -1)
-        {
-            constr->top.SetValue(y);
-            constr->top.SetDone(TRUE);
-        }
-        if (w != -1)
-        {
-            constr->width.SetValue(w);
-            constr->width.SetDone(TRUE);
-        }
-        if (h != -1)
-        {
-            constr->height.SetValue(h);
-            constr->height.SetDone(TRUE);
-        }
+        // Set an erase event first
+        wxEraseEvent eraseEvent(GetId());
+        eraseEvent.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(eraseEvent);
+
+        wxPaintEvent event(GetId());
+        event.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(event);
+
+        m_needsRefresh = FALSE;
     }
 }
 
     }
 }
 
-void wxWindow::MoveConstraint(int x, int y)
+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
+
+// Responds to colour changes: passes event on to children.
+void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 {
 {
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
+    wxWindowList::Node *node = GetChildren().GetFirst();
+    while ( node )
     {
     {
-        if (x != -1)
-        {
-            constr->left.SetValue(x);
-            constr->left.SetDone(TRUE);
-        }
-        if (y != -1)
+        // Only propagate to non-top-level windows
+        wxWindow *win = node->GetData();
+        if ( win->GetParent() )
         {
         {
-            constr->top.SetValue(y);
-            constr->top.SetDone(TRUE);
+            wxSysColourChangedEvent event2;
+            event.m_eventObject = win;
+            win->GetEventHandler()->ProcessEvent(event2);
         }
         }
-    }
-}
 
 
-void wxWindow::GetSizeConstraint(int *w, int *h) const
-{
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
-    {
-        *w = constr->width.GetValue();
-        *h = constr->height.GetValue();
+        node = node->GetNext();
     }
     }
-    else
-        GetSize(w, h);
 }
 
 }
 
-void wxWindow::GetClientSizeConstraint(int *w, int *h) const
+void wxWindow::OnIdle(wxIdleEvent& event)
 {
 {
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
-    {
-        *w = constr->width.GetValue();
-        *h = constr->height.GetValue();
-    }
-    else
-        GetClientSize(w, h);
+    // This calls the UI-update mechanism (querying windows for
+    // menu/toolbar/control state information)
+    UpdateWindowUI();
 }
 
 }
 
-void wxWindow::GetPositionConstraint(int *x, int *y) const
-{
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
-    {
-        *x = constr->left.GetValue();
-        *y = constr->top.GetValue();
-    }
-    else
-        GetPosition(x, y);
-}
+// ----------------------------------------------------------------------------
+// accelerators
+// ----------------------------------------------------------------------------
 
 
-bool wxWindow::Close(bool force)
+bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
 {
 {
-    wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
-    event.SetEventObject(this);
-#if WXWIN_COMPATIBILITY
-    event.SetForce(force);
-#endif
-    event.SetCanVeto(!force);
-    
-    return GetEventHandler()->ProcessEvent(event);
-}
+    if (!m_acceleratorTable.Ok())
+        return FALSE;
 
 
-wxObject* wxWindow::GetChild(int number) const
-{
-    // Return a pointer to the Nth object in the window
-    wxNode *node = GetChildren().First();
-    int n = number;
-    while (node && n--)
-        node = node->Next() ;
-    if (node)
+    int count = m_acceleratorTable.GetCount();
+    wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
+    int i;
+    for (i = 0; i < count; i++)
     {
     {
-        wxObject *obj = (wxObject *)node->Data();
-        return(obj) ;
-    }
-    else
-        return NULL ;
-}
+        wxAcceleratorEntry* entry = & (entries[i]);
+        if (entry->MatchesEvent(event))
+        {
+            // Bingo, we have a match. Now find a control that matches the entry
+            // command id.
 
 
-void wxWindow::OnDefaultAction(wxControl *initiatingItem)
-{
-    // Obsolete function
-}
+            // Need to go up to the top of the window hierarchy, since it might
+            // be e.g. a menu item
+            wxWindow* parent = this;
+            while ( parent && !parent->IsTopLevel() )
+                parent = parent->GetParent();
 
 
-void wxWindow::Clear()
-{
-    wxClientDC dc(this);
-    wxBrush brush(GetBackgroundColour(), wxSOLID);
-    dc.SetBackground(brush);
-    dc.Clear();
-}
+            if (!parent)
+                return FALSE;
 
 
-// Fits the panel around the items
-void wxWindow::Fit()
-{
-    int maxX = 0;
-    int maxY = 0;
-    wxNode *node = GetChildren().First();
-    while ( node )
-    {
-        wxWindow *win = (wxWindow *)node->Data();
-        int wx, wy, ww, wh;
-        win->GetPosition(&wx, &wy);
-        win->GetSize(&ww, &wh);
-        if ( wx + ww > maxX )
-            maxX = wx + ww;
-        if ( wy + wh > maxY )
-            maxY = wy + wh;
-        
-        node = node->Next();
-    }
-    SetClientSize(maxX + 5, maxY + 5);
-}
+            wxFrame* frame = wxDynamicCast(parent, wxFrame);
+            if ( frame )
+            {
+                // Try for a menu command
+                if (frame->GetMenuBar())
+                {
+                    wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
+                    if (item)
+                    {
+                        wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
+                        commandEvent.SetEventObject(frame);
 
 
-void wxWindow::SetValidator(const wxValidator& validator)
-{
-    if ( m_windowValidator )
-        delete m_windowValidator;
-    m_windowValidator = (wxValidator*) validator.Clone();
-    
-    if ( m_windowValidator )
-        m_windowValidator->SetWindow(this) ;
-}
+                        // If ProcessEvent returns TRUE (it was handled), then
+                        // the calling code will skip the event handling.
+                        return frame->GetEventHandler()->ProcessEvent(commandEvent);
+                    }
+                }
+            }
 
 
-void wxWindow::SetClientObject( wxClientData *data )
-{
-    if (m_clientObject) delete m_clientObject;
-    m_clientObject = data;
-}
+            // Find a child matching the command id
+            wxWindow* child = parent->FindWindow(entry->GetCommand());
 
 
-wxClientData *wxWindow::GetClientObject()
-{
-    return m_clientObject;
-}
+            // No such child
+            if (!child)
+                return FALSE;
 
 
-void wxWindow::SetClientData( void *data )
-{
-    m_clientData = data;
-}
+            // Now we process those kinds of windows that we can.
+            // For now, only buttons.
+            if ( wxDynamicCast(child, wxButton) )
+            {
+                wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
+                commandEvent.SetEventObject(child);
+                return child->GetEventHandler()->ProcessEvent(commandEvent);
+            }
 
 
-void *wxWindow::GetClientData()
-{
-    return m_clientData;
-}
+            return FALSE;
+        } // matches event
+    }// for
 
 
-// Find a window by id or name
-wxWindow *wxWindow::FindWindow(long id)
-{
-    if ( GetId() == id)
-        return this;
-    
-    wxNode *node = GetChildren().First();
-    while ( node )
-    {
-        wxWindow *child = (wxWindow *)node->Data();
-        wxWindow *found = child->FindWindow(id);
-        if ( found )
-            return found;
-        node = node->Next();
-    }
-    return NULL;
+    // We didn't match the key event against an accelerator.
+    return FALSE;
 }
 
 }
 
-wxWindow *wxWindow::FindWindow(const wxString& name)
+// ============================================================================
+// Motif-specific stuff from here on
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// function which maintain the global hash table mapping Widgets to wxWindows
+// ----------------------------------------------------------------------------
+
+bool wxAddWindowToTable(Widget w, wxWindow *win)
 {
 {
-    if ( GetName() == name)
-        return this;
-    
-    wxNode *node = GetChildren().First();
-    while ( node )
+    wxWindow *oldItem = NULL;
+    if ((oldItem = (wxWindow *)gs_wxWidgetHashTable->Get ((long) w)))
     {
     {
-        wxWindow *child = (wxWindow *)node->Data();
-        wxWindow *found = child->FindWindow(name);
-        if ( found )
-            return found;
-        node = node->Next();
+        wxLogDebug("Widget table clash: new widget is %ld, %s",
+                   (long)w, win->GetClassInfo()->GetClassName());
+        return FALSE;
     }
     }
-    return NULL;
-}
 
 
-void wxWindow::OnIdle(wxIdleEvent& event)
-{
-    // This calls the UI-update mechanism (querying windows for
-    // menu/toolbar/control state information)
-    UpdateWindowUI();
-}
+    gs_wxWidgetHashTable->Put((long) w, win);
 
 
-// Raise the window to the top of the Z order
-void wxWindow::Raise()
-{
-    Window window = XtWindow((Widget) GetTopWidget());
-    XRaiseWindow(XtDisplay((Widget) GetTopWidget()), window);
+    return TRUE;
 }
 
 }
 
-// Lower the window to the bottom of the Z order
-void wxWindow::Lower()
+wxWindow *wxGetWindowFromTable(Widget w)
 {
 {
-    Window window = XtWindow((Widget) GetTopWidget());
-    XLowerWindow(XtDisplay((Widget) GetTopWidget()), window);
+    return (wxWindow *)gs_wxWidgetHashTable->Get((long) w);
 }
 
 }
 
-bool wxWindow::AcceptsFocus() const
+void wxDeleteWindowFromTable(Widget w)
 {
 {
-    return IsShown() && IsEnabled();
+    gs_wxWidgetHashTable->Delete((long)w);
 }
 
 }
 
-// Update region access
-wxRegion& wxWindow::GetUpdateRegion() const
-{
-    return (wxRegion&) m_updateRegion;
-}
+// ----------------------------------------------------------------------------
+// add/remove window from the table
+// ----------------------------------------------------------------------------
 
 
-bool wxWindow::IsExposed(int x, int y, int w, int h) const
+// Add to hash table, add event handler
+bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
+                             WXWidget formWidget, int x, int y, int width, int height)
 {
 {
-    return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
-}
+    wxAddWindowToTable((Widget) mainWidget, this);
+    if (CanAddEventHandler())
+    {
+        XtAddEventHandler((Widget) mainWidget,
+            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
+            False,
+            wxPanelItemEventHandler,
+            (XtPointer) this);
+    }
 
 
-bool wxWindow::IsExposed(const wxPoint& pt) const
-{
-    return (m_updateRegion.Contains(pt) != wxOutRegion);
-}
+    if (!formWidget)
+    {
+        XtTranslations ptr;
+        XtOverrideTranslations ((Widget) mainWidget,
+            ptr = XtParseTranslationTable ("<Configure>: resize()"));
+        XtFree ((char *) ptr);
+    }
 
 
-bool wxWindow::IsExposed(const wxRect& rect) const
-{
-    return (m_updateRegion.Contains(rect) != wxOutRegion);
-}
+    // Some widgets have a parent form widget, e.g. wxRadioBox
+    if (formWidget)
+    {
+        if (!wxAddWindowToTable((Widget) formWidget, this))
+            return FALSE;
 
 
-/*
-* Allocates control IDs
-*/
+        XtTranslations ptr;
+        XtOverrideTranslations ((Widget) formWidget,
+            ptr = XtParseTranslationTable ("<Configure>: resize()"));
+        XtFree ((char *) ptr);
+    }
 
 
-int wxWindow::NewControlId()
-{
-    static int s_controlId = 0;
-    s_controlId ++;
-    return s_controlId;
-}
+    if (x == -1)
+        x = 0;
+    if (y == -1)
+        y = 0;
+    SetSize (x, y, width, height);
 
 
-void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel)
-{
-    m_acceleratorTable = accel;
+    return TRUE;
 }
 
 }
 
-// All widgets should have this as their resize proc.
-// OnSize sent to wxWindow via client data.
-void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
+// Remove event handler, remove from hash table
+bool wxWindow::DetachWidget(WXWidget widget)
 {
 {
-    wxWindow *win = (wxWindow *)wxWidgetHashTable->Get((long)w);
-    if (!win)
-        return;
-    
-    if (win->PreResize())
+    if (CanAddEventHandler())
     {
     {
-        int width, height;
-        win->GetSize(&width, &height);
-        wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
-        sizeEvent.SetEventObject(win);
-        win->GetEventHandler()->ProcessEvent(sizeEvent);
+        XtRemoveEventHandler((Widget) widget,
+            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
+            False,
+            wxPanelItemEventHandler,
+            (XtPointer)this);
     }
     }
-}
 
 
-bool wxAddWindowToTable(Widget w, wxWindow *win)
-{
-    wxWindow *oldItem = NULL;
-    //  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
-    if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
-    {
-        wxLogError("Widget table clash: new widget is %ld, %s", (long)w, win->GetClassInfo()->GetClassName());
-        return FALSE;
-    }
-    
-    wxWidgetHashTable->Put ((long) w, win);
+    wxDeleteWindowFromTable((Widget) widget);
     return TRUE;
 }
 
     return TRUE;
 }
 
-wxWindow *wxGetWindowFromTable(Widget w)
-{
-    return (wxWindow *)wxWidgetHashTable->Get ((long) w);
-}
-
-void wxDeleteWindowFromTable(Widget w)
-{
-    wxWidgetHashTable->Delete((long)w);
-}
+// ----------------------------------------------------------------------------
+// Motif-specific accessors
+// ----------------------------------------------------------------------------
 
 
-// Get the underlying X window and display
+// Get the underlying X window
 WXWindow wxWindow::GetXWindow() const
 {
 WXWindow wxWindow::GetXWindow() const
 {
-    if (GetMainWidget())
-        return (WXWindow) XtWindow((Widget) GetMainWidget());
+    Widget wMain = GetMainWidget();
+    if ( wMain )
+        return (WXWindow) XtWindow(wMain);
     else
         return (WXWindow) 0;
 }
 
     else
         return (WXWindow) 0;
 }
 
+// Get the underlying X display
 WXDisplay *wxWindow::GetXDisplay() const
 {
 WXDisplay *wxWindow::GetXDisplay() const
 {
-    if (GetMainWidget())
-        return (WXDisplay*) XtDisplay((Widget) GetMainWidget());
+    Widget wMain = GetMainWidget();
+    if ( wMain )
+        return (WXDisplay*) XtDisplay(wMain);
     else
         return (WXDisplay*) NULL;
 }
     else
         return (WXDisplay*) NULL;
 }
@@ -2366,123 +1704,115 @@ WXWidget wxWindow::GetTopWidget() const
     return GetMainWidget();
 }
 
     return GetMainWidget();
 }
 
-void wxCanvasRepaintProc (Widget drawingArea, XtPointer clientData,
-                          XmDrawingAreaCallbackStruct * cbs)
+WXWidget wxWindow::GetLabelWidget() const
+{
+    return GetMainWidget();
+}
+
+// ----------------------------------------------------------------------------
+// Motif callbacks
+// ----------------------------------------------------------------------------
+
+// All widgets should have this as their resize proc.
+// OnSize sent to wxWindow via client data.
+void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
+{
+    wxWindow *win = wxGetWindowFromTable(w);
+    if (!win)
+        return;
+
+    if (win->PreResize())
+    {
+        int width, height;
+        win->GetSize(&width, &height);
+        wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
+        sizeEvent.SetEventObject(win);
+        win->GetEventHandler()->ProcessEvent(sizeEvent);
+    }
+}
+
+static void wxCanvasRepaintProc(Widget drawingArea,
+                                XtPointer clientData,
+                                XmDrawingAreaCallbackStruct * cbs)
 {
 {
-    if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))
+    if (!wxGetWindowFromTable(drawingArea))
         return;
         return;
-    
+
     XEvent * event = cbs->event;
     wxWindow * win = (wxWindow *) clientData;
     Display * display = (Display *) win->GetXDisplay();
     XEvent * event = cbs->event;
     wxWindow * win = (wxWindow *) clientData;
     Display * display = (Display *) win->GetXDisplay();
-    
+
     switch (event->type)
     {
     case Expose:
         {
             wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
                 event->xexpose.width, event->xexpose.height);
     switch (event->type)
     {
     case Expose:
         {
             wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
                 event->xexpose.width, event->xexpose.height);
-                /*
-                cout << "Expose proc. wxRect: " << rect->x << ", " << rect->y << ", ";
-                cout << rect->width << ", " << rect->height << "\n\n";
-            */
-            
+
             win->m_updateRects.Append((wxObject*) rect);
             win->m_updateRects.Append((wxObject*) rect);
-            
+
             if (event -> xexpose.count == 0)
             {
             if (event -> xexpose.count == 0)
             {
-             /*
+#if 0
                 wxPaintEvent event(win->GetId());
                 event.SetEventObject(win);
                 win->GetEventHandler()->ProcessEvent(event);
                 wxPaintEvent event(win->GetId());
                 event.SetEventObject(win);
                 win->GetEventHandler()->ProcessEvent(event);
-               */
-                
+#endif // 0
+
                 win->DoPaint();
                 win->ClearUpdateRects();
             }
             break;
         }
                 win->DoPaint();
                 win->ClearUpdateRects();
             }
             break;
         }
-    default:
-        {
-            cout << "\n\nNew Event ! is = " << event -> type << "\n";
-            break;
-        }
     }
 }
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
     }
 }
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
-void 
-wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event)
+static void wxCanvasEnterLeave(Widget drawingArea,
+                               XtPointer clientData,
+                               XCrossingEvent * event)
 {
     XmDrawingAreaCallbackStruct cbs;
     XEvent ev;
 {
     XmDrawingAreaCallbackStruct cbs;
     XEvent ev;
-    
-    //if (event->mode!=NotifyNormal)
-    //  return ;
-    
-    //  ev = *((XEvent *) event); // Causes Purify error (copying too many bytes)
+
     ((XCrossingEvent &) ev) = *event;
     ((XCrossingEvent &) ev) = *event;
-    
+
     cbs.reason = XmCR_INPUT;
     cbs.event = &ev;
     cbs.reason = XmCR_INPUT;
     cbs.event = &ev;
-    
-    wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
+
+    wxCanvasInputEvent(drawingArea, (XtPointer) NULL, &cbs);
 }
 
 // Fix to make it work under Motif 1.0 (!)
 }
 
 // Fix to make it work under Motif 1.0 (!)
-void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
+static void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
 {
 {
-#if   XmVersion<=1000
-    
+#if XmVersion <= 1000
     XmDrawingAreaCallbackStruct cbs;
     XEvent ev;
     XmDrawingAreaCallbackStruct cbs;
     XEvent ev;
-    
-    //ev.xbutton = *event;
+
     ev = *((XEvent *) event);
     cbs.reason = XmCR_INPUT;
     cbs.event = &ev;
     ev = *((XEvent *) event);
     cbs.reason = XmCR_INPUT;
     cbs.event = &ev;
-    
+
     wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
     wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
-#endif
+#endif // XmVersion <= 1000
 }
 
 }
 
-void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs)
+static void wxCanvasInputEvent(Widget drawingArea,
+                               XtPointer data,
+                               XmDrawingAreaCallbackStruct * cbs)
 {
 {
-    wxWindow *canvas = (wxWindow *) wxWidgetHashTable->Get ((long) (Widget) drawingArea);
+    wxWindow *canvas = wxGetWindowFromTable(drawingArea);
     XEvent local_event;
     XEvent local_event;
-    
+
     if (canvas==NULL)
     if (canvas==NULL)
-        return ;
-    
+        return;
+
     if (cbs->reason != XmCR_INPUT)
         return;
     if (cbs->reason != XmCR_INPUT)
         return;
-    
-    local_event = *(cbs->event);       // We must keep a copy!
-    
-  /*
-  switch (local_event.xany.type)
-  {
-  case EnterNotify:
-  cout << "EnterNotify\n";
-  break;
-  case LeaveNotify:
-  cout << "LeaveNotify\n";
-  break;
-  case ButtonPress:
-  cout << "ButtonPress\n";
-  break;
-  case ButtonRelease:
-  cout << "ButtonRelease\n";
-  break;
-  case MotionNotify:
-  cout << "MotionNotify\n";
-  break;
-  default:
-  cout << "Something else\n";
-  break;
-  }
-    */
-    
+
+    local_event = *(cbs->event);    // We must keep a copy!
+
     switch (local_event.xany.type)
     {
     case EnterNotify:
     switch (local_event.xany.type)
     {
     case EnterNotify:
@@ -2492,7 +1822,7 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
     case MotionNotify:
         {
             wxEventType eventType = wxEVT_NULL;
     case MotionNotify:
         {
             wxEventType eventType = wxEVT_NULL;
-            
+
             if (local_event.xany.type == EnterNotify)
             {
                 //if (local_event.xcrossing.mode!=NotifyNormal)
             if (local_event.xany.type == EnterNotify)
             {
                 //if (local_event.xcrossing.mode!=NotifyNormal)
@@ -2514,7 +1844,7 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                 {
                     Window root, child;
                     Display *dpy = XtDisplay (drawingArea);
                 {
                     Window root, child;
                     Display *dpy = XtDisplay (drawingArea);
-                    
+
                     XQueryPointer (dpy, XtWindow (drawingArea),
                         &root, &child,
                         &local_event.xmotion.x_root,
                     XQueryPointer (dpy, XtWindow (drawingArea),
                         &root, &child,
                         &local_event.xmotion.x_root,
@@ -2527,7 +1857,7 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                 {
                 }
             }
                 {
                 }
             }
-            
+
             else if (local_event.xany.type == ButtonPress)
             {
                 if (local_event.xbutton.button == Button1)
             else if (local_event.xany.type == ButtonPress)
             {
                 if (local_event.xbutton.button == Button1)
@@ -2564,33 +1894,33 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                     canvas->m_button3Pressed = FALSE;
                 }
             }
                     canvas->m_button3Pressed = FALSE;
                 }
             }
-            
+
             wxMouseEvent wxevent (eventType);
             wxevent.m_eventHandle = (char *) &local_event;
             wxMouseEvent wxevent (eventType);
             wxevent.m_eventHandle = (char *) &local_event;
-            
+
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
-                || (event_left_is_down (&local_event) 
+                || (event_left_is_down (&local_event)
                 && (eventType != wxEVT_LEFT_UP)));
             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
                 && (eventType != wxEVT_LEFT_UP)));
             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
-                || (event_middle_is_down (&local_event) 
+                || (event_middle_is_down (&local_event)
                 && (eventType != wxEVT_MIDDLE_UP)));
             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
                 && (eventType != wxEVT_MIDDLE_UP)));
             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
-                || (event_right_is_down (&local_event) 
+                || (event_right_is_down (&local_event)
                 && (eventType != wxEVT_RIGHT_UP)));
                 && (eventType != wxEVT_RIGHT_UP)));
-            
+
             wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
             wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
             wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
             wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
             wxevent.SetTimestamp(local_event.xbutton.time);
             wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
             wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
             wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
             wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
             wxevent.SetTimestamp(local_event.xbutton.time);
-            
+
             // Now check if we need to translate this event into a double click
             if (TRUE) // canvas->doubleClickAllowed)
             {
                 if (wxevent.ButtonDown())
                 {
             // Now check if we need to translate this event into a double click
             if (TRUE) // canvas->doubleClickAllowed)
             {
                 if (wxevent.ButtonDown())
                 {
-                    long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay()) ;
-                    
+                    long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
+
                     // get button and time-stamp
                     int button = 0;
                     if      (wxevent.LeftDown())   button = 1;
                     // get button and time-stamp
                     int button = 0;
                     if      (wxevent.LeftDown())   button = 1;
@@ -2613,11 +1943,11 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                         case wxEVT_RIGHT_DOWN:
                             wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
                             break;
                         case wxEVT_RIGHT_DOWN:
                             wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
                             break;
-                            
+
                         default :
                             break;
                         }
                         default :
                             break;
                         }
-                        
+
                     }
                     else
                     {
                     }
                     else
                     {
@@ -2627,33 +1957,36 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                     }
                 }
             }
                     }
                 }
             }
-            
+
             wxevent.SetId(canvas->GetId());
             wxevent.SetEventObject(canvas);
             wxevent.m_x = local_event.xbutton.x;
             wxevent.m_y = local_event.xbutton.y;
             canvas->GetEventHandler()->ProcessEvent (wxevent);
             wxevent.SetId(canvas->GetId());
             wxevent.SetEventObject(canvas);
             wxevent.m_x = local_event.xbutton.x;
             wxevent.m_y = local_event.xbutton.y;
             canvas->GetEventHandler()->ProcessEvent (wxevent);
-            /*
+#if 0
             if (eventType == wxEVT_ENTER_WINDOW ||
             if (eventType == wxEVT_ENTER_WINDOW ||
-            eventType == wxEVT_LEAVE_WINDOW ||
-            eventType == wxEVT_MOTION
-            )
-            return;
-            */
+                    eventType == wxEVT_LEAVE_WINDOW ||
+                    eventType == wxEVT_MOTION
+               )
+                return;
+#endif // 0
             break;
       }
     case KeyPress:
         {
             KeySym keySym;
             break;
       }
     case KeyPress:
         {
             KeySym keySym;
-            // XComposeStatus compose;
-            // (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
+#if 0
+            XComposeStatus compose;
+            (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
+#endif // 0
+
             (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
 
             wxEventType eventType = wxEVT_CHAR;
 
             wxKeyEvent event (eventType);
             (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
 
             wxEventType eventType = wxEVT_CHAR;
 
             wxKeyEvent event (eventType);
-            
+
             if (local_event.xkey.state & ShiftMask)
                 event.m_shiftDown = TRUE;
             if (local_event.xkey.state & ControlMask)
             if (local_event.xkey.state & ShiftMask)
                 event.m_shiftDown = TRUE;
             if (local_event.xkey.state & ControlMask)
@@ -2665,14 +1998,14 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
             event.SetEventObject(canvas);
             event.m_keyCode = id;
             event.SetTimestamp(local_event.xkey.time);
             event.SetEventObject(canvas);
             event.m_keyCode = id;
             event.SetTimestamp(local_event.xkey.time);
-            
+
             if (id > -1)
             {
                 // Implement wxFrame::OnCharHook by checking ancestor.
                 wxWindow *parent = canvas->GetParent();
                 while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
                     parent = parent->GetParent();
             if (id > -1)
             {
                 // Implement wxFrame::OnCharHook by checking ancestor.
                 wxWindow *parent = canvas->GetParent();
                 while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
                     parent = parent->GetParent();
-                
+
                 if (parent)
                 {
                     event.SetEventType(wxEVT_CHAR_HOOK);
                 if (parent)
                 {
                     event.SetEventType(wxEVT_CHAR_HOOK);
@@ -2689,7 +2022,7 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
                 {
                   event.SetEventType(wxEVT_CHAR);
                   canvas->GetEventHandler()->ProcessEvent (event);
                 {
                   event.SetEventType(wxEVT_CHAR);
                   canvas->GetEventHandler()->ProcessEvent (event);
-               }
+        }
             }
             break;
         }
             }
             break;
         }
@@ -2698,9 +2031,9 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
             KeySym keySym;
             (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
             KeySym keySym;
             (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
-            
+
             wxKeyEvent event (wxEVT_KEY_UP);
             wxKeyEvent event (wxEVT_KEY_UP);
-            
+
             if (local_event.xkey.state & ShiftMask)
                 event.m_shiftDown = TRUE;
             if (local_event.xkey.state & ControlMask)
             if (local_event.xkey.state & ShiftMask)
                 event.m_shiftDown = TRUE;
             if (local_event.xkey.state & ControlMask)
@@ -2712,7 +2045,7 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
             event.SetEventObject(canvas);
             event.m_keyCode = id;
             event.SetTimestamp(local_event.xkey.time);
             event.SetEventObject(canvas);
             event.m_keyCode = id;
             event.SetTimestamp(local_event.xkey.time);
-            
+
             if (id > -1)
             {
                 canvas->GetEventHandler()->ProcessEvent (event);
             if (id > -1)
             {
                 canvas->GetEventHandler()->ProcessEvent (event);
@@ -2744,74 +2077,138 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
     }
 }
 
     }
 }
 
-void wxWindow::DoPaint()
+static void wxPanelItemEventHandler(Widget    wid,
+                                    XtPointer client_data,
+                                    XEvent*   event,
+                                    Boolean  *continueToDispatch)
 {
 {
-    //TODO : make a temporary gc so we can do the XCopyArea below
-    if (m_backingPixmap && !m_needsRefresh)
-    {
-      wxPaintDC dc(this);
+    // Widget can be a label or the actual widget.
 
 
-      GC tempGC = (GC) dc.GetBackingGC();
+    wxWindow *window = wxGetWindowFromTable(drawingArea);
+    if (window)
+    {
+        wxMouseEvent wxevent(0);
+        if (wxTranslateMouseEvent(wxevent, window, wid, event))
+        {
+            window->GetEventHandler()->ProcessEvent(wxevent);
+        }
+    }
 
 
-      Widget widget = (Widget) GetMainWidget();
+    // TODO: probably the key to allowing default behaviour to happen. Say we
+    // set a m_doDefault flag to FALSE at the start of this function. Then in
+    // e.g. wxWindow::OnMouseEvent we can call Default() which sets this flag to
+    // TRUE, indicating that default processing can happen. Thus, behaviour can
+    // appear to be overridden just by adding an event handler and not calling
+    // wxWindow::OnWhatever. ALSO, maybe we can use this instead of the current
+    // way of handling drawing area events, to simplify things.
+    *continueToDispatch = True;
+}
 
 
-      int scrollPosX = 0;
-      int scrollPosY = 0;
+static void wxScrollBarCallback(Widget scrollbar,
+                                XtPointer clientData,
+                                XmScaleCallbackStruct *cbs)
+{
+    Widget scrolledWindow = XtParent (scrollbar);
+    wxWindow *win = wxGetWindowFromTable(scrollbar);
+    int orientation = (int) clientData;
 
 
-      // We have to test whether it's a wxScrolledWindow (hack!)
-      // because otherwise we don't know how many pixels have been
-      // scrolled. We might solve this in the future by defining
-      // virtual wxWindow functions to get the scroll position in pixels.
-      // Or, each kind of scrolled window has to implement backing
-      // stores itself, using generic wxWindows code.
-      if (this->IsKindOf(CLASSINFO(wxScrolledWindow)))
-      {
-          wxScrolledWindow* scrolledWindow = (wxScrolledWindow*) this;
-          int x, y;
-          scrolledWindow->CalcScrolledPosition(0, 0, & x, & y);
+    wxEventType eventType = wxEVT_NULL;
+    switch (cbs->reason)
+    {
+    case XmCR_INCREMENT:
+        {
+            eventType = wxEVT_SCROLL_LINEDOWN;
+            break;
+        }
+    case XmCR_DECREMENT:
+        {
+            eventType = wxEVT_SCROLL_LINEUP;
+            break;
+        }
+    case XmCR_DRAG:
+        {
+            eventType = wxEVT_SCROLL_THUMBTRACK;
+            break;
+        }
+    case XmCR_VALUE_CHANGED:
+        {
+            // TODO: Should this be intercepted too, or will it cause
+            // duplicate events?
+            eventType = wxEVT_SCROLL_THUMBTRACK;
+            break;
+        }
+    case XmCR_PAGE_INCREMENT:
+        {
+            eventType = wxEVT_SCROLL_PAGEDOWN;
+            break;
+        }
+    case XmCR_PAGE_DECREMENT:
+        {
+            eventType = wxEVT_SCROLL_PAGEUP;
+            break;
+        }
+    case XmCR_TO_TOP:
+        {
+            eventType = wxEVT_SCROLL_TOP;
+            break;
+        }
+    case XmCR_TO_BOTTOM:
+        {
+            eventType = wxEVT_SCROLL_BOTTOM;
+            break;
+        }
+    default:
+        {
+            // Should never get here
+            wxFAIL_MSG("Unknown scroll event.");
+            break;
+        }
+    }
 
 
-          scrollPosX = - x;
-          scrollPosY = - y;
-      }
+    wxScrollEvent event(eventType, win->GetId());
+    event.SetEventObject(win);
+    event.SetPosition(cbs->value);
+    event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
 
 
-      // TODO: This could be optimized further by only copying the
-      // areas in the current update region.
+    win->GetEventHandler()->ProcessEvent(event);
+}
 
 
-      // Only blit the part visible in the client area. The backing pixmap
-      // always starts at 0, 0 but we may be looking at only a portion of it.
-      wxSize clientArea = GetClientSize();
-      int toBlitX = m_pixmapWidth - scrollPosX;
-      int toBlitY = m_pixmapHeight - scrollPosY;
+// For repainting arbitrary windows
+void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *)
+{
+    Window window;
+    Display *display;
 
 
-      // Copy whichever is samller, the amount of pixmap we have to copy,
-      // or the size of the client area.
-      toBlitX = wxMin(toBlitX, clientArea.x);
-      toBlitY = wxMin(toBlitY, clientArea.y);
+    wxWindow* win = wxGetWindowFromTable(w);
+    if (!win)
+        return;
 
 
-      // Make sure we're not negative
-      toBlitX = wxMax(0, toBlitX);
-      toBlitY = wxMax(0, toBlitY);
-    
-      XCopyArea (XtDisplay (widget), (Pixmap) m_backingPixmap, XtWindow (widget), tempGC,
-        scrollPosX, scrollPosY, // Start at the scroll position
-        toBlitX, toBlitY,       // How much of the pixmap to copy
-        0, 0);                  // Destination
-    }
-    else
+    switch(event -> type)
     {
     {
-        // Set an erase event first
-        wxEraseEvent eraseEvent(GetId());
-        eraseEvent.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(eraseEvent);
+    case Expose :
+        {
+            window = (Window) win -> GetXWindow();
+            display = (Display *) win -> GetXDisplay();
 
 
-        wxPaintEvent event(GetId());
-        event.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(event);
+            wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
+                event->xexpose.width, event->xexpose.height);
+            win->m_updateRects.Append((wxObject*) rect);
 
 
-        m_needsRefresh = FALSE;
+            if (event -> xexpose.count == 0)
+            {
+                win->DoPaint();
+
+                win->ClearUpdateRects();
+            }
+            break;
+        }
     }
 }
 
     }
 }
 
+// ----------------------------------------------------------------------------
+// CanvaseXXXSize() functions
+// ----------------------------------------------------------------------------
+
 // SetSize, but as per old wxCanvas (with drawing widget etc.)
 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
 {
 // SetSize, but as per old wxCanvas (with drawing widget etc.)
 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
 {
@@ -2819,38 +2216,38 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);
     GetPosition(& oldX, & oldY);
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);
     GetPosition(& oldX, & oldY);
-    
+
     bool useOldPos = FALSE;
     bool useOldSize = FALSE;
     bool useOldPos = FALSE;
     bool useOldSize = FALSE;
-    
+
     if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
         useOldPos = TRUE;
     else if (x == oldX && y == oldY)
         useOldPos = TRUE;
     if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
         useOldPos = TRUE;
     else if (x == oldX && y == oldY)
         useOldPos = TRUE;
-    
+
     if ((w == -1) && (h == -1))
         useOldSize = TRUE;
     else if (w == oldW && h == oldH)
         useOldSize = TRUE;
     if ((w == -1) && (h == -1))
         useOldSize = TRUE;
     else if (w == oldW && h == oldH)
         useOldSize = TRUE;
-    
+
     if (!wxNoOptimize::CanOptimize())
     {
         useOldSize = FALSE; useOldPos = FALSE;
     }
     if (!wxNoOptimize::CanOptimize())
     {
         useOldSize = FALSE; useOldPos = FALSE;
     }
-    
+
     if (useOldPos && useOldSize)
         return;
     if (useOldPos && useOldSize)
         return;
-    
+
     Widget drawingArea = (Widget) m_drawingArea;
     bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     Widget drawingArea = (Widget) m_drawingArea;
     bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
-    
+
     if (managed)
         XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
     if (managed)
         XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
-    
+
     int xx = x; int yy = y;
     AdjustForParentClientOrigin(xx, yy, sizeFlags);
     int xx = x; int yy = y;
     AdjustForParentClientOrigin(xx, yy, sizeFlags);
-    
+
     if (!useOldPos)
     {
         if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
     if (!useOldPos)
     {
         if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
@@ -2858,17 +2255,17 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
             XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
                 XmNx, xx, NULL);
         }
             XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
                 XmNx, xx, NULL);
         }
-        
+
         if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         {
             XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
                 XmNy, yy, NULL);
         }
     }
         if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         {
             XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
                 XmNy, yy, NULL);
         }
     }
-    
+
     if (!useOldSize)
     {
     if (!useOldSize)
     {
-        
+
         if (w > -1)
         {
             if (m_borderWidget)
         if (w > -1)
         {
             if (m_borderWidget)
@@ -2881,9 +2278,9 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
                     NULL);
                 w -= 2 * (thick + margin);
             }
                     NULL);
                 w -= 2 * (thick + margin);
             }
-            
+
             XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
             XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
-            
+
             Dimension spacing;
             Widget sbar;
             XtVaGetValues ((Widget) m_scrolledWindow,
             Dimension spacing;
             Widget sbar;
             XtVaGetValues ((Widget) m_scrolledWindow,
@@ -2895,9 +2292,9 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
                 XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
             else
                 wsbar = 0;
                 XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
             else
                 wsbar = 0;
-            
+
             w -= (spacing + wsbar);
             w -= (spacing + wsbar);
-            
+
             //      XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
         }
         if (h > -1)
             //      XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
         }
         if (h > -1)
@@ -2912,9 +2309,9 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
                     NULL);
                 h -= 2 * (thick + margin);
             }
                     NULL);
                 h -= 2 * (thick + margin);
             }
-            
+
             XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
             XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
-            
+
             Dimension spacing;
             Widget sbar;
             XtVaGetValues ((Widget) m_scrolledWindow,
             Dimension spacing;
             Widget sbar;
             XtVaGetValues ((Widget) m_scrolledWindow,
@@ -2926,265 +2323,112 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
                 XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
             else
                 wsbar = 0;
                 XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
             else
                 wsbar = 0;
-            
+
             h -= (spacing + wsbar);
             h -= (spacing + wsbar);
-            
+
             //      XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
             //      XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
-            
+
         }
     }
         }
     }
-    
+
     if (managed)
         XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
     if (managed)
         XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
-    
-    /*
+
+#if 0
     int ww, hh;
     GetClientSize (&ww, &hh);
     wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
     sizeEvent.SetEventObject(this);
     int ww, hh;
     GetClientSize (&ww, &hh);
     wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
     sizeEvent.SetEventObject(this);
-    
+
       GetEventHandler()->ProcessEvent(sizeEvent);
       GetEventHandler()->ProcessEvent(sizeEvent);
-    */
-    
+#endif // 0
 }
 
 void wxWindow::CanvasSetClientSize (int w, int h)
 {
     Widget drawingArea = (Widget) m_drawingArea;
 }
 
 void wxWindow::CanvasSetClientSize (int w, int h)
 {
     Widget drawingArea = (Widget) m_drawingArea;
-    
+
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
     XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
-    
+
     if (w > -1)
         XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
     if (h > -1)
         XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
     if (w > -1)
         XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
     if (h > -1)
         XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
-        /* TODO: is this necessary?
-        allowRepainting = FALSE;
-        
-          XSync (XtDisplay (drawingArea), FALSE);
-          XEvent event;
-          while (XtAppPending (wxTheApp->appContext))
-          {
-          XFlush (XtDisplay (drawingArea));
-          XtAppNextEvent (wxTheApp->appContext, &event);
-          XtDispatchEvent (&event);
-          }
-    */
-    
-    XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
-    
-    /* TODO
-    allowRepainting = TRUE;
-    DoRefresh ();
-    */
-    
-    /*
-    wxSizeEvent sizeEvent(wxSize(w, h), GetId());
-    sizeEvent.SetEventObject(this);
-    
-      GetEventHandler()->ProcessEvent(sizeEvent);
-    */
-}
-
-void wxWindow::CanvasGetClientSize (int *w, int *h) const
-{
-    // Must return the same thing that was set via SetClientSize
-    Dimension xx, yy;
-    XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
-    *w = xx;
-    *h = yy;
-}
-
-void wxWindow::CanvasGetSize (int *w, int *h) const
-{
-    Dimension xx, yy;
-    if ((Widget) m_borderWidget)
-        XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
-    else if ((Widget) m_scrolledWindow)
-        XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
-    else
-        XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
-    
-    *w = xx;
-    *h = yy;
-}
 
 
-void wxWindow::CanvasGetPosition (int *x, int *y) const
-{
-    Position xx, yy;
-    XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
-    
-    // We may be faking the client origin.
-    // So a window that's really at (0, 30) may appear
-    // (to wxWin apps) to be at (0, 0).
-    if (GetParent())
-    {
-        wxPoint pt(GetParent()->GetClientAreaOrigin());
-        xx -= pt.x;
-        yy -= pt.y;
-    }
-    
-    *x = xx;
-    *y = yy;
-}
+#if 0
+    // TODO: is this necessary?
+    allowRepainting = FALSE;
 
 
-// Add to hash table, add event handler
-bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
-                             WXWidget formWidget, int x, int y, int width, int height)
-{
-    wxAddWindowToTable((Widget) mainWidget, this);
-    if (CanAddEventHandler())
-    {
-        XtAddEventHandler((Widget) mainWidget,
-            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
-            False,
-            wxPanelItemEventHandler,
-            (XtPointer) this);
-    }
-    
-    if (!formWidget)
-    {
-        XtTranslations ptr;
-        XtOverrideTranslations ((Widget) mainWidget,
-            ptr = XtParseTranslationTable ("<Configure>: resize()"));
-        XtFree ((char *) ptr);
-    }
-    
-    // Some widgets have a parent form widget, e.g. wxRadioBox
-    if (formWidget)
-    {
-        if (!wxAddWindowToTable((Widget) formWidget, this))
-            return FALSE;
-        
-        XtTranslations ptr;
-        XtOverrideTranslations ((Widget) formWidget,
-            ptr = XtParseTranslationTable ("<Configure>: resize()"));
-        XtFree ((char *) ptr);
+    XSync (XtDisplay (drawingArea), FALSE);
+    XEvent event;
+    while (XtAppPending (wxTheApp->appContext))
+    {
+        XFlush (XtDisplay (drawingArea));
+        XtAppNextEvent (wxTheApp->appContext, &event);
+        XtDispatchEvent (&event);
     }
     }
-    
-    if (x == -1)
-        x = 0;
-    if (y == -1)
-        y = 0;
-    SetSize (x, y, width, height);
-    
-    return TRUE;
+#endif // 0
+
+    XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
+
+#if 0
+       allowRepainting = TRUE;
+       DoRefresh ();
+
+       wxSizeEvent sizeEvent(wxSize(w, h), GetId());
+       sizeEvent.SetEventObject(this);
+
+       GetEventHandler()->ProcessEvent(sizeEvent);
+#endif // 0
 }
 
 }
 
-// Remove event handler, remove from hash table
-bool wxWindow::DetachWidget(WXWidget widget)
+void wxWindow::CanvasGetClientSize (int *w, int *h) const
 {
 {
-    if (CanAddEventHandler())
-    {
-        XtRemoveEventHandler((Widget) widget,
-            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
-            False,
-            wxPanelItemEventHandler,
-            (XtPointer)this);
-    }
-    
-    wxDeleteWindowFromTable((Widget) widget);
-    return TRUE;
+    // Must return the same thing that was set via SetClientSize
+    Dimension xx, yy;
+    XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
+    *w = xx;
+    *h = yy;
 }
 
 }
 
-void wxPanelItemEventHandler (Widget    wid,
-                              XtPointer client_data,
-                              XEvent*   event,
-                              Boolean *continueToDispatch)
+void wxWindow::CanvasGetSize (int *w, int *h) const
 {
 {
-    // Widget can be a label or the actual widget.
-    
-    wxWindow *window = (wxWindow *)wxWidgetHashTable->Get((long)wid);
-    if (window)
-    {
-        wxMouseEvent wxevent(0);
-        if (wxTranslateMouseEvent(wxevent, window, wid, event))
-        {
-            window->GetEventHandler()->ProcessEvent(wxevent);
-        }
-    }
-    // TODO: probably the key to allowing default behaviour
-    // to happen.
-    // Say we set a m_doDefault flag to FALSE at the start of this
-    // function. Then in e.g. wxWindow::OnMouseEvent we can
-    // call Default() which sets this flag to TRUE, indicating
-    // that default processing can happen. Thus, behaviour can appear
-    // to be overridden just by adding an event handler and not calling
-    // wxWindow::OnWhatever.
-    // ALSO, maybe we can use this instead of the current way of handling
-    // drawing area events, to simplify things.
-    *continueToDispatch = True;
+    Dimension xx, yy;
+    if ((Widget) m_borderWidget)
+        XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
+    else if ((Widget) m_scrolledWindow)
+        XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
+    else
+        XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
+
+    *w = xx;
+    *h = yy;
 }
 
 }
 
-static void wxScrollBarCallback(Widget scrollbar, XtPointer clientData,
-                                XmScaleCallbackStruct *cbs)
+void wxWindow::CanvasGetPosition (int *x, int *y) const
 {
 {
-    Widget scrolledWindow = XtParent (scrollbar);
-    wxWindow *win = (wxWindow *) wxWidgetHashTable->Get ((long) scrolledWindow);
-    int orientation = (int) clientData;
-    
-    wxEventType eventType = wxEVT_NULL;
-    switch (cbs->reason)
+    Position xx, yy;
+    XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
+
+    // We may be faking the client origin.
+    // So a window that's really at (0, 30) may appear
+    // (to wxWin apps) to be at (0, 0).
+    if (GetParent())
     {
     {
-    case XmCR_INCREMENT:
-        {
-            eventType = wxEVT_SCROLL_LINEDOWN;
-            break;
-        }
-    case XmCR_DECREMENT:
-        {
-            eventType = wxEVT_SCROLL_LINEUP;
-            break;
-        }
-    case XmCR_DRAG:
-        {
-            eventType = wxEVT_SCROLL_THUMBTRACK;
-            break;
-        }
-    case XmCR_VALUE_CHANGED:
-        {
-            // TODO: Should this be intercepted too, or will it cause
-            // duplicate events?
-            eventType = wxEVT_SCROLL_THUMBTRACK;
-            break;
-        }
-    case XmCR_PAGE_INCREMENT:
-        {
-            eventType = wxEVT_SCROLL_PAGEDOWN;
-            break;
-        }
-    case XmCR_PAGE_DECREMENT:
-        {
-            eventType = wxEVT_SCROLL_PAGEUP;
-            break;
-        }
-    case XmCR_TO_TOP:
-        {
-            eventType = wxEVT_SCROLL_TOP;
-            break;
-        }
-    case XmCR_TO_BOTTOM:
-        {
-            eventType = wxEVT_SCROLL_BOTTOM;
-            break;
-        }
-    default:
-        {
-            // Should never get here
-            wxFAIL_MSG("Unknown scroll event.");
-            break;
-        }
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        xx -= pt.x;
+        yy -= pt.y;
     }
     }
-    
-    wxScrollEvent event(eventType, win->GetId());
-    event.SetEventObject(win);
-    event.SetPosition(cbs->value);
-    event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
-    
-    win->GetEventHandler()->ProcessEvent(event);
+
+    *x = xx;
+    *y = yy;
 }
 
 }
 
+// ----------------------------------------------------------------------------
+// TranslateXXXEvent() functions
+// ----------------------------------------------------------------------------
+
 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {
     switch (xevent->xany.type)
 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {
     switch (xevent->xany.type)
@@ -3196,7 +2440,7 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
     case MotionNotify:
         {
             wxEventType eventType = wxEVT_NULL;
     case MotionNotify:
         {
             wxEventType eventType = wxEVT_NULL;
-            
+
             if (xevent->xany.type == LeaveNotify)
             {
                 win->m_button1Pressed = FALSE;
             if (xevent->xany.type == LeaveNotify)
             {
                 win->m_button1Pressed = FALSE;
@@ -3246,16 +2490,16 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
                 else return FALSE;
             }
             else return FALSE;
                 else return FALSE;
             }
             else return FALSE;
-            
+
             wxevent.m_eventHandle = (char *)xevent;
             wxevent.SetEventType(eventType);
             wxevent.m_eventHandle = (char *)xevent;
             wxevent.SetEventType(eventType);
-            
+
             Position x1, y1;
             XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
             Position x1, y1;
             XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
-            
+
             int x2, y2;
             win->GetPosition(&x2, &y2);
             int x2, y2;
             win->GetPosition(&x2, &y2);
-            
+
             // The button x/y must be translated to wxWindows
             // window space - the widget might be a label or button,
             // within a form.
             // The button x/y must be translated to wxWindows
             // window space - the widget might be a label or button,
             // within a form.
@@ -3266,20 +2510,20 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
                 dx = x1;
                 dy = y1;
             }
                 dx = x1;
                 dy = y1;
             }
-            
+
             wxevent.m_x = xevent->xbutton.x + dx;
             wxevent.m_y = xevent->xbutton.y + dy;
             wxevent.m_x = xevent->xbutton.x + dx;
             wxevent.m_y = xevent->xbutton.y + dy;
-            
+
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
-                || (event_left_is_down (xevent) 
+                || (event_left_is_down (xevent)
                 && (eventType != wxEVT_LEFT_UP)));
             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
                 && (eventType != wxEVT_LEFT_UP)));
             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
-                || (event_middle_is_down (xevent) 
+                || (event_middle_is_down (xevent)
                 && (eventType != wxEVT_MIDDLE_UP)));
             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
                 && (eventType != wxEVT_MIDDLE_UP)));
             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
-                || (event_right_is_down (xevent) 
+                || (event_right_is_down (xevent)
                 && (eventType != wxEVT_RIGHT_UP)));
                 && (eventType != wxEVT_RIGHT_UP)));
-            
+
             wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
             wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
             return TRUE;
             wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
             wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
             return TRUE;
@@ -3295,13 +2539,15 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEve
     case KeyPress:
         {
             char buf[20];
     case KeyPress:
         {
             char buf[20];
-            
+
             KeySym keySym;
             KeySym keySym;
-            // XComposeStatus compose;
-            // (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
+#if 0
+            XComposeStatus compose;
+            (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
+#endif // 0
             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
-            
+
             if (xevent->xkey.state & ShiftMask)
                 wxevent.m_shiftDown = TRUE;
             if (xevent->xkey.state & ControlMask)
             if (xevent->xkey.state & ShiftMask)
                 wxevent.m_shiftDown = TRUE;
             if (xevent->xkey.state & ControlMask)
@@ -3313,10 +2559,10 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEve
             wxevent.SetEventObject(win);
             wxevent.m_keyCode = id;
             wxevent.SetTimestamp(xevent->xkey.time);
             wxevent.SetEventObject(win);
             wxevent.m_keyCode = id;
             wxevent.SetTimestamp(xevent->xkey.time);
-            
+
             wxevent.m_x = xevent->xbutton.x;
             wxevent.m_y = xevent->xbutton.y;
             wxevent.m_x = xevent->xbutton.x;
             wxevent.m_y = xevent->xbutton.y;
-            
+
             if (id > -1)
                 return TRUE;
             else
             if (id > -1)
                 return TRUE;
             else
@@ -3329,15 +2575,19 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEve
     return FALSE;
 }
 
     return FALSE;
 }
 
+// ----------------------------------------------------------------------------
+// Colour stuff
+// ----------------------------------------------------------------------------
+
 #define YAllocColor XAllocColor
 XColor g_itemColors[5];
 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
 {
     int result;
     static XmColorProc colorProc;
 #define YAllocColor XAllocColor
 XColor g_itemColors[5];
 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
 {
     int result;
     static XmColorProc colorProc;
-    
+
     result = wxNO_COLORS;
     result = wxNO_COLORS;
-    
+
     if (back)
     {
         g_itemColors[0].red = (((long) back->Red ()) << 8);
     if (back)
     {
         g_itemColors[0].red = (((long) back->Red ()) << 8);
@@ -3367,10 +2617,10 @@ int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
         if (result == wxNO_COLORS)
             result = wxFORE_COLORS;
     }
         if (result == wxNO_COLORS)
             result = wxFORE_COLORS;
     }
-    
+
     Display *dpy = display;
     Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
     Display *dpy = display;
     Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
-    
+
     if (back)
     {
         /* 5 Colours to allocate */
     if (back)
     {
         /* 5 Colours to allocate */
@@ -3384,30 +2634,30 @@ int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
         if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
             result = wxNO_COLORS;
     }
         if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
             result = wxNO_COLORS;
     }
-    
+
     return (result);
     return (result);
-    
+
 }
 
 }
 
-// Changes the foreground and background colours to be derived
-// from the current background colour.
-// To change the foreground colour, you must call SetForegroundColour
-// explicitly.
+// Changes the foreground and background colours to be derived from the current
+// background colour. To change the foreground colour, you must call
+// SetForegroundColour explicitly.
 void wxWindow::ChangeBackgroundColour()
 {
 void wxWindow::ChangeBackgroundColour()
 {
-    if (GetMainWidget())
-        DoChangeBackgroundColour(GetMainWidget(), m_backgroundColour);
-    
+    WXWidget mainWidget = GetMainWidget();
+    if ( mainWidget )
+        DoChangeBackgroundColour(mainWidget, m_backgroundColour);
+
     // This not necessary
 #if 0
     // This not necessary
 #if 0
-    
+
     if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
     {
         DoChangeBackgroundColour(m_scrolledWindow, m_backgroundColour);
         // Have to set the scrollbar colours back since
         // the scrolled window seemed to change them
     if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
     {
         DoChangeBackgroundColour(m_scrolledWindow, m_backgroundColour);
         // Have to set the scrollbar colours back since
         // the scrolled window seemed to change them
-        wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
-        
+        wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+
         if (m_hScrollBar)
             DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
         if (m_vScrollBar)
         if (m_hScrollBar)
             DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
         if (m_vScrollBar)
@@ -3418,14 +2668,14 @@ void wxWindow::ChangeBackgroundColour()
 
 void wxWindow::ChangeForegroundColour()
 {
 
 void wxWindow::ChangeForegroundColour()
 {
-    if (GetMainWidget())
-        DoChangeForegroundColour(GetMainWidget(), m_foregroundColour);
-    if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
+    WXWidget mainWidget = GetMainWidget();
+    if ( mainWidget )
+        DoChangeForegroundColour(mainWidget, m_foregroundColour);
+    if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
         DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
 }
 
 // Change a widget's foreground and background colours.
         DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
 }
 
 // Change a widget's foreground and background colours.
-
 void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
 {
     // When should we specify the foreground, if it's calculated
 void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
 {
     // When should we specify the foreground, if it's calculated
@@ -3436,24 +2686,27 @@ void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundCol
     // Therefore SetBackgroundColour computes the foreground colour, and
     // SetForegroundColour changes the foreground colour. The ordering is
     // important.
     // Therefore SetBackgroundColour computes the foreground colour, and
     // SetForegroundColour changes the foreground colour. The ordering is
     // important.
-    
-    XtVaSetValues ((Widget) widget,
-        XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
-        NULL);
+
+    Widget w = (Widget)widget;
+    XtVaSetValues(
+                  w,
+                  XmNforeground, foregroundColour.AllocColour(XtDisplay(w)),
+                  NULL
+                 );
 }
 
 void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
 {
     wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
         (wxColour*) NULL);
 }
 
 void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
 {
     wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
         (wxColour*) NULL);
-    
+
     XtVaSetValues ((Widget) widget,
         XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
         XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
         XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
         XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
         NULL);
     XtVaSetValues ((Widget) widget,
         XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
         XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
         XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
         XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
         NULL);
-    
+
     if (changeArmColour)
         XtVaSetValues ((Widget) widget,
         XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
     if (changeArmColour)
         XtVaSetValues ((Widget) widget,
         XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
@@ -3482,14 +2735,14 @@ void wxWindow::ChangeFont(bool keepOriginalSize)
     {
         int width, height, width1, height1;
         GetSize(& width, & height);
     {
         int width, height, width1, height1;
         GetSize(& width, & height);
-        
+
         // lesstif 0.87 hangs here
         // lesstif 0.87 hangs here
-#ifndef LESSTIF_VERSION        
+#ifndef LESSTIF_VERSION
         XtVaSetValues (w,
             XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
             NULL);
 #endif
         XtVaSetValues (w,
             XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
             NULL);
 #endif
-        
+
         GetSize(& width1, & height1);
         if (keepOriginalSize && (width != width1 || height != height1))
         {
         GetSize(& width1, & height1);
         if (keepOriginalSize && (width != width1 || height != height1))
         {
@@ -3498,100 +2751,19 @@ void wxWindow::ChangeFont(bool keepOriginalSize)
     }
 }
 
     }
 }
 
-void wxWindow::SetFont(const wxFont& font)
-{
-    m_windowFont = font;
-    ChangeFont();
-}
+// ----------------------------------------------------------------------------
+// global functions
+// ----------------------------------------------------------------------------
 
 
-void wxWindow::SetToolTip(const wxString& tooltip)
+wxWindow *wxGetActiveWindow()
 {
     // TODO
 {
     // TODO
+    return NULL;
 }
 
 }
 
-void wxWindow::ClearUpdateRects()
-{
-    wxNode* node = m_updateRects.First();
-    while (node)
-    {
-        wxRect* rect = (wxRect*) node->Data();
-        delete rect;
-        node = node->Next();
-    }
-    m_updateRects.Clear();
-}
-
-bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
-{
-    if (!m_acceleratorTable.Ok())
-        return FALSE;
-    
-    int count = m_acceleratorTable.GetCount();
-    wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
-    int i;
-    for (i = 0; i < count; i++)
-    {
-        wxAcceleratorEntry* entry = & (entries[i]);
-        if (entry->MatchesEvent(event))
-        {
-            // Bingo, we have a match. Now find a control
-            // that matches the entry command id.
-            
-            // Need to go up to the top of the window hierarchy,
-            // since it might be e.g. a menu item
-            wxWindow* parent = this;
-            while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)) && !parent->IsKindOf(CLASSINFO(wxDialog)))
-                parent = parent->GetParent();
-            
-            if (!parent)
-                return FALSE;
-            
-            if (parent->IsKindOf(CLASSINFO(wxFrame)))
-            {
-                // Try for a menu command
-                wxFrame* frame = (wxFrame*) parent;
-                if (frame->GetMenuBar())
-                {
-                    wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
-                    if (item)
-                    {
-                        wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
-                        commandEvent.SetEventObject(frame);
-                        
-                        // If ProcessEvent returns TRUE (it was handled), then
-                        // the calling code will skip the event handling.
-                        return frame->GetEventHandler()->ProcessEvent(commandEvent);
-                    }
-                }
-            }
-            
-            // Find a child matching the command id
-            wxWindow* child = parent->FindWindow(entry->GetCommand());
-            
-            // No such child
-            if (!child)
-                return FALSE;
-            
-            // Now we process those kinds of windows that we can.
-            // For now, only buttons.
-            if (child->IsKindOf(CLASSINFO(wxButton)))
-            {
-                wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
-                commandEvent.SetEventObject(child);
-                return child->GetEventHandler()->ProcessEvent(commandEvent);
-            }
-            
-            return FALSE;
-        } // matches event
-    }// for
-    
-    // We didn't match the key event against an accelerator.
-    return FALSE;
-}
-
-/*
-* wxNoOptimize: switch off size optimization
-*/
+// ----------------------------------------------------------------------------
+// wxNoOptimize: switch off size optimization
+// ----------------------------------------------------------------------------
 
 int wxNoOptimize::m_count = 0;
 
 
 int wxNoOptimize::m_count = 0;
 
@@ -3610,40 +2782,3 @@ bool wxNoOptimize::CanOptimize()
     return (m_count == 0);
 }
 
     return (m_count == 0);
 }
 
-// For repainting arbitrary windows
-void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *)
-{
-    Window window;
-    Display *display;
-    
-    wxWindow* win = (wxWindow *)wxWidgetHashTable->Get((long)w);
-    if (!win)
-        return;
-    
-    switch(event -> type)
-    {
-    case Expose :
-        {
-            window = (Window) win -> GetXWindow();
-            display = (Display *) win -> GetXDisplay();
-            
-            wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
-                event->xexpose.width, event->xexpose.height);
-            win->m_updateRects.Append((wxObject*) rect);
-            
-            if (event -> xexpose.count == 0)
-            {
-                win->DoPaint();
-                
-                win->ClearUpdateRects();
-            }
-            break;
-        }
-    default :
-        {
-            cout << "\n\nNew Event ! is = " << event -> type << "\n";
-            break;
-        }
-    }
-}
-
index 75fc25d84dd397609db14a12f9f50392ffb83945..7d1f20164780cfb5d8045cfed8500c2fd70e153d 100644 (file)
@@ -1018,7 +1018,7 @@ void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
 // drag and drop
 // ---------------------------------------------------------------------------
 
 // drag and drop
 // ---------------------------------------------------------------------------
 
-#if    wxUSE_DRAG_AND_DROP
+#if wxUSE_DRAG_AND_DROP
 
 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 {
 
 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 {
@@ -1272,7 +1272,8 @@ int wxWindow::GetCharWidth() const
     return lpTextMetric.tmAveCharWidth;
 }
 
     return lpTextMetric.tmAveCharWidth;
 }
 
-void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
+void wxWindow::GetTextExtent(const wxString& string,
+                             int *x, int *y,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
 {
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
 {