Reformatted Motif headers; added __WXX11__ symbol support to common headers;

added place-holding src/x11 and include/wx/x11 files. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14015 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2002-02-05 16:34:33 +00:00
parent a4e17da546
commit 83df96d63a
162 changed files with 22793 additions and 2176 deletions
--- a/include/wx/x11/accel.h
+++ b/include/wx/x11/accel.h
@@ -0,0 +1,51 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        accel.h
+// Purpose:     wxAcceleratorTable class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_ACCEL_H_
+#define _WX_ACCEL_H_
+
+#ifdef __GNUG__
+#pragma interface "accel.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/event.h"
+
+class WXDLLEXPORT wxAcceleratorTable: public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxAcceleratorTable)
+public:
+    wxAcceleratorTable();
+    wxAcceleratorTable(const wxString& resource); // Load from .rc resource
+    wxAcceleratorTable(int n, wxAcceleratorEntry entries[]); // Load from array
+    
+    // Copy constructors
+    wxAcceleratorTable(const wxAcceleratorTable& accel) { Ref(accel); }
+    wxAcceleratorTable(const wxAcceleratorTable* accel) { if (accel) Ref(*accel); }
+    
+    ~wxAcceleratorTable();
+    
+    wxAcceleratorTable& operator = (const wxAcceleratorTable& accel) { if (*this == accel) return (*this); Ref(accel); return *this; }
+    bool operator == (const wxAcceleratorTable& accel) { return m_refData == accel.m_refData; }
+    bool operator != (const wxAcceleratorTable& accel) { return m_refData != accel.m_refData; }
+    
+    bool Ok() const;
+    
+    // Implementation only
+    int GetCount() const;
+    wxAcceleratorEntry* GetEntries() const;
+};
+
+WXDLLEXPORT_DATA(extern wxAcceleratorTable) wxNullAcceleratorTable;
+
+#endif
+// _WX_ACCEL_H_
--- a/include/wx/x11/app.h
+++ b/include/wx/x11/app.h
@@ -0,0 +1,131 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        app.h
+// Purpose:     wxApp class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_APP_H_
+#define _WX_APP_H_
+
+#ifdef __GNUG__
+#pragma interface "app.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/gdicmn.h"
+#include "wx/event.h"
+
+// ----------------------------------------------------------------------------
+// forward declarations
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFrame;
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxApp;
+class WXDLLEXPORT wxKeyEvent;
+class WXDLLEXPORT wxLog;
+
+// ----------------------------------------------------------------------------
+// the wxApp class for Motif - see wxAppBase for more details
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxApp : public wxAppBase
+{
+    DECLARE_DYNAMIC_CLASS(wxApp)
+        
+public:
+    wxApp();
+    ~wxApp() {}
+    
+    // override base class (pure) virtuals
+    // -----------------------------------
+    
+    virtual int MainLoop();
+    virtual void ExitMainLoop();
+    virtual bool Initialized();
+    virtual bool Pending();
+    virtual void Dispatch();
+    virtual bool Yield(bool onlyIfNeeded = FALSE);
+    
+    virtual bool OnInitGui();
+    
+    virtual wxIcon GetStdIcon(int which) const;
+    
+    // implementation from now on
+    // --------------------------
+    
+    void OnIdle(wxIdleEvent& event);
+    
+    // Send idle event to all top-level windows.
+    // Returns TRUE if more idle time is requested.
+    bool SendIdleEvents();
+    
+    // Send idle event to window and all subwindows
+    // Returns TRUE if more idle time is requested.
+    bool SendIdleEvents(wxWindow* win);
+    
+    // Motif implementation.
+    
+    // Processes an X event.
+    virtual void ProcessXEvent(WXEvent* event);
+    
+    // Returns TRUE if an accelerator has been processed
+    virtual bool CheckForAccelerator(WXEvent* event);
+    
+    // Returns TRUE if a key down event has been processed
+    virtual bool CheckForKeyDown(WXEvent* event);
+    
+    // Returns TRUE if a key up event has been processed
+    virtual bool CheckForKeyUp(WXEvent* event);
+    
+protected:
+    bool                  m_showOnInit;
+    
+public:
+    // Implementation
+    static bool Initialize();
+    static void CleanUp();
+    
+    void DeletePendingObjects();
+    bool ProcessIdle();
+    
+    // Motif-specific
+    WXAppContext   GetAppContext() const { return m_appContext; }
+    WXWidget       GetTopLevelWidget() const { return m_topLevelWidget; }
+    WXColormap     GetMainColormap(WXDisplay* display);
+    WXDisplay*     GetInitialDisplay() const { return m_initialDisplay; }
+    long           GetMaxRequestSize() const { return m_maxRequestSize; }
+    
+    // This handler is called when a property change event occurs
+    virtual void   HandlePropertyChange(WXEvent *event);
+    
+public:
+    static long    sm_lastMessageTime;
+    int            m_nCmdShow;
+    
+protected:
+    bool                  m_keepGoing;
+    
+    // Motif-specific
+    WXAppContext          m_appContext;
+    WXWidget              m_topLevelWidget;
+    WXColormap            m_mainColormap;
+    WXDisplay*            m_initialDisplay;
+    long                  m_maxRequestSize;
+    
+    DECLARE_EVENT_TABLE()
+};
+
+int WXDLLEXPORT wxEntry( int argc, char *argv[] );
+
+#endif
+// _WX_APP_H_
+
--- a/include/wx/x11/bitmap.h
+++ b/include/wx/x11/bitmap.h
@@ -0,0 +1,230 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        bitmap.h
+// Purpose:     wxBitmap class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_BITMAP_H_
+#define _WX_BITMAP_H_
+
+#ifdef __GNUG__
+#pragma interface "bitmap.h"
+#endif
+
+#include "wx/gdiobj.h"
+#include "wx/gdicmn.h"
+#include "wx/palette.h"
+
+// Bitmap
+class WXDLLEXPORT wxDC;
+class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxBitmapHandler;
+class WXDLLEXPORT wxIcon;
+class WXDLLEXPORT wxCursor;
+class WXDLLEXPORT wxImage;
+
+// A mask is a mono bitmap used for drawing bitmaps
+// transparently.
+class WXDLLEXPORT wxMask: public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxMask)
+        
+public:
+    wxMask();
+    
+    // Construct a mask from a bitmap and a colour indicating
+    // the transparent area
+    wxMask(const wxBitmap& bitmap, const wxColour& colour);
+    
+    // Construct a mask from a bitmap and a palette index indicating
+    // the transparent area
+    wxMask(const wxBitmap& bitmap, int paletteIndex);
+    
+    // Construct a mask from a mono bitmap (copies the bitmap).
+    wxMask(const wxBitmap& bitmap);
+    
+    ~wxMask();
+    
+    bool Create(const wxBitmap& bitmap, const wxColour& colour);
+    bool Create(const wxBitmap& bitmap, int paletteIndex);
+    bool Create(const wxBitmap& bitmap);
+    
+    WXPixmap GetPixmap() const { return m_pixmap; }
+    void SetPixmap(WXPixmap pixmap) { m_pixmap = pixmap; }
+    
+protected:
+    WXPixmap      m_pixmap;
+};
+
+class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
+{
+    friend class WXDLLEXPORT wxBitmap;
+    friend class WXDLLEXPORT wxIcon;
+    friend class WXDLLEXPORT wxCursor;
+public:
+    wxBitmapRefData();
+    ~wxBitmapRefData();
+    
+public:
+    int               m_width;
+    int               m_height;
+    int               m_depth;
+    bool              m_ok;
+    int               m_numColors;
+    wxPalette         m_bitmapPalette;
+    int               m_quality;
+    
+    wxMask *          m_bitmapMask; // Optional mask
+    
+    // Motif implementation
+public:
+    WXPixmap          m_pixmap;
+    WXDisplay*        m_display;
+    bool              m_freePixmap;
+    unsigned long*    m_freeColors;
+    long              m_freeColorsCount;
+    
+    // These 5 variables are for wxControl
+    WXPixmap          m_insensPixmap ;
+    WXPixmap          m_labelPixmap ;
+    WXPixmap          m_armPixmap ;
+    WXImage*          m_image ;
+    WXImage*          m_insensImage ;
+};
+
+#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+
+class WXDLLEXPORT wxBitmapHandler: public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
+public:
+    wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; };
+    
+    virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
+    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+        int desiredWidth, int desiredHeight);
+    virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
+    
+    void SetName(const wxString& name) { m_name = name; }
+    void SetExtension(const wxString& ext) { m_extension = ext; }
+    void SetType(long type) { m_type = type; }
+    wxString GetName() const { return m_name; }
+    wxString GetExtension() const { return m_extension; }
+    long GetType() const { return m_type; }
+protected:
+    wxString  m_name;
+    wxString  m_extension;
+    long      m_type;
+};
+
+#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
+
+class WXDLLEXPORT wxBitmap: public wxGDIObject
+{
+    DECLARE_DYNAMIC_CLASS(wxBitmap)
+        
+        friend class WXDLLEXPORT wxBitmapHandler;
+    
+public:
+    wxBitmap(); // Platform-specific
+    
+    // Copy constructors
+    wxBitmap(const wxBitmap& bitmap)
+    { Ref(bitmap); }
+    
+    // Initialize with raw XBM data
+    wxBitmap(const char bits[], int width, int height, int depth = 1);
+    
+    // from XPM
+    wxBitmap(const char **data) { (void)CreateFromXpm(data); }
+    wxBitmap(char **data) { (void)CreateFromXpm((const char **)data); }
+    
+    // Initialize with XPM data -- deprecated
+    wxBitmap(char **data, wxControl* control);
+    
+    // Load a file or resource
+    wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_XPM);
+    
+    // Constructor for generalised creation from data
+    wxBitmap(void *data, long type, int width, int height, int depth = 1);
+    
+    // If depth is omitted, will create a bitmap compatible with the display
+    wxBitmap(int width, int height, int depth = -1);
+    
+    // Convert from wxImage:  
+    wxBitmap(const wxImage& image, int depth = -1) { (void)CreateFromImage(image, depth); }
+    
+    ~wxBitmap();
+    
+    virtual bool Create(int width, int height, int depth = -1);
+    virtual bool Create(void *data, long type, int width, int height, int depth = 1);
+    
+    wxBitmap GetSubBitmap( const wxRect& rect ) const;
+    
+    virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_XPM);
+    virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
+    
+    wxImage ConvertToImage() const;
+    
+    bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
+    int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
+    int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
+    int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
+    int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
+    void SetWidth(int w);
+    void SetHeight(int h);
+    void SetDepth(int d);
+    void SetQuality(int q);
+    void SetOk(bool isOk);
+    
+    wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
+    void SetPalette(const wxPalette& palette);
+    
+    wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
+    void SetMask(wxMask *mask) ;
+    
+    wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; }
+    bool operator == (const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
+    bool operator != (const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
+    
+    // Format handling
+    static wxList& GetHandlers() { return sm_handlers; }
+    static void AddHandler(wxBitmapHandler *handler);
+    static void InsertHandler(wxBitmapHandler *handler);
+    static bool RemoveHandler(const wxString& name);
+    static wxBitmapHandler *FindHandler(const wxString& name);
+    static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType);
+    static wxBitmapHandler *FindHandler(long bitmapType);
+    
+    static void InitStandardHandlers();
+    static void CleanUpHandlers();
+    
+    // Motif implementation
+public:
+    WXDisplay* GetDisplay() const { return M_BITMAPDATA->m_display; }
+    WXPixmap GetPixmap() const { return (WXPixmap) M_BITMAPDATA->m_pixmap; }
+    virtual WXPixmap GetLabelPixmap(WXWidget w) ;
+    virtual WXPixmap GetArmPixmap(WXWidget w) ;
+    virtual WXPixmap GetInsensPixmap(WXWidget w = (WXWidget) 0) ;
+    void SetPixmapNull() { M_BITMAPDATA->m_pixmap = 0; }
+    
+protected:
+    static wxList sm_handlers;
+    
+protected:
+    bool CreateFromXpm(const char **bits);
+    bool CreateFromImage(const wxImage& image, int depth);    
+};
+
+// Creates a bitmap with transparent areas drawn in
+// the given colour.
+wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour);
+
+#endif
+// _WX_BITMAP_H_
--- a/include/wx/x11/brush.h
+++ b/include/wx/x11/brush.h
@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        brush.h
+// Purpose:     wxBrush class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_BRUSH_H_
+#define _WX_BRUSH_H_
+
+#ifdef __GNUG__
+#pragma interface "brush.h"
+#endif
+
+#include "wx/gdicmn.h"
+#include "wx/gdiobj.h"
+#include "wx/bitmap.h"
+
+class WXDLLEXPORT wxBrush;
+
+class WXDLLEXPORT wxBrushRefData: public wxGDIRefData
+{
+    friend class WXDLLEXPORT wxBrush;
+public:
+    wxBrushRefData();
+    wxBrushRefData(const wxBrushRefData& data);
+    ~wxBrushRefData();
+    
+protected:
+    int           m_style;
+    wxBitmap      m_stipple ;
+    wxColour      m_colour;
+};
+
+#define M_BRUSHDATA ((wxBrushRefData *)m_refData)
+
+// Brush
+class WXDLLEXPORT wxBrush: public wxGDIObject
+{
+    DECLARE_DYNAMIC_CLASS(wxBrush)
+        
+public:
+    wxBrush();
+    wxBrush(const wxColour& col, int style);
+    wxBrush(const wxBitmap& stipple);
+    inline wxBrush(const wxBrush& brush) { Ref(brush); }
+    ~wxBrush();
+    
+    virtual void SetColour(const wxColour& col)  ;
+    virtual void SetColour(unsigned char r, unsigned char g, unsigned char b)  ;
+    virtual void SetStyle(int style)  ;
+    virtual void SetStipple(const wxBitmap& stipple)  ;
+    
+    inline wxBrush& operator = (const wxBrush& brush) { if (*this == brush) return (*this); Ref(brush); return *this; }
+    inline bool operator == (const wxBrush& brush) const { return m_refData == brush.m_refData; }
+    inline bool operator != (const wxBrush& brush) const { return m_refData != brush.m_refData; }
+    
+    inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); };
+    inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); };
+    inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); };
+    
+    virtual bool Ok() const { return (m_refData != NULL) ; }
+    
+    // Implementation
+    
+    // Useful helper: create the brush resource
+    bool RealizeResource();
+    
+    // When setting properties, we must make sure we're not changing
+    // another object
+    void Unshare();
+};
+
+#endif
+// _WX_BRUSH_H_
--- a/include/wx/x11/clipbrd.h
+++ b/include/wx/x11/clipbrd.h
@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        clipbrd.h
+// Purpose:     Clipboard functionality.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_CLIPBRD_H_
+#define _WX_CLIPBRD_H_
+
+#ifdef __GNUG__
+#pragma interface "clipbrd.h"
+#endif
+
+#if wxUSE_CLIPBOARD
+
+#include "wx/list.h"
+
+bool WXDLLEXPORT wxOpenClipboard();
+bool WXDLLEXPORT wxClipboardOpen();
+bool WXDLLEXPORT wxCloseClipboard();
+bool WXDLLEXPORT wxEmptyClipboard();
+bool WXDLLEXPORT wxIsClipboardFormatAvailable(wxDataFormat dataFormat);
+bool WXDLLEXPORT wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj, int width = 0, int height = 0);
+wxObject* WXDLLEXPORT wxGetClipboardData(wxDataFormat dataFormat, long *len = NULL);
+wxDataFormat WXDLLEXPORT wxEnumClipboardFormats(wxDataFormat dataFormat);
+wxDataFormat WXDLLEXPORT wxRegisterClipboardFormat(char *formatName);
+bool WXDLLEXPORT wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int maxCount);
+
+//-----------------------------------------------------------------------------
+// wxClipboard
+//-----------------------------------------------------------------------------
+
+class wxClipboard : public wxClipboardBase
+{
+public:
+    wxClipboard();
+    ~wxClipboard();
+    
+    // open the clipboard before SetData() and GetData()
+    virtual bool Open();
+    
+    // close the clipboard after SetData() and GetData()
+    virtual void Close();
+    
+    // opened?
+    virtual bool IsOpened() const { return m_open; }
+    
+    // replaces the data on the clipboard with data
+    virtual bool SetData( wxDataObject *data );
+    
+    // adds data to the clipboard
+    virtual bool AddData( wxDataObject *data );
+    
+    // format available on the clipboard ?
+    virtual bool IsSupported( const wxDataFormat& format );
+    
+    // fill data with data on the clipboard (if available)
+    virtual bool GetData( wxDataObject& data );
+    
+    // clears wxTheClipboard and the system's clipboard if possible
+    virtual void Clear();
+    
+    virtual void UsePrimarySelection(bool primary = TRUE)
+    { m_usePrimary = primary; }
+    
+    // implementation from now on
+    
+    bool              m_open;
+    wxList            m_data;
+    bool              m_usePrimary;
+    
+private:
+    DECLARE_DYNAMIC_CLASS(wxClipboard)
+};
+
+#endif // wxUSE_CLIPBOARD
+
+#endif
+// _WX_CLIPBRD_H_
--- a/include/wx/x11/colour.h
+++ b/include/wx/x11/colour.h
@@ -0,0 +1,92 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        colour.h
+// Purpose:     wxColour class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COLOUR_H_
+#define _WX_COLOUR_H_
+
+#ifdef __GNUG__
+#pragma interface "colour.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/string.h"
+
+// Colour
+class WXDLLEXPORT wxColour : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxColour)
+public:
+    // ctors
+    // default
+    wxColour();
+    // from RGB
+    wxColour( unsigned char red, unsigned char green, unsigned char blue );
+    wxColour( unsigned long colRGB ) { Set(colRGB); }
+    
+    // implicit conversion from the colour name
+    wxColour( const wxString &colourName ) { InitFromName(colourName); }
+    wxColour( const char *colourName ) { InitFromName(colourName); }
+    
+    // copy ctors and assignment operators
+    wxColour( const wxColour& col );
+    wxColour& operator = ( const wxColour& col );
+    
+    // dtor
+    ~wxColour();
+    
+    // Set() functions
+    void Set( unsigned char red, unsigned char green, unsigned char blue );
+    void Set( unsigned long colRGB )
+    {
+        // we don't need to know sizeof(long) here because we assume that the three
+        // least significant bytes contain the R, G and B values
+        Set((unsigned char)colRGB,
+            (unsigned char)(colRGB >> 8),
+            (unsigned char)(colRGB >> 16));
+    }
+    
+    // accessors
+    bool Ok() const {return m_isInit; }
+    unsigned char Red() const { return m_red; }
+    unsigned char Green() const { return m_green; }
+    unsigned char Blue() const { return m_blue; }
+    
+    int GetPixel() const { return m_pixel; };
+    void SetPixel(int pixel) { m_pixel = pixel; m_isInit = TRUE; };
+    
+    inline bool operator == (const wxColour& colour) const { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); }
+    
+    inline bool operator != (const wxColour& colour) const { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
+    
+    // Allocate a colour, or nearest colour, using the given display.
+    // If realloc is TRUE, ignore the existing pixel, otherwise just return
+    // the existing one.
+    // Returns the allocated pixel.
+    
+    // TODO: can this handle mono displays? If not, we should have an extra
+    // flag to specify whether this should be black or white by default.
+    
+    int AllocColour(WXDisplay* display, bool realloc = FALSE);
+    
+    void InitFromName(const wxString& col);
+    
+private:
+    bool          m_isInit;
+    unsigned char m_red;
+    unsigned char m_blue;
+    unsigned char m_green;
+    
+public:
+    int           m_pixel;
+};
+
+#endif
+// _WX_COLOUR_H_
--- a/include/wx/x11/cursor.h
+++ b/include/wx/x11/cursor.h
@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        cursor.h
+// Purpose:     wxCursor class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_CURSOR_H_
+#define _WX_CURSOR_H_
+
+#ifdef __GNUG__
+#pragma interface "cursor.h"
+#endif
+
+#include "wx/bitmap.h"
+
+/* Cursor for one display, so we can choose the correct one for
+* the current display.
+*/
+class wxXCursor : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxXCursor)
+        
+public:
+    WXDisplay*  m_display;
+    WXCursor    m_cursor;
+};
+
+class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData
+{
+    friend class WXDLLEXPORT wxBitmap;
+    friend class WXDLLEXPORT wxCursor;
+public:
+    wxCursorRefData();
+    ~wxCursorRefData();
+    
+    wxList        m_cursors;  // wxXCursor objects, one per display
+    wxStockCursor m_cursorId; // wxWindows standard cursor id
+};
+
+#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
+
+// Cursor
+class WXDLLEXPORT wxCursor: public wxBitmap
+{
+    DECLARE_DYNAMIC_CLASS(wxCursor)
+        
+public:
+    wxCursor();
+    
+    // Copy constructors
+    wxCursor(const wxCursor& cursor) { Ref(cursor); }
+    
+    wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
+        const char maskBits[] = NULL);
+    
+    wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_XBM,
+        int hotSpotX = 0, int hotSpotY = 0);
+    
+    wxCursor(wxStockCursor id);
+    ~wxCursor();
+    
+    virtual bool Ok() const { return ((m_refData != NULL) && M_CURSORDATA->m_ok); }
+    
+    wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
+    bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
+    bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
+    
+    // Motif-specific.
+    // Create/get a cursor for the current display
+    WXCursor GetXCursor(WXDisplay* display) ;
+    // Make a cursor from standard id
+    WXCursor MakeCursor(WXDisplay* display, wxStockCursor id);
+};
+
+extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
+
+#endif
+// _WX_CURSOR_H_
--- a/include/wx/x11/dataform.h
+++ b/include/wx/x11/dataform.h
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        motif/dataform.h
+// Purpose:     declaration of the wxDataFormat class
+// Author:      Robert Roebling
+// Modified by:
+// Created:     19.10.99 (extracted from motif/dataobj.h)
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Robert Roebling
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MOTIF_DATAFORM_H
+#define _WX_MOTIF_DATAFORM_H
+
+class wxDataFormat
+{
+public:
+    // the clipboard formats under Xt are Atoms
+    typedef Atom NativeFormat;
+    
+    wxDataFormat();
+    wxDataFormat( wxDataFormatId type );
+    wxDataFormat( const wxString &id );
+    wxDataFormat( const wxChar *id );
+    wxDataFormat( NativeFormat format );
+    
+    wxDataFormat& operator=(NativeFormat format)
+    { SetId(format); return *this; }
+    
+    // comparison (must have both versions)
+    bool operator==(NativeFormat format) const
+    { return m_format == (NativeFormat)format; }
+    bool operator!=(NativeFormat format) const
+    { return m_format != (NativeFormat)format; }
+    bool operator==(wxDataFormatId format) const
+    { return m_type == (wxDataFormatId)format; }
+    bool operator!=(wxDataFormatId format) const
+    { return m_type != (wxDataFormatId)format; }
+    
+    // explicit and implicit conversions to NativeFormat which is one of
+    // standard data types (implicit conversion is useful for preserving the
+    // compatibility with old code)
+    NativeFormat GetFormatId() const { return m_format; }
+    operator NativeFormat() const { return m_format; }
+    
+    void SetId( NativeFormat format );
+    
+    // string ids are used for custom types - this SetId() must be used for
+    // application-specific formats
+    wxString GetId() const;
+    void SetId( const wxChar *id );
+    
+    // implementation
+    wxDataFormatId GetType() const;
+    
+private:
+    wxDataFormatId   m_type;
+    NativeFormat     m_format;
+    
+    void PrepareFormats();
+    void SetType( wxDataFormatId type );
+};
+
+
+#endif // _WX_MOTIF_DATAFORM_H
+
--- a/include/wx/x11/dataobj.h
+++ b/include/wx/x11/dataobj.h
@@ -0,0 +1,30 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/motif/dataobj.h
+// Purpose:     declaration of the wxDataObject class for Motif
+// Author:      Julian Smart
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MOTIF_DATAOBJ_H_
+#define _WX_MOTIF_DATAOBJ_H_
+
+#ifdef __GNUG__
+#pragma interface "dataobj.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// wxDataObject is the same as wxDataObjectBase under wxMotif
+// ----------------------------------------------------------------------------
+
+class wxDataObject : public wxDataObjectBase
+{
+public:
+#ifdef __DARWIN__
+    ~wxDataObject() { }
+#endif
+};
+
+#endif //_WX_MOTIF_DATAOBJ_H_
+
--- a/include/wx/x11/dc.h
+++ b/include/wx/x11/dc.h
@@ -0,0 +1,168 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dc.h
+// Purpose:     wxDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DC_H_
+#define _WX_DC_H_
+
+#ifdef __GNUG__
+#pragma interface "dc.h"
+#endif
+
+#include "wx/pen.h"
+#include "wx/brush.h"
+#include "wx/icon.h"
+#include "wx/font.h"
+#include "wx/gdicmn.h"
+
+//-----------------------------------------------------------------------------
+// constants
+//-----------------------------------------------------------------------------
+
+#ifndef MM_TEXT
+#define MM_TEXT         0
+#define MM_ISOTROPIC    1
+#define MM_ANISOTROPIC  2
+#define MM_LOMETRIC     3
+#define MM_HIMETRIC     4
+#define MM_TWIPS        5
+#define MM_POINTS       6
+#define MM_METRIC       7
+#endif
+
+//-----------------------------------------------------------------------------
+// wxDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDC : public wxDCBase
+{
+    DECLARE_DYNAMIC_CLASS(wxDC)
+        
+public:
+    wxDC();
+    ~wxDC() { }
+    
+    // implement base class pure virtuals
+    // ----------------------------------
+    
+    virtual void DestroyClippingRegion();
+    
+    virtual wxSize GetPPI() const;
+    
+    virtual void SetMapMode(int mode);
+    virtual void SetUserScale(double x, double y);
+    virtual void SetLogicalScale(double x, double y);
+    virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
+    virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
+    virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
+    
+protected:
+    virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
+    virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
+        bool useMask = FALSE);
+    
+    virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
+        wxCoord width, wxCoord height);
+    virtual void DoGetSize(int *width, int *height) const;
+    virtual void DoGetSizeMM(int* width, int* height) const;
+    
+public:
+    void ComputeScaleAndOrigin();
+    
+    wxCoord XDEV2LOG(wxCoord x) const
+    {
+        wxCoord new_x = x - m_deviceOriginX;
+        if (new_x > 0)
+            return (wxCoord)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
+        else
+            return (wxCoord)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
+    }
+    wxCoord XDEV2LOGREL(wxCoord x) const
+    {
+        if (x > 0)
+            return (wxCoord)((double)(x) / m_scaleX + 0.5);
+        else
+            return (wxCoord)((double)(x) / m_scaleX - 0.5);
+    }
+    wxCoord YDEV2LOG(wxCoord y) const
+    {
+        wxCoord new_y = y - m_deviceOriginY;
+        if (new_y > 0)
+            return (wxCoord)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
+        else
+            return (wxCoord)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
+    }
+    wxCoord YDEV2LOGREL(wxCoord y) const
+    {
+        if (y > 0)
+            return (wxCoord)((double)(y) / m_scaleY + 0.5);
+        else
+            return (wxCoord)((double)(y) / m_scaleY - 0.5);
+    }
+    wxCoord XLOG2DEV(wxCoord x) const
+    {
+        wxCoord new_x = x - m_logicalOriginX;
+        if (new_x > 0)
+            return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
+        else
+            return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
+    }
+    // Without device translation, for backing pixmap purposes
+    wxCoord XLOG2DEV_2(wxCoord x) const
+    {
+        wxCoord new_x = x - m_logicalOriginX;
+        if (new_x > 0)
+            return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX;
+        else
+            return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX;
+    }
+    wxCoord XLOG2DEVREL(wxCoord x) const
+    {
+        if (x > 0)
+            return (wxCoord)((double)(x) * m_scaleX + 0.5);
+        else
+            return (wxCoord)((double)(x) * m_scaleX - 0.5);
+    }
+    wxCoord YLOG2DEV(wxCoord y) const
+    {
+        wxCoord new_y = y - m_logicalOriginY;
+        if (new_y > 0)
+            return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
+        else
+            return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
+    }
+    // Without device translation, for backing pixmap purposes
+    wxCoord YLOG2DEV_2(wxCoord y) const
+    {
+        wxCoord new_y = y - m_logicalOriginY;
+        if (new_y > 0)
+            return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY;
+        else
+            return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY;
+    }
+    wxCoord YLOG2DEVREL(wxCoord y) const
+    {
+        if (y > 0)
+            return (wxCoord)((double)(y) * m_scaleY + 0.5);
+        else
+            return (wxCoord)((double)(y) * m_scaleY - 0.5);
+    }
+    
+public:
+    // not sure what for, but what is a mm on a screen you don't know the size of?
+    double       m_mm_to_pix_x,m_mm_to_pix_y;
+    
+    // recompute scale?
+    bool         m_needComputeScaleX, m_needComputeScaleY;
+    
+};
+
+#endif
+// _WX_DC_H_
--- a/include/wx/x11/dcclient.h
+++ b/include/wx/x11/dcclient.h
@@ -0,0 +1,177 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcclient.h
+// Purpose:     wxClientDC, wxPaintDC and wxWindowDC classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCCLIENT_H_
+#define _WX_DCCLIENT_H_
+
+#ifdef __GNUG__
+#pragma interface "dcclient.h"
+#endif
+
+#include "wx/dc.h"
+
+// -----------------------------------------------------------------------------
+// fwd declarations
+// -----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindowDC;
+class WXDLLEXPORT wxWindow;
+
+// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented
+// differently. On many platforms, however, they will be the same.
+
+//-----------------------------------------------------------------------------
+// wxWindowDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindowDC : public wxDC
+{
+    DECLARE_DYNAMIC_CLASS(wxWindowDC)
+        
+public:
+    wxWindowDC();
+    wxWindowDC( wxWindow *win );
+    
+    ~wxWindowDC();
+    
+    // TODO this function is Motif-only for now - should it go into base class?
+    void Clear(const wxRect& rect);
+    
+    // implement base class pure virtuals
+    // ----------------------------------
+    
+    virtual void Clear();
+    
+    virtual void SetFont(const wxFont& font);
+    virtual void SetPen(const wxPen& pen);
+    virtual void SetBrush(const wxBrush& brush);
+    virtual void SetBackground(const wxBrush& brush);
+    virtual void SetBackgroundMode(int mode);
+    virtual void SetPalette(const wxPalette& palette);
+    virtual void SetLogicalFunction( int function );
+    
+    virtual void SetTextForeground(const wxColour& colour);
+    virtual void SetTextBackground(const wxColour& colour);
+    
+    virtual wxCoord GetCharHeight() const;
+    virtual wxCoord GetCharWidth() const;
+    virtual void DoGetTextExtent(const wxString& string,
+        wxCoord *x, wxCoord *y,
+        wxCoord *descent = NULL,
+        wxCoord *externalLeading = NULL,
+        wxFont *theFont = NULL) const;
+    
+    virtual bool CanDrawBitmap() const;
+    virtual bool CanGetTextExtent() const;
+    
+    virtual int GetDepth() const;
+    virtual wxSize GetPPI() const;
+    
+    virtual void DestroyClippingRegion();
+    
+    // Helper function for setting clipping
+    void SetDCClipping();
+    
+    // implementation from now on
+    // --------------------------
+    
+    WXGC GetGC() const { return m_gc; }
+    WXGC GetBackingGC() const { return m_gcBacking; }
+    WXDisplay* GetDisplay() const { return m_display; }
+    bool GetAutoSetting() const { return m_autoSetting; }
+    void SetAutoSetting(bool flag) { m_autoSetting = flag; }
+    
+protected:
+    virtual void DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
+        int style = wxFLOOD_SURFACE);
+    
+    virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
+    
+    virtual void DoDrawPoint(wxCoord x, wxCoord y);
+    virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
+    
+    virtual void DoDrawArc(wxCoord x1, wxCoord y1,
+        wxCoord x2, wxCoord y2,
+        wxCoord xc, wxCoord yc);
+    virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
+        double sa, double ea);
+    
+    virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
+        wxCoord width, wxCoord height,
+        double radius);
+    virtual void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    
+    virtual void DoCrossHair(wxCoord x, wxCoord y);
+    
+    virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
+    virtual void DoDrawRotatedText(const wxString &text, wxCoord x, wxCoord y, double angle);
+    
+    virtual bool DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+        wxDC *source, wxCoord xsrc, wxCoord ysrc,
+        int rop = wxCOPY, bool useMask = FALSE, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1);
+    
+    virtual void DoSetClippingRegionAsRegion(const wxRegion& region);
+    virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
+        wxCoord width, wxCoord height);
+    
+    virtual void DoDrawLines(int n, wxPoint points[],
+        wxCoord xoffset, wxCoord yoffset);
+    virtual void DoDrawPolygon(int n, wxPoint points[],
+        wxCoord xoffset, wxCoord yoffset,
+        int fillStyle = wxODDEVEN_RULE);
+    
+    WXGC         m_gc;
+    WXGC         m_gcBacking;
+    WXDisplay*   m_display;
+    wxWindow*    m_window;
+    WXRegion     m_currentRegion; // Current clipping region (incl. paint clip region)
+    WXRegion     m_userRegion;    // User-defined clipping region
+    WXPixmap     m_pixmap;        // Pixmap for drawing on
+    
+    // Not sure if we'll need all of these
+    int          m_backgroundPixel;
+    wxColour     m_currentColour;
+    //    int          m_currentBkMode;
+    int          m_currentPenWidth ;
+    int          m_currentPenJoin ;
+    int          m_currentPenCap ;
+    int          m_currentPenDashCount ;
+    wxMOTIFDash* m_currentPenDash ;
+    wxBitmap     m_currentStipple ;
+    int          m_currentStyle ;
+    int          m_currentFill ;
+    int          m_autoSetting ; // See comment in dcclient.cpp
+    WXFont       m_oldFont;
+};
+
+class WXDLLEXPORT wxPaintDC: public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxPaintDC)
+        
+public:
+    wxPaintDC() { }
+    wxPaintDC(wxWindow* win);
+    
+    ~wxPaintDC();
+};
+
+class WXDLLEXPORT wxClientDC: public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxClientDC)
+        
+public:
+    wxClientDC() { }
+    wxClientDC(wxWindow* win) : wxWindowDC(win) { }
+};
+
+#endif
+// _WX_DCCLIENT_H_
--- a/include/wx/x11/dcmemory.h
+++ b/include/wx/x11/dcmemory.h
@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcmemory.h
+// Purpose:     wxMemoryDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCMEMORY_H_
+#define _WX_DCMEMORY_H_
+
+#ifdef __GNUG__
+#pragma interface "dcmemory.h"
+#endif
+
+#include "wx/dcclient.h"
+
+class wxMemoryDC : public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+        
+public:
+    wxMemoryDC();
+    wxMemoryDC( wxDC *dc ); // Create compatible DC
+    ~wxMemoryDC();
+    
+    virtual void SelectObject( const wxBitmap& bitmap );
+    
+    void DoGetSize( int *width, int *height ) const;
+    
+    wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
+    
+private:
+    friend class wxPaintDC;
+    
+    wxBitmap  m_bitmap;
+};
+
+#endif
+// _WX_DCMEMORY_H_
--- a/include/wx/x11/dcprint.h
+++ b/include/wx/x11/dcprint.h
@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcprint.h
+// Purpose:     wxPrinterDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCPRINT_H_
+#define _WX_DCPRINT_H_
+
+#ifdef __GNUG__
+#pragma interface "dcprint.h"
+#endif
+
+#include "wx/dc.h"
+
+class WXDLLEXPORT wxPrinterDC: public wxDC
+{
+public:
+    DECLARE_CLASS(wxPrinterDC)
+        
+    // Create a printer DC
+    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output, bool interactive = TRUE, int orientation = wxPORTRAIT);
+    
+    ~wxPrinterDC();
+};
+
+#endif
+// _WX_DCPRINT_H_
+
--- a/include/wx/x11/dcscreen.h
+++ b/include/wx/x11/dcscreen.h
@@ -0,0 +1,48 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcscreen.h
+// Purpose:     wxScreenDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCSCREEN_H_
+#define _WX_DCSCREEN_H_
+
+#ifdef __GNUG__
+#pragma interface "dcscreen.h"
+#endif
+
+#include "wx/dcclient.h"
+
+class WXDLLEXPORT wxScreenDC: public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxScreenDC)
+        
+public:
+    // Create a DC representing the whole screen
+    wxScreenDC();
+    ~wxScreenDC();
+    
+    // Compatibility with X's requirements for
+    // drawing on top of all windows
+    static bool StartDrawingOnTop(wxWindow* window);
+    static bool StartDrawingOnTop(wxRect* rect = NULL);
+    static bool EndDrawingOnTop();
+    
+private:
+    static WXWindow sm_overlayWindow;
+    
+    // If we have started transparent drawing at a non-(0,0) point
+    // then we will have to adjust the device origin in the
+    // constructor.
+    static int sm_overlayWindowX;
+    static int sm_overlayWindowY;
+};
+
+#endif
+// _WX_DCSCREEN_H_
+
--- a/include/wx/x11/dnd.h
+++ b/include/wx/x11/dnd.h
@@ -0,0 +1,178 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        dnd.h
+// Purpose:     declaration of wxDropTarget, wxDropSource classes
+// Author:      Julian Smart
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Vadim Zeitlin, Robert Roebling, Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_DND_H_
+#define _WX_DND_H_
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_DRAG_AND_DROP
+
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/dataobj.h"
+#include "wx/cursor.h"
+
+//-------------------------------------------------------------------------
+// classes
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindow;
+
+class WXDLLEXPORT wxDropTarget;
+class WXDLLEXPORT wxTextDropTarget;
+class WXDLLEXPORT wxFileDropTarget;
+class WXDLLEXPORT wxPrivateDropTarget;
+
+class WXDLLEXPORT wxDropSource;
+
+//-------------------------------------------------------------------------
+// wxDropTarget
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDropTarget: public wxObject
+{
+public:
+    
+    wxDropTarget();
+    ~wxDropTarget();
+    
+    virtual void OnEnter() { }
+    virtual void OnLeave() { }
+    virtual bool OnDrop( long x, long y, const void *data, size_t size ) = 0;
+    
+    // Override these to indicate what kind of data you support: 
+    
+    virtual size_t GetFormatCount() const = 0;
+    virtual wxDataFormat GetFormat(size_t n) const = 0;
+    
+    // implementation
+};
+
+//-------------------------------------------------------------------------
+// wxTextDropTarget
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxTextDropTarget: public wxDropTarget
+{
+public:
+    
+    wxTextDropTarget() {};
+    virtual bool OnDrop( long x, long y, const void *data, size_t size );
+    virtual bool OnDropText( long x, long y, const char *psz );
+    
+protected:
+    
+    virtual size_t GetFormatCount() const;
+    virtual wxDataFormat GetFormat(size_t n) const;
+};
+
+//-------------------------------------------------------------------------
+// wxPrivateDropTarget
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPrivateDropTarget: public wxDropTarget
+{
+public:
+    
+    wxPrivateDropTarget();
+    
+    // you have to override OnDrop to get at the data
+    
+    // the string ID identifies the format of clipboard or DnD data. a word
+    // processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
+    // to the clipboard - the latter with the Id "WXWORD_FORMAT".
+    
+    void SetId( const wxString& id )
+    { m_id = id; }
+    
+    wxString GetId()
+    { return m_id; }
+    
+private:
+    
+    virtual size_t GetFormatCount() const;
+    virtual wxDataFormat GetFormat(size_t n) const;
+    
+    wxString   m_id;
+};
+
+// ----------------------------------------------------------------------------
+// A drop target which accepts files (dragged from File Manager or Explorer)
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFileDropTarget: public wxDropTarget
+{
+public:
+    
+    wxFileDropTarget() {};
+    
+    virtual bool OnDrop( long x, long y, const void *data, size_t size );
+    virtual bool OnDropFiles( long x, long y, 
+        size_t nFiles, const char * const aszFiles[] );
+    
+protected:
+    
+    virtual size_t GetFormatCount() const;
+    virtual wxDataFormat GetFormat(size_t n) const;
+};
+
+//-------------------------------------------------------------------------
+// wxDropSource
+//-------------------------------------------------------------------------
+
+enum wxDragResult
+{
+    wxDragError,    // error prevented the d&d operation from completing
+        wxDragNone,     // drag target didn't accept the data
+        wxDragCopy,     // the data was successfully copied
+        wxDragMove,     // the data was successfully moved
+        wxDragCancel    // the operation was cancelled by user (not an error)
+};
+
+class WXDLLEXPORT wxDropSource: public wxObject
+{
+public:
+    
+    wxDropSource( wxWindow *win );
+    wxDropSource( wxDataObject &data, wxWindow *win );
+    
+    ~wxDropSource(void);
+    
+    void SetData( wxDataObject &data  );
+    wxDragResult DoDragDrop( bool bAllowMove = FALSE );
+    
+    virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; };
+    
+    // implementation
+#if 0
+    void RegisterWindow(void);
+    void UnregisterWindow(void);
+    
+    wxWindow      *m_window;
+    wxDragResult   m_retValue;
+    wxDataObject  *m_data;
+    
+    wxCursor      m_defaultCursor;
+    wxCursor      m_goaheadCursor;
+#endif
+};
+
+#endif
+
+// wxUSE_DRAG_AND_DROP
+
+#endif  
+//_WX_DND_H_
+
--- a/include/wx/x11/font.h
+++ b/include/wx/x11/font.h
@@ -0,0 +1,117 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        font.h
+// Purpose:     wxFont class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_FONT_H_
+#define _WX_FONT_H_
+
+#ifdef __GNUG__
+#pragma interface "font.h"
+#endif
+
+class wxXFont;
+
+// Font
+class wxFont : public wxFontBase
+{
+public:
+    // ctors and such
+    wxFont() { Init(); }
+    wxFont(const wxFont& font) { Init(); Ref(font); }
+    
+    wxFont(int size,
+        int family,
+        int style,
+        int weight,
+        bool underlined = FALSE,
+        const wxString& face = wxEmptyString,
+        wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
+    {
+        Init();
+        
+        (void)Create(size, family, style, weight, underlined, face, encoding);
+    }
+    
+    wxFont(const wxNativeFontInfo& info);
+    
+    bool Create(int size,
+        int family,
+        int style,
+        int weight,
+        bool underlined = FALSE,
+        const wxString& face = wxEmptyString,
+        wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
+    
+    // wxMOTIF-specific
+    bool Create(const wxString& fontname,
+        wxFontEncoding fontenc = wxFONTENCODING_DEFAULT);
+    bool Create(const wxNativeFontInfo& fontinfo);
+    
+    virtual ~wxFont();
+    
+    // assignment
+    wxFont& operator=(const wxFont& font);
+    
+    // implement base class pure virtuals
+    virtual int GetPointSize() const;
+    virtual int GetFamily() const;
+    virtual int GetStyle() const;
+    virtual int GetWeight() const;
+    virtual bool GetUnderlined() const;
+    virtual wxString GetFaceName() const;
+    virtual wxFontEncoding GetEncoding() const;
+    virtual wxNativeFontInfo *GetNativeFontInfo() const;
+    
+    virtual void SetPointSize(int pointSize);
+    virtual void SetFamily(int family);
+    virtual void SetStyle(int style);
+    virtual void SetWeight(int weight);
+    virtual void SetFaceName(const wxString& faceName);
+    virtual void SetUnderlined(bool underlined);
+    virtual void SetEncoding(wxFontEncoding encoding);
+    virtual void SetNativeFontInfo( const wxNativeFontInfo& info );
+    
+    // Implementation
+    
+    // Find an existing, or create a new, XFontStruct
+    // based on this wxFont and the given scale. Append the
+    // font to list in the private data for future reference.
+    
+    // TODO This is a fairly basic implementation, that doesn't
+    // allow for different facenames, and also doesn't do a mapping
+    // between 'standard' facenames (e.g. Arial, Helvetica, Times Roman etc.)
+    // and the fonts that are available on a particular system.
+    // Maybe we need to scan the user's machine to build up a profile
+    // of the fonts and a mapping file.
+    
+    // Return font struct, and optionally the Motif font list
+    wxXFont *GetInternalFont(double scale = 1.0,
+        WXDisplay* display = NULL) const;
+    
+    // These two are helper functions for convenient access of the above.
+    WXFontStructPtr GetFontStruct(double scale = 1.0,
+        WXDisplay* display = NULL) const;
+    WXFontList GetFontList(double scale = 1.0,
+        WXDisplay* display = NULL) const;
+    
+protected:
+    // common part of all ctors
+    void Init();
+    
+    // VZ: IMHO, we don't need it at all...
+    bool RealizeResource() { return TRUE; }
+    void Unshare();
+    
+private:
+    DECLARE_DYNAMIC_CLASS(wxFont)
+};
+
+#endif
+// _WX_FONT_H_
--- a/include/wx/x11/gdiobj.h
+++ b/include/wx/x11/gdiobj.h
@@ -0,0 +1,48 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        gdiobj.h
+// Purpose:     wxGDIObject class: base class for other GDI classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GDIOBJ_H_
+#define _WX_GDIOBJ_H_
+
+#include "wx/object.h"
+
+#ifdef __GNUG__
+#pragma interface "gdiobj.h"
+#endif
+
+class WXDLLEXPORT wxGDIRefData: public wxObjectRefData {
+public:
+    inline wxGDIRefData()
+    {
+    }
+};
+
+#define M_GDIDATA ((wxGDIRefData *)m_refData)
+
+class WXDLLEXPORT wxGDIObject: public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxGDIObject)
+public:
+    inline wxGDIObject() { m_visible = FALSE; };
+    inline ~wxGDIObject() {};
+    
+    inline bool IsNull() const { return (m_refData == 0); }
+    
+    virtual bool GetVisible() { return m_visible; }
+    virtual void SetVisible(bool v) { m_visible = v; }
+    
+protected:
+    bool m_visible; // Can a pointer to this object be safely taken?
+    // - only if created within FindOrCreate...
+};
+
+#endif
+// _WX_GDIOBJ_H_
--- a/include/wx/x11/glcanvas.h
+++ b/include/wx/x11/glcanvas.h
@@ -0,0 +1,161 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        glcanvas.h
+// Purpose:     wxGLCanvas, for using OpenGL with wxWindows 2.0 for Motif.
+//              Uses the GLX extension.
+// Author:      Julian Smart and Wolfram Gloger
+// Modified by:
+// Created:     1995, 1999
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart, Wolfram Gloger
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma interface "glcanvas.h"
+#endif
+
+#ifndef _WX_GLCANVAS_H_
+#define _WX_GLCANVAS_H_
+
+#include "wx/setup.h"
+
+#if wxUSE_GLCANVAS
+
+#include "wx/gdicmn.h"
+#include "wx/palette.h"
+#include "wx/scrolwin.h"
+
+#include <GL/glx.h>
+
+enum
+{
+    WX_GL_RGBA=1,          /* use true color palette */
+        WX_GL_BUFFER_SIZE,     /* bits for buffer if not WX_GL_RGBA */
+        WX_GL_LEVEL,           /* 0 for main buffer, >0 for overlay, <0 for underlay */
+        WX_GL_DOUBLEBUFFER,    /* use doublebuffer */
+        WX_GL_STEREO,          /* use stereoscopic display */
+        WX_GL_AUX_BUFFERS,     /* number of auxiliary buffers */
+        WX_GL_MIN_RED,         /* use red buffer with most bits (> MIN_RED bits) */
+        WX_GL_MIN_GREEN,       /* use green buffer with most bits (> MIN_GREEN bits) */
+        WX_GL_MIN_BLUE,        /* use blue buffer with most bits (> MIN_BLUE bits) */
+        WX_GL_MIN_ALPHA,       /* use blue buffer with most bits (> MIN_ALPHA bits) */
+        WX_GL_DEPTH_SIZE,      /* bits for Z-buffer (0,16,32) */
+        WX_GL_STENCIL_SIZE,    /* bits for stencil buffer */
+        WX_GL_MIN_ACCUM_RED,   /* use red accum buffer with most bits (> MIN_ACCUM_RED bits) */
+        WX_GL_MIN_ACCUM_GREEN, /* use green buffer with most bits (> MIN_ACCUM_GREEN bits) */
+        WX_GL_MIN_ACCUM_BLUE,  /* use blue buffer with most bits (> MIN_ACCUM_BLUE bits) */
+        WX_GL_MIN_ACCUM_ALPHA  /* use blue buffer with most bits (> MIN_ACCUM_ALPHA bits) */
+};
+
+//---------------------------------------------------------------------------
+// classes
+//---------------------------------------------------------------------------
+
+
+class WXDLLEXPORT wxGLContext: public wxObject
+{
+public:
+    wxGLContext( bool isRGB, wxWindow *win, 
+        const wxPalette& palette = wxNullPalette );
+    wxGLContext( bool WXUNUSED(isRGB), wxWindow *win, 
+        const wxPalette& WXUNUSED(palette),
+        const wxGLContext *other  /* for sharing display lists */
+        );
+    ~wxGLContext();
+    
+    void SetCurrent();
+    void SetColour(const char *colour);
+    void SwapBuffers();
+    
+    void SetupPixelFormat();
+    void SetupPalette(const wxPalette& palette);
+    wxPalette CreateDefaultPalette();
+    
+    inline wxPalette* GetPalette() const { return (wxPalette*) & m_palette; }
+    inline wxWindow* GetWindow() const { return m_window; }
+    // inline GtkWidget* GetWidget() const { return m_widget; }
+    inline GLXContext GetContext() const { return m_glContext; }
+    
+public:
+    GLXContext       m_glContext;
+    
+    // GtkWidget       *m_widget;
+    wxPalette        m_palette;
+    wxWindow*        m_window;
+    
+    DECLARE_CLASS(wxGLContext)
+};
+
+
+class WXDLLEXPORT wxGLCanvas: public wxScrolledWindow
+{
+public:
+    inline wxGLCanvas() {
+        m_glContext = (wxGLContext*) NULL;
+        m_sharedContext = (wxGLContext*) NULL;
+        // m_glWidget = (GtkWidget*) NULL;
+        m_vi = (void*) NULL;
+        // m_exposed = FALSE;
+    }
+    wxGLCanvas( wxWindow *parent, wxWindowID id = -1, 
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, 
+        long style = 0, const wxString& name = "GLCanvas", 
+        int *attribList = (int*) NULL, 
+        const wxPalette& palette = wxNullPalette );
+    wxGLCanvas( wxWindow *parent, const wxGLContext *shared = (wxGLContext *)NULL,
+        wxWindowID id = -1, 
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, 
+        long style = 0, const wxString& name = "GLCanvas", 
+        int *attribList = (int*) NULL, 
+        const wxPalette& palette = wxNullPalette );
+    wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared = (wxGLCanvas *)NULL,
+        wxWindowID id = -1, 
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, 
+        long style = 0, const wxString& name = "GLCanvas", 
+        int *attribList = (int*) NULL, 
+        const wxPalette& palette = wxNullPalette );
+    
+    bool Create( wxWindow *parent, 
+        const wxGLContext *shared = (wxGLContext*)NULL,
+        const wxGLCanvas *shared_context_of = (wxGLCanvas*)NULL,
+        wxWindowID id = -1, 
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, 
+        long style = 0, const wxString& name = "GLCanvas", 
+        int *attribList = (int*) NULL,
+        const wxPalette& palette = wxNullPalette );
+    
+    ~wxGLCanvas();
+    
+    void SetCurrent();
+    void SetColour(const char *colour);
+    void SwapBuffers();
+    
+    // void OnSize(wxSizeEvent& event);
+    
+    // void OnInternalIdle();
+    
+    inline wxGLContext* GetContext() const { return m_glContext; } 
+    
+    // implementation
+    
+    wxGLContext      *m_glContext,
+        *m_sharedContext;
+    wxGLCanvas       *m_sharedContextOf;
+    void             *m_vi;
+    // GtkWidget        *m_glWidget;
+    // bool              m_exposed;
+    
+    DECLARE_EVENT_TABLE()
+        DECLARE_CLASS(wxGLCanvas)
+        
+};
+
+#endif
+//  wxUSE_GLCANVAS
+
+#endif
+// _WX_GLCANVAS_H_
--- a/include/wx/x11/icon.h
+++ b/include/wx/x11/icon.h
@@ -0,0 +1,57 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        icon.h
+// Purpose:     wxIcon class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_ICON_H_
+#define _WX_ICON_H_
+
+#ifdef __GNUG__
+#pragma interface "icon.h"
+#endif
+
+#include "wx/bitmap.h"
+
+#define M_ICONDATA ((wxBitmapRefData *)m_refData)
+#define M_ICONHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
+
+// Icon
+class WXDLLEXPORT wxIcon: public wxBitmap
+{
+    DECLARE_DYNAMIC_CLASS(wxIcon)
+        
+public:
+    wxIcon();
+    
+    // Copy constructors
+    inline wxIcon(const wxIcon& icon) { Ref(icon); }
+    
+    // Initialize with XBM data
+    wxIcon(const char bits[], int width, int height);
+    
+    // Initialize with XPM data
+    wxIcon(const char **data);
+    wxIcon(char **data);
+    
+    wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_XPM,
+        int desiredWidth = -1, int desiredHeight = -1);
+    ~wxIcon();
+    
+    bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_XPM,
+        int desiredWidth = -1, int desiredHeight = -1);
+    
+    inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
+    inline bool operator == (const wxIcon& icon) const { return m_refData == icon.m_refData; }
+    inline bool operator != (const wxIcon& icon) const { return m_refData != icon.m_refData; }
+    
+    virtual bool Ok() const { return ((m_refData != NULL) && (M_ICONDATA->m_ok)); }
+};
+
+#endif
+// _WX_ICON_H_
--- a/include/wx/x11/joystick.h
+++ b/include/wx/x11/joystick.h
@@ -0,0 +1,93 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        joystick.h
+// Purpose:     wxJoystick class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_JOYSTICK_H_
+#define _WX_JOYSTICK_H_
+
+#ifdef __GNUG__
+#pragma interface "joystick.h"
+#endif
+
+#include "wx/event.h"
+
+class WXDLLEXPORT wxJoystick: public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxJoystick)
+public:
+/*
+* Public interface
+    */
+    
+    wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; };
+    
+    // Attributes
+    ////////////////////////////////////////////////////////////////////////////
+    
+    wxPoint GetPosition() const;
+    int GetZPosition() const;
+    int GetButtonState() const;
+    int GetPOVPosition() const;
+    int GetPOVCTSPosition() const;
+    int GetRudderPosition() const;
+    int GetUPosition() const;
+    int GetVPosition() const;
+    int GetMovementThreshold() const;
+    void SetMovementThreshold(int threshold) ;
+    
+    // Capabilities
+    ////////////////////////////////////////////////////////////////////////////
+    
+    bool IsOk() const; // Checks that the joystick is functioning
+    int GetNumberJoysticks() const ;
+    int GetManufacturerId() const ;
+    int GetProductId() const ;
+    wxString GetProductName() const ;
+    int GetXMin() const;
+    int GetYMin() const;
+    int GetZMin() const;
+    int GetXMax() const;
+    int GetYMax() const;
+    int GetZMax() const;
+    int GetNumberButtons() const;
+    int GetNumberAxes() const;
+    int GetMaxButtons() const;
+    int GetMaxAxes() const;
+    int GetPollingMin() const;
+    int GetPollingMax() const;
+    int GetRudderMin() const;
+    int GetRudderMax() const;
+    int GetUMin() const;
+    int GetUMax() const;
+    int GetVMin() const;
+    int GetVMax() const;
+    
+    bool HasRudder() const;
+    bool HasZ() const;
+    bool HasU() const;
+    bool HasV() const;
+    bool HasPOV() const;
+    bool HasPOV4Dir() const;
+    bool HasPOVCTS() const;
+    
+    // Operations
+    ////////////////////////////////////////////////////////////////////////////
+    
+    // pollingFreq = 0 means that movement events are sent when above the threshold.
+    // If pollingFreq > 0, events are received every this many milliseconds.
+    bool SetCapture(wxWindow* win, int pollingFreq = 0);
+    bool ReleaseCapture();
+    
+protected:
+    int       m_joystick;
+};
+
+#endif
+// _WX_JOYSTICK_H_
--- a/include/wx/x11/mdi.h
+++ b/include/wx/x11/mdi.h
@@ -0,0 +1,250 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        mdi.h
+// Purpose:     MDI (Multiple Document Interface) classes.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MDI_H_
+#define _WX_MDI_H_
+
+#ifdef __GNUG__
+#pragma interface "mdi.h"
+#endif
+
+/*
+New MDI scheme using tabs. We can use a wxNotebook to implement the client
+window. wxMDIChildFrame can be implemented as an XmMainWindow widget
+as before, and is a child of the notebook _and_ of the parent frame...
+but wxMDIChildFrame::GetParent should return the parent frame.
+
+*/
+
+#include "wx/frame.h"
+#include "wx/notebook.h"
+
+WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxStatusLineNameStr;
+
+class WXDLLEXPORT wxMDIClientWindow;
+class WXDLLEXPORT wxMDIChildFrame;
+
+class WXDLLEXPORT wxMDIParentFrame: public wxFrame
+{
+    DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
+        
+        friend class WXDLLEXPORT wxMDIChildFrame;
+public:
+    
+    wxMDIParentFrame();
+    inline wxMDIParentFrame(wxWindow *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,  // Scrolling refers to client window
+        const wxString& name = wxFrameNameStr)
+    {
+        Create(parent, id, title, pos, size, style, name);
+    }
+    
+    ~wxMDIParentFrame();
+    
+    bool Create(wxWindow *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+        const wxString& name = wxFrameNameStr);
+    
+    void OnSize(wxSizeEvent& event);
+    void OnActivate(wxActivateEvent& event);
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+    void OnMenuHighlight(wxMenuEvent& event);
+    
+    void SetMenuBar(wxMenuBar *menu_bar);
+    
+    // Get the active MDI child window
+    wxMDIChildFrame *GetActiveChild() const ;
+    
+    // Get the client window
+    wxMDIClientWindow *GetClientWindow() const { return m_clientWindow; };
+    
+    // Create the client window class (don't Create the window,
+    // just return a new class)
+    virtual wxMDIClientWindow *OnCreateClient() ;
+    
+    // MDI operations
+    virtual void Cascade();
+    virtual void Tile();
+    virtual void ArrangeIcons();
+    virtual void ActivateNext();
+    virtual void ActivatePrevious();
+    
+    // Implementation
+    
+    // Set the active child
+    inline void SetActiveChild(wxMDIChildFrame* child) { m_activeChild = child; }
+    
+    // Set the child's menubar into the parent frame
+    void SetChildMenuBar(wxMDIChildFrame* frame);
+    
+    inline wxMenuBar* GetActiveMenuBar() const { return m_activeMenuBar; }
+    
+    // Redirect events to active child first
+    virtual bool ProcessEvent(wxEvent& event);
+    
+protected:
+    virtual void DoSetSize(int x, int y,
+        int width, int height,
+        int sizeFlags = wxSIZE_AUTO);
+    virtual void DoSetClientSize(int width, int height);
+    
+    // Gets the size available for subwindows after menu size, toolbar size
+    // and status bar size have been subtracted. If you want to manage your own
+    // toolbar(s), don't call SetToolBar.
+    void DoGetClientSize(int *width, int *height) const;
+    
+protected:
+    
+    wxMDIClientWindow*    m_clientWindow;
+    wxMDIChildFrame*      m_activeChild;
+    wxMenuBar*            m_activeMenuBar;
+    
+    DECLARE_EVENT_TABLE()
+};
+
+class WXDLLEXPORT wxMDIChildFrame: public wxFrame
+{
+    DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
+        
+public:
+    wxMDIChildFrame();
+    wxMDIChildFrame(wxMDIParentFrame *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE,
+        const wxString& name = wxFrameNameStr)
+    {
+        Create(parent, id, title, pos, size, style, name);
+    }
+    
+    ~wxMDIChildFrame();
+    
+    bool Create(wxMDIParentFrame *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE,
+        const wxString& name = wxFrameNameStr);
+    
+    // Set menu bar
+    void SetMenuBar(wxMenuBar *menu_bar);
+    void SetTitle(const wxString& title);
+    
+    // Set icon
+    virtual void SetIcon(const wxIcon& icon);
+    
+    // Override wxFrame operations
+    void CaptureMouse();
+    void ReleaseMouse();
+    void Raise();
+    void Lower(void);
+    void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1);
+    
+    // MDI operations
+    virtual void Maximize();
+    virtual void Maximize(bool WXUNUSED(maximize)) { };
+    inline void Minimize() { Iconize(TRUE); };
+    virtual void Iconize(bool iconize);
+    virtual void Restore();
+    virtual void Activate();
+    virtual bool IsIconized() const ;
+    
+    virtual bool IsTopLevel() const { return FALSE; }
+    
+    // Is the frame maximized? Returns TRUE for
+    // wxMDIChildFrame due to the tabbed implementation.
+    virtual bool IsMaximized(void) const ;
+    
+    bool Show(bool show);
+    
+    WXWidget GetMainWidget() const { return m_mainWidget; };
+    WXWidget GetTopWidget() const { return m_mainWidget; };
+    WXWidget GetClientWidget() const { return m_mainWidget; };
+    
+    /*
+    virtual void OnRaise();
+    virtual void OnLower();
+    */
+    
+    void SetMDIParentFrame(wxMDIParentFrame* parentFrame) { m_mdiParentFrame = parentFrame; }
+    wxMDIParentFrame* GetMDIParentFrame() const { return m_mdiParentFrame; }
+    
+protected:
+    wxMDIParentFrame* m_mdiParentFrame;
+    
+    virtual void DoSetSize(int x, int y,
+        int width, int height,
+        int sizeFlags = wxSIZE_AUTO);
+    virtual void DoSetClientSize(int width, int height);
+    
+    void DoGetClientSize(int *width, int *height) const;
+    void DoGetSize(int *width, int *height) const;
+    void DoGetPosition(int *x, int *y) const ;
+};
+
+/* The client window is a child of the parent MDI frame, and itself
+* contains the child MDI frames.
+* However, you create the MDI children as children of the MDI parent:
+* only in the implementation does the client window become the parent
+* of the children. Phew! So the children are sort of 'adopted'...
+*/
+
+class WXDLLEXPORT wxMDIClientWindow: public wxNotebook
+{
+    DECLARE_DYNAMIC_CLASS(wxMDIClientWindow)
+        
+public:
+    wxMDIClientWindow() ;
+    wxMDIClientWindow(wxMDIParentFrame *parent, long style = 0)
+    {
+        CreateClient(parent, style);
+    }
+    
+    ~wxMDIClientWindow();
+    
+    // Note: this is virtual, to allow overridden behaviour.
+    virtual bool CreateClient(wxMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL);
+    
+    // Explicitly call default scroll behaviour
+    void OnScroll(wxScrollEvent& event);
+    
+    // Implementation
+    void OnPageChanged(wxNotebookEvent& event);
+    
+protected:
+    virtual void DoSetSize(int x, int y,
+        int width, int height,
+        int sizeFlags = wxSIZE_AUTO);
+    virtual void DoSetClientSize(int width, int height);
+    
+    void DoGetClientSize(int *width, int *height) const;
+    void DoGetSize(int *width, int *height) const ;
+    void DoGetPosition(int *x, int *y) const ;
+    
+    
+private:
+    DECLARE_EVENT_TABLE()
+};
+
+#endif
+// _WX_MDI_H_
--- a/include/wx/x11/minifram.h
+++ b/include/wx/x11/minifram.h
@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        minifram.h
+// Purpose:     wxMiniFrame class. A small frame for e.g. floating toolbars.
+//              If there is no equivalent on your platform, just make it a
+//              normal frame.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MINIFRAM_H_
+#define _WX_MINIFRAM_H_
+
+#ifdef __GNUG__
+#pragma interface "minifram.h"
+#endif
+
+#include "wx/frame.h"
+
+class WXDLLEXPORT wxMiniFrame: public wxFrame {
+    
+    DECLARE_DYNAMIC_CLASS(wxMiniFrame)
+        
+public:
+    inline wxMiniFrame() {}
+    inline wxMiniFrame(wxWindow *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE|wxTINY_CAPTION_HORIZ,
+        const wxString& name = wxFrameNameStr)
+    {
+        // Use wxFrame constructor in absence of more specific code.
+        Create(parent, id, title, pos, size, style, name);
+    }
+    
+    ~wxMiniFrame() {}
+protected:
+};
+
+#endif
+// _WX_MINIFRAM_H_
--- a/include/wx/x11/palette.h
+++ b/include/wx/x11/palette.h
@@ -0,0 +1,81 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        palette.h
+// Purpose:     wxPalette class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PALETTE_H_
+#define _WX_PALETTE_H_
+
+#ifdef __GNUG__
+#pragma interface "palette.h"
+#endif
+
+#include "wx/gdiobj.h"
+#include "wx/list.h"
+
+class WXDLLEXPORT wxPalette;
+
+// Palette for one display
+class wxXPalette : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxXPalette)
+        
+public:
+    wxXPalette();
+    
+    WXDisplay*        m_display;
+    int               m_pix_array_n;
+    unsigned long*    m_pix_array;
+    WXColormap        m_cmap;
+    bool              m_destroyable;
+};
+
+class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
+{
+    friend class WXDLLEXPORT wxPalette;
+public:
+    wxPaletteRefData();
+    ~wxPaletteRefData();
+    
+protected:
+    wxList  m_palettes;
+};
+
+#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
+
+class WXDLLEXPORT wxPalette: public wxGDIObject
+{
+    DECLARE_DYNAMIC_CLASS(wxPalette)
+        
+public:
+    wxPalette();
+    wxPalette(const wxPalette& palette) { Ref(palette); }
+    
+    wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
+    ~wxPalette();
+    bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
+    int GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const;
+    bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
+    
+    virtual bool Ok() const { return (m_refData != NULL) ; }
+    
+    wxPalette& operator = (const wxPalette& palette) { if (*this == palette) return (*this); Ref(palette); return *this; }
+    bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
+    bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
+    
+    // Motif-specific
+    WXColormap GetXColormap(WXDisplay* display = NULL) const;
+    bool TransferBitmap(void *data, int depth, int size);
+    bool TransferBitmap8(unsigned char *data, unsigned long size, void *dest, unsigned int bpp);
+    unsigned long *GetXPixArray(WXDisplay* display, int *pix_array_n);
+    void PutXColormap(WXDisplay* display, WXColormap cmap, bool destroyable);
+};
+
+#endif
+// _WX_PALETTE_H_
--- a/include/wx/x11/pen.h
+++ b/include/wx/x11/pen.h
@@ -0,0 +1,102 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        pen.h
+// Purpose:     wxPen class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PEN_H_
+#define _WX_PEN_H_
+
+#ifdef __GNUG__
+#pragma interface "pen.h"
+#endif
+
+#include "wx/gdiobj.h"
+#include "wx/colour.h"
+#include "wx/bitmap.h"
+
+typedef char wxMOTIFDash;
+
+class WXDLLEXPORT wxPen;
+
+class WXDLLEXPORT wxPenRefData: public wxGDIRefData
+{
+    friend class WXDLLEXPORT wxPen;
+public:
+    wxPenRefData();
+    wxPenRefData(const wxPenRefData& data);
+    ~wxPenRefData();
+    
+protected:
+    int           m_width;
+    int           m_style;
+    int           m_join ;
+    int           m_cap ;
+    wxBitmap      m_stipple ;
+    int           m_nbDash ;
+    wxMOTIFDash  *m_dash ;
+    wxColour      m_colour;
+};
+
+#define M_PENDATA ((wxPenRefData *)m_refData)
+
+// Pen
+class WXDLLEXPORT wxPen: public wxGDIObject
+{
+    DECLARE_DYNAMIC_CLASS(wxPen)
+public:
+    wxPen();
+    wxPen(const wxColour& col, int width, int style);
+    wxPen(const wxBitmap& stipple, int width);
+    inline wxPen(const wxPen& pen) { Ref(pen); }
+    ~wxPen();
+    
+    inline wxPen& operator = (const wxPen& pen) { if (*this == pen) return (*this); Ref(pen); return *this; }
+    inline bool operator == (const wxPen& pen) const { return m_refData == pen.m_refData; }
+    inline bool operator != (const wxPen& pen) const { return m_refData != pen.m_refData; }
+    
+    virtual bool Ok() const { return (m_refData != NULL) ; }
+    
+    // Override in order to recreate the pen
+    void SetColour(const wxColour& col) ;
+    void SetColour(unsigned char r, unsigned char g, unsigned char b)  ;
+    
+    void SetWidth(int width)  ;
+    void SetStyle(int style)  ;
+    void SetStipple(const wxBitmap& stipple)  ;
+    void SetDashes(int nb_dashes, const wxDash *dash)  ;
+    void SetJoin(int join)  ;
+    void SetCap(int cap)  ;
+    
+    inline wxColour& GetColour() const { return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour); };
+    inline int GetWidth() const { return (M_PENDATA ? M_PENDATA->m_width : 0); };
+    inline int GetStyle() const { return (M_PENDATA ? M_PENDATA->m_style : 0); };
+    inline int GetJoin() const { return (M_PENDATA ? M_PENDATA->m_join : 0); };
+    inline int GetCap() const { return (M_PENDATA ? M_PENDATA->m_cap : 0); };
+    inline int GetDashes(wxDash **ptr) const
+    {
+        *ptr = (M_PENDATA ? (wxDash*)M_PENDATA->m_dash : (wxDash*) NULL);
+        return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
+    }
+    inline int GetDashCount() const { return (M_PENDATA->m_nbDash); }
+    inline wxDash* GetDash() const { return (wxDash*)M_PENDATA->m_dash; }
+    
+    inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL); };
+    
+    // Implementation
+    
+    // Useful helper: create the brush resource
+    bool RealizeResource();
+    
+    // When setting properties, we must make sure we're not changing
+    // another object
+    void Unshare();
+};
+
+#endif
+// _WX_PEN_H_
--- a/include/wx/x11/popupwin.h
+++ b/include/wx/x11/popupwin.h
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/msw/popupwin.h
+// Purpose:     wxPopupWindow class for wxMSW
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     06.01.01
+// RCS-ID:      $Id$
+// Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MSW_POPUPWIN_H_
+#define _WX_MSW_POPUPWIN_H_
+
+// ----------------------------------------------------------------------------
+// wxPopupWindow
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPopupWindow : public wxPopupWindowBase
+{
+public:
+    wxPopupWindow() { }
+
+    wxPopupWindow(wxWindow *parent, int flags = wxBORDER_NONE)
+        { (void)Create(parent, flags); }
+
+    bool Create(wxWindow *parent, int flags = wxBORDER_NONE)
+    {
+        return wxPopupWindowBase::Create(parent) &&
+               wxWindow::Create(parent, -1,
+                                wxDefaultPosition, wxDefaultSize,
+                                (flags & wxBORDER_MASK) | wxPOPUP_WINDOW);
+    }
+
+protected:
+    virtual void DoGetPosition(int *x, int *y) const
+    {
+        // the position of a "top level" window such as this should be in
+        // screen coordinates, not in the client ones which MSW gives us
+        // (because we are a child window)
+        wxPopupWindowBase::DoGetPosition(x, y);
+
+        GetParent()->ClientToScreen(x, y);
+    }
+
+    DECLARE_DYNAMIC_CLASS(wxPopupWindow)
+};
+
+#endif // _WX_MSW_POPUPWIN_H_
+
--- a/include/wx/x11/print.h
+++ b/include/wx/x11/print.h
@@ -0,0 +1,56 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        print.h
+// Purpose:     wxPrinter, wxPrintPreview classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PRINT_H_
+#define _WX_PRINT_H_
+
+#ifdef __GNUG__
+#pragma interface "print.h"
+#endif
+
+#include "wx/prntbase.h"
+
+/*
+* Represents the printer: manages printing a wxPrintout object
+*/
+
+class WXDLLEXPORT wxPrinter: public wxPrinterBase
+{
+    DECLARE_DYNAMIC_CLASS(wxPrinter)
+        
+public:
+    wxPrinter(wxPrintData *data = NULL);
+    ~wxPrinter();
+    
+    virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE);
+    virtual bool PrintDialog(wxWindow *parent);
+    virtual bool Setup(wxWindow *parent);
+};
+
+/*
+* wxPrintPreview
+* Programmer creates an object of this class to preview a wxPrintout.
+*/
+
+class WXDLLEXPORT wxPrintPreview: public wxPrintPreviewBase
+{
+    DECLARE_CLASS(wxPrintPreview)
+        
+public:
+    wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting = NULL, wxPrintData *data = NULL);
+    ~wxPrintPreview();
+    
+    virtual bool Print(bool interactive);
+    virtual void DetermineScaling();
+};
+
+#endif
+// _WX_PRINT_H_
--- a/include/wx/x11/private.h
+++ b/include/wx/x11/private.h
@@ -0,0 +1,120 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        private.h
+// Purpose:     Private declarations for wxMotif port
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PRIVATE_H_
+#define _WX_PRIVATE_H_
+
+#include "wx/defs.h"
+
+class wxMouseEvent;
+class wxKeyEvent;
+
+// 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);
+
+// 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);
+
+// ----------------------------------------------------------------------------
+// key events related functions
+// ----------------------------------------------------------------------------
+
+extern char wxFindMnemonic(const char* s);
+
+extern char * wxFindAccelerator (const char *s);
+extern XmString wxFindAcceleratorText (const char *s);
+
+extern int wxCharCodeXToWX(KeySym keySym);
+extern KeySym wxCharCodeWXToX(int id);
+
+// ----------------------------------------------------------------------------
+// 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 );
+
+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);
+
+#define wxNO_COLORS   0x00
+#define wxBACK_COLORS 0x01
+#define wxFORE_COLORS 0x02
+
+extern XColor itemColors[5] ;
+
+#define wxBACK_INDEX 0
+#define wxFORE_INDEX 1
+#define wxSELE_INDEX 2
+#define wxTOPS_INDEX 3
+#define wxBOTS_INDEX 4
+
+// ----------------------------------------------------------------------------
+// utility classes
+// ----------------------------------------------------------------------------
+
+// XmString made easy to use in wxWindows (and has an added benefit of
+// cleaning up automatically)
+class wxXmString
+{
+public:
+    wxXmString(const wxString& str)
+    {
+        m_string = XmStringCreateLtoR((char *)str.c_str(),
+            XmSTRING_DEFAULT_CHARSET);
+    }
+    
+    ~wxXmString() { XmStringFree(m_string); }
+    
+    // semi-implicit conversion to XmString (shouldn't rely on implicit
+    // conversion because many of Motif functions are macros)
+    XmString operator()() const { return m_string; }
+    
+private:
+    XmString m_string;
+};
+
+// ----------------------------------------------------------------------------
+// macros to avoid casting WXFOO to Foo all the time
+// ----------------------------------------------------------------------------
+
+// argument is of type "wxWindow *"
+#define GetWidget(w)    ((Widget)(w)->GetHandle())
+
+// ----------------------------------------------------------------------------
+// accessors for C modules
+// ----------------------------------------------------------------------------
+
+extern "C" XtAppContext wxGetAppContext();
+
+#endif
+// _WX_PRIVATE_H_
--- a/include/wx/x11/region.h
+++ b/include/wx/x11/region.h
@@ -0,0 +1,155 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        region.h
+// Purpose:     wxRegion class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_REGION_H_
+#define _WX_REGION_H_
+
+#ifdef __GNUG__
+#pragma interface "region.h"
+#endif
+
+#include "wx/list.h"
+#include "wx/gdiobj.h"
+#include "wx/gdicmn.h"
+
+// ----------------------------------------------------------------------------
+// A list of rectangles type used by wxRegion and wxWindow
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(wxRect, wxRectList);
+
+
+enum wxRegionContain {
+    wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2
+};
+
+// So far, for internal use only
+enum wxRegionOp {
+    wxRGN_AND,          // Creates the intersection of the two combined regions.
+        wxRGN_COPY,         // Creates a copy of the region identified by hrgnSrc1.
+        wxRGN_DIFF,         // Combines the parts of hrgnSrc1 that are not part of hrgnSrc2.
+        wxRGN_OR,           // Creates the union of two combined regions.
+        wxRGN_XOR           // Creates the union of two combined regions except for any overlapping areas.
+};
+
+class WXDLLEXPORT wxRegion : public wxGDIObject {
+    DECLARE_DYNAMIC_CLASS(wxRegion)
+        friend class WXDLLEXPORT wxRegionIterator;
+public:
+    wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
+    wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
+    wxRegion(const wxRect& rect);
+    wxRegion();
+    ~wxRegion();
+    
+    //# Copying
+    inline wxRegion(const wxRegion& r)
+    { Ref(r); }
+    inline wxRegion& operator = (const wxRegion& r)
+    { Ref(r); return (*this); }
+    
+    //# Modify region
+    // Clear current region
+    void Clear();
+    
+    // Union rectangle or region with this.
+    inline bool Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height) { return Combine(x, y, width, height, wxRGN_OR); }
+    inline bool Union(const wxRect& rect) { return Combine(rect, wxRGN_OR); }
+    inline bool Union(const wxRegion& region) { return Combine(region, wxRGN_OR); }
+    
+    // Intersect rectangle or region with this.
+    inline bool Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height) { return Combine(x, y, width, height, wxRGN_AND); }
+    inline bool Intersect(const wxRect& rect)  { return Combine(rect, wxRGN_AND); }
+    inline bool Intersect(const wxRegion& region)  { return Combine(region, wxRGN_AND); }
+    
+    // Subtract rectangle or region from this:
+    // Combines the parts of 'this' that are not part of the second region.
+    inline bool Subtract(wxCoord x, wxCoord y, wxCoord width, wxCoord height) { return Combine(x, y, width, height, wxRGN_DIFF); }
+    inline bool Subtract(const wxRect& rect)  { return Combine(rect, wxRGN_DIFF); }
+    inline bool Subtract(const wxRegion& region)  { return Combine(region, wxRGN_DIFF); }
+    
+    // XOR: the union of two combined regions except for any overlapping areas.
+    inline bool Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height) { return Combine(x, y, width, height, wxRGN_XOR); }
+    inline bool Xor(const wxRect& rect)  { return Combine(rect, wxRGN_XOR); }
+    inline bool Xor(const wxRegion& region)  { return Combine(region, wxRGN_XOR); }
+    
+    //# Information on region
+    // Outer bounds of region
+    void GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const;
+    wxRect GetBox() const ;
+    
+    // Is region empty?
+    bool Empty() const;
+    inline bool IsEmpty() const { return Empty(); }
+    bool Ok() const { return (m_refData != NULL) ; }
+    
+    //# Tests
+    // Does the region contain the point (x,y)?
+    wxRegionContain Contains(wxCoord x, wxCoord y) const;
+    // Does the region contain the point pt?
+    wxRegionContain Contains(const wxPoint& pt) const;
+    // Does the region contain the rectangle (x, y, w, h)?
+    wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const;
+    // Does the region contain the rectangle rect?
+    wxRegionContain Contains(const wxRect& rect) const;
+    
+    // Internal
+    bool Combine(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxRegionOp op);
+    bool Combine(const wxRegion& region, wxRegionOp op);
+    bool Combine(const wxRect& rect, wxRegionOp op);
+    
+    // Get the internal Region handle
+    WXRegion GetXRegion() const;
+    
+    // 'Naughty' functions that allow wxWindows to use a list of rects
+    // instead of the region, in certain circumstances (e.g. when
+    // making a region out of the update rectangles).
+    // These are used by wxPaintDC::wxPaintDC and wxRegionIterator::Reset.
+    bool UsingRects() const;
+    wxRect* GetRects();
+    int GetRectCount() const;
+    void SetRects(const wxRectList& rectList);
+    void SetRects(int count, const wxRect* rects);
+};
+
+class WXDLLEXPORT wxRegionIterator : public wxObject {
+    DECLARE_DYNAMIC_CLASS(wxRegionIterator)
+public:
+    wxRegionIterator();
+    wxRegionIterator(const wxRegion& region);
+    ~wxRegionIterator();
+    
+    void Reset() { m_current = 0; }
+    void Reset(const wxRegion& region);
+    
+    operator bool () const { return m_current < m_numRects; }
+    bool HaveRects() const { return m_current < m_numRects; }
+    
+    void operator ++ ();
+    void operator ++ (int);
+    
+    wxCoord GetX() const;
+    wxCoord GetY() const;
+    wxCoord GetW() const;
+    wxCoord GetWidth() const { return GetW(); }
+    wxCoord GetH() const;
+    wxCoord GetHeight() const { return GetH(); }
+    wxRect GetRect() const { return wxRect(GetX(), GetY(), GetWidth(), GetHeight()); }
+    
+private:
+    size_t	 m_current;
+    size_t	 m_numRects;
+    wxRegion m_region;
+    wxRect*  m_rects;
+};
+
+#endif
+// _WX_REGION_H_
--- a/include/wx/x11/timer.h
+++ b/include/wx/x11/timer.h
@@ -0,0 +1,44 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        timer.h
+// Purpose:     wxTimer class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_TIMER_H_
+#define _WX_TIMER_H_
+
+#ifdef __GNUG__
+#pragma interface "timer.h"
+#endif
+
+class WXDLLEXPORT wxTimer : public wxTimerBase
+{
+    friend void wxTimerCallback(wxTimer * timer);
+    
+public:
+    wxTimer() { Init(); }
+    wxTimer(wxEvtHandler *owner, int id = -1) : wxTimerBase(owner, id)
+    { Init(); }
+    ~wxTimer();
+    
+    virtual bool Start(int milliseconds = -1, bool oneShot = FALSE);
+    virtual void Stop();
+    
+    virtual bool IsRunning() const { return m_id != 0; }
+    
+protected:
+    void Init();
+    
+    long m_id;
+    
+private:
+    DECLARE_DYNAMIC_CLASS(wxTimer)
+};
+
+#endif
+// _WX_TIMER_H_
--- a/include/wx/x11/toolbar.h
+++ b/include/wx/x11/toolbar.h
@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/motif/toolbar.h
+// Purpose:     wxToolBar class
+// Author:      Julian Smart
+// Modified by: 13.12.99 by VZ during toolbar classes reorganization
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_TOOLBAR_H_
+#define _WX_TOOLBAR_H_
+
+#ifdef __GNUG__
+#pragma interface "toolbar.h"
+#endif
+
+class WXDLLEXPORT wxToolBar : public wxToolBarBase
+{
+public:
+    // ctors and dtor
+    wxToolBar() { Init(); }
+    
+    wxToolBar(wxWindow *parent,
+        wxWindowID id,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxNO_BORDER | wxTB_HORIZONTAL,
+        const wxString& name = wxToolBarNameStr)
+    {
+        Init();
+        
+        Create(parent, id, pos, size, style, name);
+    }
+    
+    bool Create(wxWindow *parent,
+        wxWindowID id,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxNO_BORDER | wxTB_HORIZONTAL,
+        const wxString& name = wxToolBarNameStr);
+    
+    virtual ~wxToolBar();
+    
+    // override/implement base class virtuals
+    virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
+    
+    virtual bool Realize();
+    
+    // implementation from now on
+    
+    // find tool by widget
+    wxToolBarToolBase *FindToolByWidget(WXWidget w) const;
+    
+protected:
+    // common part of all ctors
+    void Init();
+    
+    // implement base class pure virtuals
+    virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
+    virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
+    
+    virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
+    virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
+    virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
+    
+    virtual wxToolBarToolBase *CreateTool(int id,
+        const wxBitmap& bitmap1,
+        const wxBitmap& bitmap2,
+        bool toggle,
+        wxObject *clientData,
+        const wxString& shortHelpString,
+        const wxString& longHelpString);
+    virtual wxToolBarToolBase *CreateTool(wxControl *control);
+    
+private:
+    DECLARE_DYNAMIC_CLASS(wxToolBar)
+};
+
+#endif
+// _WX_TOOLBAR_H_
--- a/include/wx/x11/toplevel.h
+++ b/include/wx/x11/toplevel.h
@@ -0,0 +1,134 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/motif/frame.h
+// Purpose:     wxFrame class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MOTIF_FRAME_H_
+#define _WX_MOTIF_FRAME_H_
+
+#ifdef __GNUG__
+#pragma interface "frame.h"
+#endif
+
+class WXDLLEXPORT wxFrame : public wxFrameBase
+{
+public:
+    wxFrame() { Init(); }
+    wxFrame(wxWindow *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE,
+        const wxString& name = wxFrameNameStr)
+    {
+        Init();
+        
+        Create(parent, id, title, pos, size, style, name);
+    }
+    
+    bool Create(wxWindow *parent,
+        wxWindowID id,
+        const wxString& title,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = wxDEFAULT_FRAME_STYLE,
+        const wxString& name = wxFrameNameStr);
+    
+    virtual ~wxFrame();
+    
+    virtual bool Show(bool show = TRUE);
+    
+    // Set menu bar
+    void SetMenuBar(wxMenuBar *menu_bar);
+    
+    // Set title
+    void SetTitle(const wxString& title);
+    wxString GetTitle() const { return m_title; }
+    
+    // Set icon
+    virtual void SetIcon(const wxIcon& icon);
+    
+#if wxUSE_STATUSBAR
+    virtual void PositionStatusBar();
+#endif // wxUSE_STATUSBAR
+    
+    // Create toolbar
+#if wxUSE_TOOLBAR
+    virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1, const wxString& name = wxToolBarNameStr);
+    virtual void PositionToolBar();
+#endif // wxUSE_TOOLBAR
+    
+    // Iconize
+    virtual void Iconize(bool iconize);
+    
+    virtual bool IsIconized() const;
+    
+    // Is the frame maximized? Returns FALSE under Motif (but TRUE for
+    // wxMDIChildFrame due to the tabbed implementation).
+    virtual bool IsMaximized() const;
+    
+    virtual void Maximize(bool maximize);
+    
+    virtual void Raise();
+    virtual void Lower();
+    
+    virtual void Restore();
+    
+    // Implementation only from now on
+    // -------------------------------
+    
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+    void OnActivate(wxActivateEvent& event);
+    
+    virtual void ChangeFont(bool keepOriginalSize = TRUE);
+    virtual void ChangeBackgroundColour();
+    virtual void ChangeForegroundColour();
+    WXWidget GetMenuBarWidget() const;
+    WXWidget GetShellWidget() const { return m_frameShell; }
+    WXWidget GetWorkAreaWidget() const { return m_workArea; }
+    WXWidget GetClientAreaWidget() const { return m_clientArea; }
+    WXWidget GetTopWidget() const { return m_frameShell; }
+    
+    virtual WXWidget GetMainWidget() const { return m_frameWidget; }
+    
+    // The widget that can have children on it
+    WXWidget GetClientWidget() const;
+    bool GetVisibleStatus() const { return m_visibleStatus; }
+    
+    bool PreResize();
+    
+protected:
+    // common part of all ctors
+    void Init();
+    
+    //// Motif-specific
+    WXWidget              m_frameShell;
+    WXWidget              m_frameWidget;
+    WXWidget              m_workArea;
+    WXWidget              m_clientArea;
+    wxString              m_title;
+    bool                  m_visibleStatus;
+    bool                  m_iconized;
+    
+    virtual void DoGetClientSize(int *width, int *height) const;
+    virtual void DoGetSize(int *width, int *height) const;
+    virtual void DoGetPosition(int *x, int *y) const;
+    virtual void DoSetSize(int x, int y,
+        int width, int height,
+        int sizeFlags = wxSIZE_AUTO);
+    virtual void DoSetClientSize(int width, int height);
+    
+private:
+    DECLARE_EVENT_TABLE()
+        DECLARE_DYNAMIC_CLASS(wxFrame)
+};
+
+#endif
+// _WX_MOTIF_FRAME_H_
--- a/include/wx/x11/window.h
+++ b/include/wx/x11/window.h
@@ -0,0 +1,358 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        window.h
+// Purpose:     wxWindow class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_WINDOW_H_
+#define _WX_WINDOW_H_
+
+#ifdef __GNUG__
+#pragma interface "window.h"
+#endif
+
+#include "wx/region.h"
+
+// ----------------------------------------------------------------------------
+// wxWindow class for Motif - see also wxWindowBase
+// ----------------------------------------------------------------------------
+
+class wxWindow : public wxWindowBase
+{
+    friend class WXDLLEXPORT wxDC;
+    friend class WXDLLEXPORT wxWindowDC;
+    
+public:
+    wxWindow() { Init(); }
+    
+    wxWindow(wxWindow *parent,
+        wxWindowID id,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = 0,
+        const wxString& name = wxPanelNameStr)
+    {
+        Init();
+        Create(parent, id, pos, size, style, name);
+    }
+    
+    virtual ~wxWindow();
+    
+    bool Create(wxWindow *parent,
+        wxWindowID id,
+        const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize,
+        long style = 0,
+        const wxString& name = wxPanelNameStr);
+    
+    // implement base class pure virtuals
+    virtual void SetTitle( const wxString& title);
+    virtual wxString GetTitle() const;
+    
+    virtual void Raise();
+    virtual void Lower();
+    
+    virtual bool Show( bool show = TRUE );
+    virtual bool Enable( bool enable = TRUE );
+    
+    virtual void SetFocus();
+    
+    virtual void WarpPointer(int x, int y);
+    
+    virtual void Refresh( bool eraseBackground = TRUE,
+        const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
+    
+    virtual bool SetBackgroundColour( const wxColour &colour );
+    virtual bool SetForegroundColour( const wxColour &colour );
+    
+    virtual bool SetCursor( const wxCursor &cursor );
+    virtual bool SetFont( const wxFont &font );
+    
+    virtual int GetCharHeight() const;
+    virtual int GetCharWidth() const;
+    virtual void GetTextExtent(const wxString& string,
+        int *x, int *y,
+        int *descent = (int *) NULL,
+        int *externalLeading = (int *) NULL,
+        const wxFont *theFont = (const wxFont *) NULL)
+        const;
+    
+    virtual void SetScrollbar( int orient, int pos, int thumbVisible,
+        int range, bool refresh = TRUE );
+    virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
+    virtual int GetScrollPos( int orient ) const;
+    virtual int GetScrollThumb( int orient ) const;
+    virtual int GetScrollRange( int orient ) const;
+    virtual void ScrollWindow( int dx, int dy,
+        const wxRect* rect = (wxRect *) NULL );
+    
+    virtual void SetSizeHints(int minW, int minH,
+        int maxW = -1, int maxH = -1,
+        int incW = -1, int incH = -1);
+#if wxUSE_DRAG_AND_DROP
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
+#endif // wxUSE_DRAG_AND_DROP
+    
+    // Accept files for dragging
+    virtual void DragAcceptFiles(bool accept);
+    
+    // Get the unique identifier of a window
+    virtual WXWidget GetHandle() const { return GetMainWidget(); }
+    
+    // implementation from now on
+    // --------------------------
+    
+    // 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.)
+    virtual WXWidget GetLabelWidget() const;
+    // Get the client widget for this window (something we can create other
+    // windows on)
+    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.
+    virtual WXWidget GetTopWidget() const;
+    
+    // Get the underlying X window and display
+    WXWindow GetXWindow() const;
+    WXDisplay *GetXDisplay() const;
+    
+    // called from Motif callbacks - and should only be called from there
+    
+    void SetButton1(bool pressed) { m_button1Pressed = pressed; }
+    void SetButton2(bool pressed) { m_button2Pressed = pressed; }
+    void SetButton3(bool pressed) { m_button3Pressed = pressed; }
+    
+    void SetLastClick(int button, long timestamp)
+    { m_lastButton = button; m_lastTS = timestamp; }
+    
+    int GetLastClickedButton() const { return m_lastButton; }
+    long GetLastClickTime() const { return m_lastTS; }
+    
+    // Gives window a chance to do something in response to a size message, e.g.
+    // arrange status bar, toolbar etc.
+    virtual bool PreResize();
+    
+    // Generates a paint event
+    virtual void DoPaint();
+    
+    // update rectangle/region manipulation
+    // (for wxWindowDC and Motif callbacks only)
+    // -----------------------------------------
+    
+    // read/write access to the update rect list
+    const wxRectList& GetUpdateRects() const { return m_updateRects; }
+    
+    // Adds a recangle to the updates list
+    void AddUpdateRect(int x, int y, int w, int h)
+    { m_updateRects.Append(new wxRect(x, y, w, h)); }
+    
+    // Empties the m_updateRects list
+    void ClearUpdateRects();
+    
+    void ClearUpdateRegion() { m_updateRegion.Clear(); }
+    void SetUpdateRegion(const wxRegion& region) { m_updateRegion = region; }
+    
+    // sets the fore/background colour for the given widget
+    static void DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour);
+    static void DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
+    
+    // For implementation purposes - sometimes decorations make the client area
+    // smaller
+    virtual wxPoint GetClientAreaOrigin() const;
+    
+protected:
+    // event handlers (not virtual by design)
+    void OnIdle(wxIdleEvent& event);
+    
+    // Makes an adjustment to the window position (for example, a frame that has
+    // a toolbar that it manages itself).
+    virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
+    
+    wxWindow *GetChild(int number) const
+    { return GetChildren().Item(number)->GetData(); }
+    
+    // Responds to colour changes: passes event on to children.
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+    
+    // Motif-specific
+    
+    // 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 SetMainWidget(WXWidget w) { m_mainWidget = w; }
+    
+    bool CanAddEventHandler() const { return m_canAddEventHandler; }
+    void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }
+    
+public:
+    WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
+    void SetBackingPixmap(WXPixmap pixmap) { m_backingPixmap = pixmap; }
+    int GetPixmapWidth() const { return m_pixmapWidth; }
+    int GetPixmapHeight() const { return m_pixmapHeight; }
+    void SetPixmapWidth(int w) { m_pixmapWidth = w; }
+    void SetPixmapHeight(int h) { m_pixmapHeight = h; }
+    
+    // Change properties
+    virtual void ChangeFont(bool keepOriginalSize = TRUE);             // Change to the current font (often overridden)
+    
+    // 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();
+    
+protected:
+    // 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 DetachWidget(WXWidget widget);
+    
+    // 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,
+    // 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.
+public:
+    virtual bool ProcessAccelerator(wxKeyEvent& event);
+    
+protected:
+    // unmanage and destroy an X widget f it's !NULL (passing NULL is ok)
+    void UnmanageAndDestroy(WXWidget widget);
+    
+    // map or unmap an X widget (passing NULL is ok), returns TRUE if widget was
+    // mapped/unmapped
+    bool MapOrUnmap(WXWidget widget, bool map);
+    
+    // scrolling stuff
+    // ---------------
+    
+    // create/destroy window scrollbars
+    void CreateScrollbar(wxOrientation orientation);
+    void DestroyScrollbar(wxOrientation orientation);
+    
+    // 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;
+    
+    // For double-click detection
+    long   m_lastTS;         // last timestamp
+    int    m_lastButton;     // last pressed button
+    
+    // List of wxRects representing damaged region
+    wxRectList m_updateRects;
+    
+protected:
+    WXWidget              m_mainWidget;
+    WXWidget              m_hScrollBar;
+    WXWidget              m_vScrollBar;
+    WXWidget              m_borderWidget;
+    WXWidget              m_scrolledWindow;
+    WXWidget              m_drawingArea;
+    bool                  m_winCaptured;
+    bool                  m_hScroll;
+    bool                  m_vScroll;
+    WXPixmap              m_backingPixmap;
+    int                   m_pixmapWidth;
+    int                   m_pixmapHeight;
+    int                   m_pixmapOffsetX;
+    int                   m_pixmapOffsetY;
+    
+    // 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 DoSetClientSize(int width, int height);
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+    virtual bool DoPopupMenu(wxMenu *menu, int x, int y);
+    
+    virtual void DoCaptureMouse();
+    virtual void DoReleaseMouse();
+    
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip( wxToolTip *tip );
+#endif // wxUSE_TOOLTIPS
+    
+private:
+    // common part of all ctors
+    void Init();
+    
+    DECLARE_DYNAMIC_CLASS(wxWindow)
+    DECLARE_NO_COPY_CLASS(wxWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+// ----------------------------------------------------------------------------
+// A little class to switch off `size optimization' while an instance of the
+// object exists: this may be useful to temporarily disable the optimisation
+// which consists to do nothing when the new size is equal to the old size -
+// although quite useful usually to avoid flicker, sometimes it leads to
+// undesired effects.
+//
+// Usage: create an instance of this class on the stack to disable the size
+// optimisation, it will be reenabled as soon as the object goes out from scope.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxNoOptimize
+{
+public:
+    wxNoOptimize() { ms_count++; }
+    ~wxNoOptimize() { ms_count--; }
+    
+    static bool CanOptimize() { return ms_count == 0; }
+    
+protected:
+    static int ms_count;
+};
+
+#endif
+// _WX_WINDOW_H_