Stripped out miscellaneous Motif/Xt-specific code

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

diff --git a/include/wx/x11/bitmap.h b/include/wx/x11/bitmap.h
index 23f8bcd9bef656e04dcd118bcc9cbaddc1f8e76f..c5973e088c1cb3ea1fa9ab51a52dc0c115247911 100644 (file)
--- a/include/wx/x11/bitmap.h
+++ b/include/wx/x11/bitmap.h
@@ -89,13 +89,6 @@ public:
     bool              m_freePixmap;
     unsigned long*    m_freeColors;
     long              m_freeColorsCount;
     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)
 };
 
 #define M_BITMAPDATA ((wxBitmapRefData *)m_refData)


@@ -145,9 +138,6 @@ public:
     wxBitmap(const char **data) { (void)CreateFromXpm(data); }
     wxBitmap(char **data) { (void)CreateFromXpm((const char **)data); }
     
     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);
     
     // Load a file or resource
     wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_XPM);
     


@@ -209,9 +199,6 @@ public:
 public:
     WXDisplay* GetDisplay() const { return M_BITMAPDATA->m_display; }
     WXPixmap GetPixmap() const { return (WXPixmap) M_BITMAPDATA->m_pixmap; }
 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:
     void SetPixmapNull() { M_BITMAPDATA->m_pixmap = 0; }
     
 protected:

diff --git a/include/wx/x11/font.h b/include/wx/x11/font.h
index f75bf6c423b566c9b1910f65190c8e2385fa1bfb..faf0d35801b656cdbb116d2d78100529f54f0a32 100644 (file)
--- a/include/wx/x11/font.h
+++ b/include/wx/x11/font.h
@@ -95,11 +95,9 @@ public:
     wxXFont *GetInternalFont(double scale = 1.0,
         WXDisplay* display = NULL) const;
     
     wxXFont *GetInternalFont(double scale = 1.0,
         WXDisplay* display = NULL) const;
     

-    // These two are helper functions for convenient access of the above.
+    // Helper function for convenient access of the above.

     WXFontStructPtr GetFontStruct(double scale = 1.0,
         WXDisplay* display = NULL) const;
     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
     
 protected:
     // common part of all ctors

diff --git a/include/wx/x11/window.h b/include/wx/x11/window.h
index d4cabf0cbcf4330cb28ba5742cd0830701f72fa0..6044fbec32b5add25c4f0bf5688731b3dfa6f5db 100644 (file)
--- a/include/wx/x11/window.h
+++ b/include/wx/x11/window.h
@@ -22,15 +22,15 @@
 // wxWindow class for Motif - see also wxWindowBase
 // ----------------------------------------------------------------------------
 
 // wxWindow class for Motif - see also wxWindowBase
 // ----------------------------------------------------------------------------
 

-class wxWindow : public wxWindowBase
+class wxWindowX11 : public wxWindowBase

 {
     friend class WXDLLEXPORT wxDC;
     friend class WXDLLEXPORT wxWindowDC;
     
 public:
 {
     friend class WXDLLEXPORT wxDC;
     friend class WXDLLEXPORT wxWindowDC;
     
 public:

-    wxWindow() { Init(); }
+    wxWindowX11() { Init(); }

     
     

-    wxWindow(wxWindow *parent,
+    wxWindowX11(wxWindow *parent,

         wxWindowID id,
         const wxPoint& pos = wxDefaultPosition,
         const wxSize& size = wxDefaultSize,
         wxWindowID id,
         const wxPoint& pos = wxDefaultPosition,
         const wxSize& size = wxDefaultSize,


@@ -103,7 +103,7 @@ public:
     virtual void DragAcceptFiles(bool accept);
     
     // Get the unique identifier of a window
     virtual void DragAcceptFiles(bool accept);
     
     // Get the unique identifier of a window

-    virtual WXWidget GetHandle() const { return GetMainWidget(); }
+    virtual WXWindow GetHandle() const { return GetMainWindow(); }

     
     // implementation from now on
     // --------------------------
     
     // implementation from now on
     // --------------------------


@@ -112,16 +112,16 @@ public:
     // ---------
     
     // Get main widget for this window, e.g. a text widget
     // ---------
     
     // Get main widget for this window, e.g. a text widget

-    virtual WXWidget GetMainWidget() const;
+    virtual WXWindow GetMainWindow() const;

     // Get the widget that corresponds to the label (for font setting, label setting etc.)
     // Get the widget that corresponds to the label (for font setting, label setting etc.)

-    virtual WXWidget GetLabelWidget() const;
+    virtual WXWindow GetLabelWindow() const;

     // Get the client widget for this window (something we can create other
     // windows on)
     // Get the client widget for this window (something we can create other
     // windows on)

-    virtual WXWidget GetClientWidget() const;
+    virtual WXWindow GetClientWindow() const;

     // Get the top widget for this window, e.g. the scrolled widget parent of a
     // multi-line text widget. Top means, top in the window hierarchy that
     // implements this window.
     // Get the top widget for this window, e.g. the scrolled widget parent of a
     // multi-line text widget. Top means, top in the window hierarchy that
     // implements this window.

-    virtual WXWidget GetTopWidget() const;
+    virtual WXWindow GetTopWindow() const;

     
     // Get the underlying X window and display
     WXWindow GetXWindow() const;
     
     // Get the underlying X window and display
     WXWindow GetXWindow() const;


@@ -164,8 +164,8 @@ public:
     void SetUpdateRegion(const wxRegion& region) { m_updateRegion = region; }
     
     // sets the fore/background colour for the given widget
     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);
+    static void DoChangeForegroundColour(WXWindow widget, wxColour& foregroundColour);
+    static void DoChangeBackgroundColour(WXWindow widget, wxColour& backgroundColour, bool changeArmColour = FALSE);

     
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     
     // For implementation purposes - sometimes decorations make the client area
     // smaller


@@ -194,7 +194,7 @@ protected:
     void CanvasSetClientSize(int width, int size);
     void CanvasSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
     
     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; }
+    void SetMainWindow(WXWindow w) { m_mainWindow = w; }

     
     bool CanAddEventHandler() const { return m_canAddEventHandler; }
     void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }
     
     bool CanAddEventHandler() const { return m_canAddEventHandler; }
     void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }


@@ -218,9 +218,9 @@ public:
     
 protected:
     // Adds the widget to the hash table and adds event handlers.
     
 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);
+    bool AttachWindow(wxWindow* parent, WXWindow mainWidget,
+        int x, int y, int width, int height);
+    bool DetachWindow(WXWindow 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
     
     // How to implement accelerators. If we find a key event, translate to
     // wxWindows wxKeyEvent form. Find a widget for the window. Now find a


@@ -238,13 +238,6 @@ public:
     virtual bool ProcessAccelerator(wxKeyEvent& event);
     
 protected:
     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
     // ---------------
     
     // scrolling stuff
     // ---------------
     


@@ -253,7 +246,7 @@ protected:
     void DestroyScrollbar(wxOrientation orientation);
     
     // get either hor or vert scrollbar widget
     void DestroyScrollbar(wxOrientation orientation);
     
     // get either hor or vert scrollbar widget

-    WXWidget GetScrollbar(wxOrientation orient) const
+    WXWindow GetScrollbar(wxOrientation orient) const

     { return orient == wxHORIZONTAL ? m_hScrollBar : m_vScrollBar; }
     
     // set the scroll pos
     { return orient == wxHORIZONTAL ? m_hScrollBar : m_vScrollBar; }
     
     // set the scroll pos


@@ -282,12 +275,12 @@ protected:
     wxRectList m_updateRects;
     
 protected:
     wxRectList m_updateRects;
     
 protected:

-    WXWidget              m_mainWidget;
-    WXWidget              m_hScrollBar;
-    WXWidget              m_vScrollBar;
-    WXWidget              m_borderWidget;
-    WXWidget              m_scrolledWindow;
-    WXWidget              m_drawingArea;
+    WXWindow              m_mainWidget;
+    WXWindow              m_hScrollBar;
+    WXWindow              m_vScrollBar;
+    WXWindow              m_borderWidget;
+    WXWindow              m_scrolledWindow;
+    WXWindow              m_drawingArea;

     bool                  m_winCaptured;
     bool                  m_hScroll;
     bool                  m_vScroll;
     bool                  m_winCaptured;
     bool                  m_hScroll;
     bool                  m_vScroll;


@@ -326,8 +319,8 @@ private:
     // common part of all ctors
     void Init();
     
     // common part of all ctors
     void Init();
     

-    DECLARE_DYNAMIC_CLASS(wxWindow)
-    DECLARE_NO_COPY_CLASS(wxWindow)
+    DECLARE_DYNAMIC_CLASS(wxWindowX11)
+    DECLARE_NO_COPY_CLASS(wxWindowX11)

     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_EVENT_TABLE()
 };
 

diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp
index dc6bb3bb82f27278cd23362a1ec684f503ce6310..9e919994abec18f2439509e1e4dce7d1293fe41c 100644 (file)
--- a/src/x11/bitmap.cpp
+++ b/src/x11/bitmap.cpp
@@ -13,10 +13,6 @@
 #pragma implementation "bitmap.h"
 #endif
 
 #pragma implementation "bitmap.h"
 #endif
 

-#ifdef __VMS
-#define XtParent XTPARENT
-#endif
-

 #include "wx/setup.h"
 #include "wx/utils.h"
 #include "wx/palette.h"
 #include "wx/setup.h"
 #include "wx/utils.h"
 #include "wx/palette.h"


@@ -31,12 +27,11 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 #if wxHAVE_LIB_XPM
     #include <X11/xpm.h>
 
 #if wxHAVE_LIB_XPM
     #include <X11/xpm.h>


@@ -63,38 +58,10 @@ wxBitmapRefData::wxBitmapRefData()
     m_freePixmap = TRUE; //TODO: necessary?
     m_freeColors = (unsigned long*) 0;
     m_freeColorsCount = 0;
     m_freePixmap = TRUE; //TODO: necessary?
     m_freeColors = (unsigned long*) 0;
     m_freeColorsCount = 0;

-
-    // These 5 variables are for wxControl
-    m_insensPixmap = (WXPixmap) 0;
-    m_labelPixmap = (WXPixmap) 0;
-    m_armPixmap = (WXPixmap) 0;
-    m_image = (WXImage*) 0;
-    m_insensImage = (WXImage*) 0;

 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {

-    if (m_labelPixmap)
-        XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_labelPixmap);
-
-    if (m_armPixmap)
-        XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_armPixmap);
-
-    if (m_insensPixmap)
-        XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) m_display), (Pixmap) m_insensPixmap);
-
-    if (m_image)
-    {
-        XmUninstallImage ((XImage*) m_image);
-        XtFree ((char *) (XImage*) m_image);
-    }
-
-    if (m_insensImage)
-    {
-        XmUninstallImage ((XImage*) m_insensImage);
-        delete[] ((XImage*) m_insensImage)->data;
-        XtFree ((char *) (XImage*) m_insensImage);
-    }

     if (m_pixmap && m_freePixmap)
         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
 
     if (m_pixmap && m_freePixmap)
         XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
 


@@ -148,23 +115,9 @@ wxBitmap::wxBitmap(const wxString& filename, long type)
     LoadFile(filename, (int)type);
 }
 
     LoadFile(filename, (int)type);
 }
 

-// Create from XPM data
-static wxControl* sg_Control = NULL;
-wxBitmap::wxBitmap(char **data, wxControl* control)
+wxBitmap::wxBitmap(char **data)

 {
 {

-    // Pass the control to the Create function using a global
-    sg_Control = control;
-

     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
     (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

-
-    sg_Control = (wxControl*) NULL;
-}
-
-bool wxBitmap::CreateFromXpm(const char **bits)
-{
-    wxCHECK_MSG( bits, FALSE, _T("NULL pointer in wxBitmap::CreateFromXpm") );
-
-    return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

 }
 
 bool wxBitmap::Create(int w, int h, int d)
 }
 
 bool wxBitmap::Create(int w, int h, int d)


@@ -546,57 +499,6 @@ bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags
     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
 
     M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
     M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
 

-    // code for wxControl. TODO: can we avoid doing this until we need it?
-    // E.g. have CreateButtonPixmaps which is called on demand.
-    XImage* image = (XImage *) XtMalloc (sizeof (XImage));
-    image->width = width;
-    image->height = height;
-    image->data = (char*) data;
-    image->depth = 1;
-    image->xoffset = 0;
-    image->format = XYBitmap;
-    image->byte_order = LSBFirst;
-    image->bitmap_unit = 8;
-    image->bitmap_bit_order = LSBFirst;
-    image->bitmap_pad = 8;
-    image->bytes_per_line = (width + 7) >> 3;
-
-    char tmp[128];
-    sprintf (tmp, "Im%x", (unsigned int) image);
-    XmInstallImage (image, tmp);
-
-    // Build our manually stipped pixmap.
-
-    int bpl = (width + 7) / 8;
-    char *data1 = new char[height * bpl];
-    char* bits = (char*) data;
-    int i;
-    for (i = 0; i < height; i++)
-    {
-        int mask = i % 2 ? 0x55 : 0xaa;
-        int j;
-        for (j = 0; j < bpl; j++)
-            data1[i * bpl + j] = bits[i * bpl + j] & mask;
-    }
-    XImage* insensImage = (XImage *) XtMalloc (sizeof (XImage));
-    insensImage->width = width;
-    insensImage->height = height;
-    insensImage->data = data1;
-    insensImage->depth = 1;
-    insensImage->xoffset = 0;
-    insensImage->format = XYBitmap;
-    insensImage->byte_order = LSBFirst;
-    insensImage->bitmap_unit = 8;
-    insensImage->bitmap_bit_order = LSBFirst;
-    insensImage->bitmap_pad = 8;
-    insensImage->bytes_per_line = bpl;
-
-    sprintf (tmp, "Not%x", (unsigned int)insensImage);
-    XmInstallImage (insensImage, tmp);
-
-    M_BITMAPHANDLERDATA->m_image = (WXImage*) image;
-    M_BITMAPHANDLERDATA->m_insensImage = (WXImage*) insensImage;
-

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -821,122 +723,6 @@ void wxBitmap::InitStandardHandlers()
 #endif // wxHAVE_LIB_XPM
 }
 
 #endif // wxHAVE_LIB_XPM
 }
 

-WXPixmap wxBitmap::GetLabelPixmap (WXWidget w)
-{
-    if (M_BITMAPDATA->m_image == (WXPixmap) 0)
-        return M_BITMAPDATA->m_pixmap;
-
-    Display *dpy = (Display*) M_BITMAPDATA->m_display;
-
-#ifdef FOO
-    /*
-    If we do:
-    if (labelPixmap) return labelPixmap;
-    things can be wrong, because colors can have been changed.
-
-      If we do:
-      if (labelPixmap)
-      XmDestroyPixmap(DefaultScreenOfDisplay(dpy),labelPixmap) ;
-      we got BadDrawable if the pixmap is referenced by multiples widgets
-
-        this is a catch22!!
-
-      So, before doing thing really clean, I just do nothing; if the pixmap is
-      referenced by many widgets, Motif performs caching functions.
-      And if pixmap is referenced with multiples colors, we just have some
-      memory leaks... I hope we can deal with them...
-    */
-    // Must be destroyed, because colours can have been changed!
-    if (M_BITMAPDATA->m_labelPixmap)
-        XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_labelPixmap);
-#endif
-
-    char tmp[128];
-    sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
-
-    Pixel fg, bg;
-    Widget widget = (Widget) w;
-
-    while (XmIsGadget ( widget ))
-        widget = XtParent (widget);
-    XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
-
-    M_BITMAPDATA->m_labelPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
-
-    return M_BITMAPDATA->m_labelPixmap;
-}
-
-WXPixmap wxBitmap::GetArmPixmap (WXWidget w)
-{
-    if (M_BITMAPDATA->m_image == (WXPixmap) 0)
-        return M_BITMAPDATA->m_pixmap;
-
-    Display *dpy = (Display*) M_BITMAPDATA->m_display;
-#ifdef FOO
-    // See GetLabelPixmap () comment
-
-    // Must be destroyed, because colours can have been changed!
-    if (M_BITMAPDATA->m_armPixmap)
-        XmDestroyPixmap (DefaultScreenOfDisplay (dpy), M_BITMAPDATA->m_armPixmap);
-#endif
-
-    char tmp[128];
-    sprintf (tmp, "Im%x", (unsigned int) M_BITMAPDATA->m_image);
-
-    Pixel fg, bg;
-    Widget widget = (Widget) w;
-
-    XtVaGetValues (widget, XmNarmColor, &bg, NULL);
-    while (XmIsGadget (widget))
-        widget = XtParent (widget);
-    XtVaGetValues (widget, XmNforeground, &fg, NULL);
-
-    M_BITMAPDATA->m_armPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
-
-    return M_BITMAPDATA->m_armPixmap;
-}
-
-WXPixmap wxBitmap::GetInsensPixmap (WXWidget w)
-{
-    Display *dpy = (Display*) M_BITMAPDATA->m_display;
-
-    if (M_BITMAPDATA->m_insensPixmap)
-        return M_BITMAPDATA->m_insensPixmap;
-
-    if (!w)
-    {
-        M_BITMAPDATA->m_insensPixmap = (WXPixmap) XCreateInsensitivePixmap(dpy, (Pixmap) M_BITMAPDATA->m_pixmap);
-        if (M_BITMAPDATA->m_insensPixmap)
-            return M_BITMAPDATA->m_insensPixmap;
-        else
-            return M_BITMAPDATA->m_pixmap;
-    }
-
-    if (M_BITMAPDATA->m_insensImage == (WXPixmap) 0)
-        return M_BITMAPDATA->m_pixmap;
-
-#ifdef FOO
-    See GetLabelPixmap () comment
-        // Must be destroyed, because colours can have been changed!
-        if (M_BITMAPDATA->m_insensPixmap)
-            XmDestroyPixmap (DefaultScreenOfDisplay (dpy), (Pixmap) M_BITMAPDATA->m_insensPixmap);
-#endif
-
-    char tmp[128];
-    sprintf (tmp, "Not%x", (unsigned int) M_BITMAPDATA->m_insensImage);
-
-    Pixel fg, bg;
-    Widget widget = (Widget) w;
-
-    while (XmIsGadget (widget))
-        widget = XtParent (widget);
-    XtVaGetValues (widget, XmNbackground, &bg, XmNforeground, &fg, NULL);
-
-    M_BITMAPDATA->m_insensPixmap = (WXPixmap) XmGetPixmap (DefaultScreenOfDisplay (dpy), tmp, fg, bg);
-
-    return M_BITMAPDATA->m_insensPixmap;
-}
-

 // We may need this sometime...
 
 /****************************************************************************
 // We may need this sometime...
 
 /****************************************************************************

diff --git a/src/x11/cursor.cpp b/src/x11/cursor.cpp
index 24ce2516a07ba91ac5d28449f00b28a113dde5a5..cb0e61f34f3d7d8a6957343f8d86a9b5e4682f1b 100644 (file)
--- a/src/x11/cursor.cpp
+++ b/src/x11/cursor.cpp
@@ -22,13 +22,12 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>

 #include <X11/cursorfont.h>
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #include <X11/cursorfont.h>
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
 IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
 
 IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
 IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)

diff --git a/src/x11/dataobj.cpp b/src/x11/dataobj.cpp
index 90e41f267ac3faa19e34465a8dc35fa04040874a..f9120e6be4c3a590466070f603a3e4fad8320532 100644 (file)
--- a/src/x11/dataobj.cpp
+++ b/src/x11/dataobj.cpp
@@ -21,7 +21,6 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif

diff --git a/src/x11/dc.cpp b/src/x11/dc.cpp
index cc5c5359a40be7d4cef5683d2b29c5bc72abf11f..c66c5f4797e8e32c624b8569937e19f7f2793e94 100644 (file)
--- a/src/x11/dc.cpp
+++ b/src/x11/dc.cpp
@@ -17,7 +17,7 @@
 #include "wx/dcmemory.h"
 #include "wx/defs.h"
 
 #include "wx/dcmemory.h"
 #include "wx/defs.h"
 

-    IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)

 
 //-----------------------------------------------------------------------------
 // constants
 
 //-----------------------------------------------------------------------------
 // constants

diff --git a/src/x11/dcclient.cpp b/src/x11/dcclient.cpp
index f442f9ebcac12b0f00c4c76cb710c18589204d61..2bedcdb5b55336491b0c433ce64fee5f6c9685ae 100644 (file)
--- a/src/x11/dcclient.cpp
+++ b/src/x11/dcclient.cpp
@@ -51,12 +51,11 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 #ifdef __EMX__
     #include <float.h>          // for M_PI
 
 #ifdef __EMX__
     #include <float.h>          // for M_PI

diff --git a/src/x11/dcmemory.cpp b/src/x11/dcmemory.cpp
index 8694f0b6eccd70854984e0fecd501adf0f9e4702..613ec59d8dfd418a38da3d370e2c6b9dc95da223 100644 (file)
--- a/src/x11/dcmemory.cpp
+++ b/src/x11/dcmemory.cpp
@@ -20,7 +20,6 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif

diff --git a/src/x11/dcscreen.cpp b/src/x11/dcscreen.cpp
index 1da45d5e3935713455f9ae29d709db7bdba5f624..3be136b3c582087bc3cd7c56e01df1b3ef45854c 100644 (file)
--- a/src/x11/dcscreen.cpp
+++ b/src/x11/dcscreen.cpp
@@ -21,12 +21,12 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
 

diff --git a/src/x11/font.cpp b/src/x11/font.cpp
index 0af197f78da852a5a5de65f5c2c61bb6e7eaf016..115f1849abfbf54919cc845b00c02ce0809e7b27 100644 (file)
--- a/src/x11/font.cpp
+++ b/src/x11/font.cpp
@@ -25,7 +25,7 @@
 #pragma message disable nosimpint
 #include "wx/vms_x_fix.h"
 #endif
 #pragma message disable nosimpint
 #include "wx/vms_x_fix.h"
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS
 #pragma message enable nosimpint
 #endif
 #ifdef __VMS
 #pragma message enable nosimpint
 #endif


@@ -54,7 +54,6 @@ public:
     ~wxXFont();
 
     WXFontStructPtr     m_fontStruct;   // XFontStruct
     ~wxXFont();
 
     WXFontStructPtr     m_fontStruct;   // XFontStruct

-    WXFontList          m_fontList;     // Motif XmFontList

     WXDisplay*          m_display;      // XDisplay
     int                 m_scale;        // Scale * 100
 };
     WXDisplay*          m_display;      // XDisplay
     int                 m_scale;        // Scale * 100
 };


@@ -119,17 +118,12 @@ protected:
 wxXFont::wxXFont()
 {
     m_fontStruct = (WXFontStructPtr) 0;
 wxXFont::wxXFont()
 {
     m_fontStruct = (WXFontStructPtr) 0;

-    m_fontList = (WXFontList) 0;

     m_display = (WXDisplay*) 0;
     m_scale = 100;
 }
 
 wxXFont::~wxXFont()
 {
     m_display = (WXDisplay*) 0;
     m_scale = 100;
 }
 
 wxXFont::~wxXFont()
 {

-    XmFontList fontList = (XmFontList) m_fontList;
-
-    XmFontListFree (fontList);
-

     // TODO: why does freeing the font produce a segv???
     // Note that XFreeFont wasn't called in wxWin 1.68 either.
     // XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
     // TODO: why does freeing the font produce a segv???
     // Note that XFreeFont wasn't called in wxWin 1.68 either.
     // XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;


@@ -529,7 +523,6 @@ wxXFont* wxFont::GetInternalFont(double scale, WXDisplay* display) const
     f->m_fontStruct = (WXFontStructPtr)font;
     f->m_display = ( display ? display : wxGetDisplay() );
     f->m_scale = intScale;
     f->m_fontStruct = (WXFontStructPtr)font;
     f->m_display = ( display ? display : wxGetDisplay() );
     f->m_scale = intScale;

-    f->m_fontList = XmFontListCreate ((XFontStruct*) font, XmSTRING_DEFAULT_CHARSET);

     M_FONTDATA->m_fonts.Append(f);
 
     return f;
     M_FONTDATA->m_fonts.Append(f);
 
     return f;


@@ -542,10 +535,3 @@ WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
     return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
 }
 
     return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
 }
 

-WXFontList wxFont::GetFontList(double scale, WXDisplay* display) const
-{
-    wxXFont* f = GetInternalFont(scale, display);
-
-    return (f ? f->m_fontList : (WXFontList) 0);
-}
-

diff --git a/src/x11/gsockx11.c b/src/x11/gsockx11.c
index 1297cecdee1d7517042c0227e99b3842224f9259..b6199391e63897abf5df472f477155ac2a8cade0 100644 (file)
--- a/src/x11/gsockx11.c
+++ b/src/x11/gsockx11.c
@@ -1,7 +1,7 @@
 /* -------------------------------------------------------------------------
  * Project: GSocket (Generic Socket) for WX
  * Name:    gsockmot.c
 /* -------------------------------------------------------------------------
  * Project: GSocket (Generic Socket) for WX
  * Name:    gsockmot.c

- * Purpose: GSocket: Motif part
+ * Purpose: GSocket: X11 part

  * CVSID:   $Id$
  * ------------------------------------------------------------------------- */
 
  * CVSID:   $Id$
  * ------------------------------------------------------------------------- */
 


@@ -10,10 +10,13 @@
 #if wxUSE_SOCKETS
 
 #include <stdlib.h>
 #if wxUSE_SOCKETS
 
 #include <stdlib.h>

-#include <X11/Intrinsic.h>
+// #include <X11/Intrinsic.h>

 #include "wx/gsocket.h"
 #include "wx/unix/gsockunx.h"
 
 #include "wx/gsocket.h"
 #include "wx/unix/gsockunx.h"
 

+// TODO: Raw X11 version
+#if 0
+

 extern XtAppContext wxGetAppContext();
 
 static void _GSocket_Motif_Input(XtPointer data, int *fid,
 extern XtAppContext wxGetAppContext();
 
 static void _GSocket_Motif_Input(XtPointer data, int *fid,


@@ -123,4 +126,7 @@ void _GSocket_Disable_Events(GSocket *socket)
 /* some compilers don't like having empty source files */
 static int wxDummyGsockVar = 0;
 
 /* some compilers don't like having empty source files */
 static int wxDummyGsockVar = 0;
 

+#endif
+ // 0
+

 #endif /* wxUSE_SOCKETS/!wxUSE_SOCKETS */
 #endif /* wxUSE_SOCKETS/!wxUSE_SOCKETS */

diff --git a/src/x11/icon.cpp b/src/x11/icon.cpp
index 96905576b3364d0a4eb414ec09ed18a10af92c23..5acb3abee32ebec8b318a79cd12f60a3d7006c6f 100644 (file)
--- a/src/x11/icon.cpp
+++ b/src/x11/icon.cpp
@@ -19,13 +19,12 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
-#include <X11/cursorfont.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
 

diff --git a/src/x11/joystick.cpp b/src/x11/joystick.cpp
index b9b6fae1d03d145225ad2855f4b50444123f3652..9b7a84dfbca328543765b38b8d5a28ad487b9dea 100644 (file)
--- a/src/x11/joystick.cpp
+++ b/src/x11/joystick.cpp
@@ -13,7 +13,7 @@
 #pragma implementation "joystick.h"
 #endif
 
 #pragma implementation "joystick.h"
 #endif
 

-// Not implemented in wxMotif
+// Not implemented in X11

 #if 0
 
 #include "wx/joystick.h"
 #if 0
 
 #include "wx/joystick.h"

diff --git a/src/x11/palette.cpp b/src/x11/palette.cpp
index ef2b2597a6dacf5ddfee089eef663a775cd16a6d..36bd8cfafc5b13decd841e13a171cceefb570a18 100644 (file)
--- a/src/x11/palette.cpp
+++ b/src/x11/palette.cpp
@@ -46,7 +46,7 @@ not the functionality that wxPalette::Create() aims to provide.
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif

diff --git a/src/x11/region.cpp b/src/x11/region.cpp
index fb3b1e3db2551e6b427f0bdc01a79689adca70bf..6ab42feeb054e49d19cf5eea6ff3e105a1acf22c 100644 (file)
--- a/src/x11/region.cpp
+++ b/src/x11/region.cpp
@@ -18,11 +18,11 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif

-// #include "wx/motif/private.h"
+// #include "wx/x11/private.h"

 
     IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
     IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
 
     IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
     IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)

diff --git a/src/x11/timer.cpp b/src/x11/timer.cpp
index 570e4186f97f8fb843a5d017fcb387ee099631e6..d178cad4f4785d8eac0fa42ae037e612016a885a 100644 (file)
--- a/src/x11/timer.cpp
+++ b/src/x11/timer.cpp
@@ -20,12 +20,12 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
 

diff --git a/src/x11/toolbar.cpp b/src/x11/toolbar.cpp
index a7faa4d42aff45e8224bddc42b4744c2bd0f72ef..8deee8590519d9c109e6721905c256c20e2a1c58 100644 (file)
--- a/src/x11/toolbar.cpp
+++ b/src/x11/toolbar.cpp
@@ -33,26 +33,23 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
-#include <Xm/PushBG.h>
-#include <Xm/PushB.h>
-#include <Xm/Label.h>
-#include <Xm/ToggleB.h>
-#include <Xm/ToggleBG.h>
-#include <Xm/Form.h>

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 

-#include "wx/motif/private.h"
+
+
+#include "wx/x11/private.h"

 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARY

 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

-#endif
+
+// TODO: a decent generic toolbar implementation that
+// we can put in src/generic
+#if 0

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -664,3 +661,4 @@ void wxToolBarTimer::Notify()
         XtPopup (help_popup, XtGrabNone);
 }
 
         XtPopup (help_popup, XtGrabNone);
 }
 

+#endif

diff --git a/src/x11/utils.cpp b/src/x11/utils.cpp
index 9f6ed67e35324661f01c31c2ea15611c891a352c..66f7f60686424d12c4f5d063f6a303b0f4283ffa 100644 (file)
--- a/src/x11/utils.cpp
+++ b/src/x11/utils.cpp
@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-

 #include "wx/setup.h"
 #include "wx/utils.h"
 #include "wx/app.h"
 #include "wx/setup.h"
 #include "wx/utils.h"
 #include "wx/app.h"


@@ -48,14 +44,14 @@
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif

-#include <Xm/Xm.h>
+

 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #include "wx/unix/execute.h"
 
 #ifdef __VMS__
 #pragma message enable nosimpint
 #endif
 
 #include "wx/unix/execute.h"
 

-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -101,6 +97,9 @@ void wxFlushEvents()
 // in long calculations.
 bool wxCheckForInterrupt(wxWindow *wnd)
 {
 // in long calculations.
 bool wxCheckForInterrupt(wxWindow *wnd)
 {

+    wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
+    return FALSE;
+#if 0

     wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
 
     Display *dpy=(Display*) wnd->GetXDisplay();
     wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
 
     Display *dpy=(Display*) wnd->GetXDisplay();


@@ -127,12 +126,13 @@ bool wxCheckForInterrupt(wxWindow *wnd)
     }
 
     return hadEvents;
     }
 
     return hadEvents;

+#endif

 }
 
 // ----------------------------------------------------------------------------
 // wxExecute stuff
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
 // wxExecute stuff
 // ----------------------------------------------------------------------------

-
+#if 0

 static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
                                   XtInputId *id)
 {
 static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
                                   XtInputId *id)
 {


@@ -156,6 +156,7 @@ int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
 
     return (int)id;
 }
 
     return (int)id;
 }

+#endif

 
 // ----------------------------------------------------------------------------
 // misc
 
 // ----------------------------------------------------------------------------
 // misc


@@ -170,6 +171,7 @@ void wxBell()
 
 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 {
 
 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 {

+#if 0

     // FIXME TODO
     // This code is WRONG!! Does NOT return the
     // Motif version of the libs but the X protocol
     // FIXME TODO
     // This code is WRONG!! Does NOT return the
     // Motif version of the libs but the X protocol


@@ -181,6 +183,13 @@ int wxGetOsVersion(int *majorVsn, int *minorVsn)
         *minorVsn = ProtocolRevision (display);
 
     return wxMOTIF_X;
         *minorVsn = ProtocolRevision (display);
 
     return wxMOTIF_X;

+#else
+    if (majorVsn)
+        *majorVsn = 0;
+    if (minorVsn)
+        *minorVsn = 0;
+    return wxX11;
+#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -670,7 +679,7 @@ void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 }
 
 
 }
 
 

-// Configurable display in Motif
+// Configurable display in X11

 static WXDisplay *gs_currentDisplay = NULL;
 static wxString gs_displayName;
 
 static WXDisplay *gs_currentDisplay = NULL;
 static wxString gs_displayName;
 


@@ -678,9 +687,6 @@ WXDisplay *wxGetDisplay()
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;

-
-    if (wxTheApp && wxTheApp->GetTopLevelWidget())
-        return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());

     else if (wxTheApp)
         return wxTheApp->GetInitialDisplay();
     else
     else if (wxTheApp)
         return wxTheApp->GetInitialDisplay();
     else


@@ -691,7 +697,7 @@ bool wxSetDisplay(const wxString& display_name)
 {
     gs_displayName = display_name;
 
 {
     gs_displayName = display_name;
 

-    if ( !display_name )
+    if ( display_name.IsEmpty() )

     {
         gs_currentDisplay = NULL;
 
     {
         gs_currentDisplay = NULL;
 


@@ -701,17 +707,7 @@ bool wxSetDisplay(const wxString& display_name)
     {
         Cardinal argc = 0;
 
     {
         Cardinal argc = 0;
 

-        Display *display = XtOpenDisplay((XtAppContext) wxTheApp->GetAppContext(),
-            (const char*) display_name,
-            (const char*) wxTheApp->GetAppName(),
-            (const char*) wxTheApp->GetClassName(),
-            NULL,
-#if XtSpecificationRelease < 5
-            0, &argc,
-#else
-            0, (int *)&argc,
-#endif
-            NULL);
+        Display* display = XOpenDisplay((const char*) display_name);

 
         if (display)
         {
 
         if (display)
         {


@@ -1191,43 +1187,3 @@ void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
     }
 }
 
     }
 }
 

-
-// These functions duplicate those in wxWindow, but are needed
-// for use outside of wxWindow (e.g. wxMenu, wxMenuBar).
-
-// Change a widget's foreground and background colours.
-
-void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
-{
-    // When should we specify the foreground, if it's calculated
-    // by wxComputeColours?
-    // Solution: say we start with the default (computed) foreground colour.
-    // If we call SetForegroundColour explicitly for a control or window,
-    // then the foreground is changed.
-    // Therefore SetBackgroundColour computes the foreground colour, and
-    // SetForegroundColour changes the foreground colour. The ordering is
-    // important.
-
-    XtVaSetValues ((Widget) widget,
-        XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
-        NULL);
-}
-
-void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
-{
-    wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
-        (wxColour*) NULL);
-
-    XtVaSetValues ((Widget) widget,
-        XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
-        XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
-        XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
-        XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
-        NULL);
-
-    if (changeArmColour)
-        XtVaSetValues ((Widget) widget,
-        XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
-        NULL);
-}
-

diff --git a/src/x11/window.cpp b/src/x11/window.cpp
index 4af73494aae060fc8be401a871b6b8a5b5c32d6a..54f29ea892b20541b56ebb2a2abaf31072915434 100644 (file)
--- a/src/x11/window.cpp
+++ b/src/x11/window.cpp
@@ -21,12 +21,6 @@
     #pragma implementation "window.h"
 #endif
 
     #pragma implementation "window.h"
 #endif
 

-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#define XtWindow XTWINDOW
-#define XtScreen XTSCREEN
-#endif
-

 #include "wx/setup.h"
 #include "wx/menu.h"
 #include "wx/dc.h"
 #include "wx/setup.h"
 #include "wx/menu.h"
 #include "wx/dc.h"


@@ -50,22 +44,7 @@
     #include "wx/dnd.h"
 #endif
 
     #include "wx/dnd.h"
 #endif
 

-#ifdef __VMS__
-#pragma message disable nosimpint
-#endif
-#include <Xm/Xm.h>
-
-#include <Xm/DrawingA.h>
-#include <Xm/ScrolledW.h>
-#include <Xm/ScrollBar.h>
-#include <Xm/Frame.h>
-#include <Xm/Label.h>
-#include <Xm/RowColumn.h>           // for XmMenuPosition
-#ifdef __VMS__
-#pragma message enable nosimpint
-#endif
-
-#include "wx/motif/private.h"
+#include "wx/x11/private.h"

 
 #include <string.h>
 
 
 #include <string.h>
 


@@ -98,24 +77,6 @@ static void wxPanelItemEventHandler(Widget    wid,
                                     XEvent*   event,
                                     Boolean  *continueToDispatch);
 
                                     XEvent*   event,
                                     Boolean  *continueToDispatch);
 

-// unused for now
-#if 0
-
-// Helper function for 16-bit fonts
-static int str16len(const char *s)
-{
-    int count = 0;
-
-    while (s[0] && s[1]) {
-        count++;
-        s += 2;
-    }
-
-    return count;
-}
-
-#endif // 0
-

 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------


@@ -128,12 +89,12 @@ static int str16len(const char *s)
 // event tables
 // ----------------------------------------------------------------------------
 
 // event tables
 // ----------------------------------------------------------------------------
 

-    IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+IMPLEMENT_DYNAMIC_CLASS(wxWindowX11, wxWindowBase)

 
 

-    BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
-        EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-        EVT_IDLE(wxWindow::OnIdle)
-    END_EVENT_TABLE()
+BEGIN_EVENT_TABLE(wxWindowX11, wxWindowBase)
+    EVT_SYS_COLOUR_CHANGED(wxWindowX11::OnSysColourChanged)
+    EVT_IDLE(wxWindowX11::OnIdle)
+END_EVENT_TABLE()

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -143,35 +104,11 @@ static int str16len(const char *s)
 // helper functions
 // ----------------------------------------------------------------------------
 
 // helper functions
 // ----------------------------------------------------------------------------
 

-void wxWindow::UnmanageAndDestroy(WXWidget widget)
-{
-    Widget w = (Widget)widget;
-    if ( w )
-    {
-        XtUnmanageChild(w);
-        XtDestroyWidget(w);
-    }
-}
-
-bool wxWindow::MapOrUnmap(WXWidget widget, bool map)
-{
-    Widget w = (Widget)widget;
-    if ( !w )
-        return FALSE;
-
-    if ( map )
-        XtMapWidget(w);
-    else
-        XtUnmapWidget(w);
-
-    return TRUE;
-}
-

 // ----------------------------------------------------------------------------
 // constructors
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // constructors
 // ----------------------------------------------------------------------------
 

-void wxWindow::Init()
+void wxWindowX11::Init()

 {
     // generic initializations first
     InitBase();
 {
     // generic initializations first
     InitBase();


@@ -214,7 +151,7 @@ void wxWindow::Init()
 }
 
 // real construction (Init() must have been called before!)
 }
 
 // real construction (Init() must have been called before!)

-bool wxWindow::Create(wxWindow *parent, wxWindowID id,
+bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,

                       const wxPoint& pos,
                       const wxSize& size,
                       long style,
                       const wxPoint& pos,
                       const wxSize& size,
                       long style,


@@ -229,149 +166,20 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
     m_foregroundColour = *wxBLACK;
 
     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
     m_foregroundColour = *wxBLACK;
 

-    //// TODO: we should probably optimize by only creating a
-    //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
-    //// But for now, let's simplify things by always creating the
-    //// drawing area, since otherwise the translations are different.
-
-    // New translations for getting mouse motion feedback
-    static const String translations =
-"<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
-<Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
-<Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
-<BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
-<Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
-<Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
-<Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
-<Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
-<Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
-<Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
-<Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
-<EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
-<LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
-<Key>: DrawingAreaInput()";
-
-    XtActionsRec actions[1];
-    actions[0].string = "wxCanvasMotionEvent";
-    actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
-    XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
-
-    Widget parentWidget = (Widget) parent->GetClientWidget();
-    

     if (style & wxSIMPLE_BORDER)
     {
     if (style & wxSIMPLE_BORDER)
     {

-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_IN,
-                                    XmNshadowThickness, 1,
-                                    NULL
-                                   );

     } else if (style & wxSUNKEN_BORDER)
     {
     } else if (style & wxSUNKEN_BORDER)
     {

-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_IN,
-                                    NULL
-                                   );

     } else if (style & wxRAISED_BORDER)
     {
     } else if (style & wxRAISED_BORDER)
     {

-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_OUT,
-                                    NULL
-                                   );

     }
 
     }
 

-    m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
-                                 (
-                                  "scrolledWindow",
-                                  xmScrolledWindowWidgetClass,
-                                  m_borderWidget ? (Widget) m_borderWidget
-                                                 : parentWidget,
-                                  XmNresizePolicy, XmRESIZE_NONE,
-                                  XmNspacing, 0,
-                                  XmNscrollingPolicy, XmAPPLICATION_DEFINED,
-                                  //XmNscrollBarDisplayPolicy, XmAS_NEEDED,
-                                  NULL
-                                 );
-
-    XtTranslations ptr = XtParseTranslationTable(translations);
-    m_drawingArea = (WXWidget)XtVaCreateWidget
-                              (
-                               name,
-                               xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
-                               XmNunitType, XmPIXELS,
-                               // XmNresizePolicy, XmRESIZE_ANY,
-                               XmNresizePolicy, XmRESIZE_NONE,
-                               XmNmarginHeight, 0,
-                               XmNmarginWidth, 0,
-                               XmNtranslations, ptr,
-                               NULL
-                              );
-    XtFree((char *) ptr);
-
-#if 0
-    if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
-    {
-        ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
-        XtOverrideTranslations ((Widget) m_drawingArea, ptr);
-        XtFree ((char *) ptr);
-    }
-#endif // 0
-
-    wxAddWindowToTable((Widget) m_drawingArea, this);
-    wxAddWindowToTable((Widget) m_scrolledWindow, this);
-
-    // This order is very important in Motif 1.2.1
-    XtRealizeWidget ((Widget) m_scrolledWindow);
-    XtRealizeWidget ((Widget) m_drawingArea);
-    XtManageChild ((Widget) m_drawingArea);
-
-    ptr = XtParseTranslationTable("<Configure>: resize()");
-    XtOverrideTranslations((Widget) m_drawingArea, ptr);
-    XtFree ((char *) ptr);
-
-    XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
-    XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
-
-    // TODO?
-#if 0
-    display = XtDisplay (scrolledWindow);
-    xwindow = XtWindow (drawingArea);
-#endif // 0
-
-    XtAddEventHandler(
-                      (Widget)m_drawingArea,
-                       PointerMotionHintMask | EnterWindowMask |
-                       LeaveWindowMask | FocusChangeMask,
-                       False,
-                       (XtEventHandler) wxCanvasEnterLeave,
-                       (XtPointer) this
-                     );
-
-    // Scrolled widget needs to have its colour changed or we get a little blue
-    // square where the scrollbars abutt
-    wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-    DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
-    DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
-
-    XmScrolledWindowSetAreas(
-                             (Widget)m_scrolledWindow,
-                             (Widget) 0, (Widget) 0,
-                             (Widget) m_drawingArea);
+    // TODO: create XWindow

 
 #if 0
 
 #if 0

-    if (m_hScrollBar)
-        XtRealizeWidget ((Widget) m_hScrollBar);
-    if (m_vScrollBar)
-        XtRealizeWidget ((Widget) m_vScrollBar);
-#endif // 0
+    wxAddWindowToTable((Window) m_drawingArea, this);
+    wxAddWindowToTable((Window) m_scrolledWindow, this);
+#endif

 
     // Without this, the cursor may not be restored properly (e.g. in splitter
     // sample).
 
     // Without this, the cursor may not be restored properly (e.g. in splitter
     // sample).


@@ -383,7 +191,7 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 }
 
 // Destructor
 }
 
 // Destructor

-wxWindow::~wxWindow()
+wxWindowX11::~wxWindow()

 {
     if (g_captureWindow == this)
        g_captureWindow = NULL;
 {
     if (g_captureWindow == this)
        g_captureWindow = NULL;


@@ -391,11 +199,11 @@ wxWindow::~wxWindow()
     m_isBeingDeleted = TRUE;
     
     // Motif-specific actions first
     m_isBeingDeleted = TRUE;
     
     // Motif-specific actions first

-    WXWidget wMain = GetMainWidget();
+    WXWindow wMain = GetMainWindow();

     if ( wMain )
     {
         // Removes event handlers
     if ( wMain )
     {
         // Removes event handlers

-        DetachWidget(wMain);
+        //DetachWidget(wMain);

     }
 
     ClearUpdateRects();
     }
 
     ClearUpdateRects();


@@ -403,6 +211,9 @@ wxWindow::~wxWindow()
     if ( m_parent )
         m_parent->RemoveChild( this );
 
     if ( m_parent )
         m_parent->RemoveChild( this );
 

+    // TODO
+
+#if 0    

     // If m_drawingArea, we're a fully-fledged window with drawing area,
     // scrollbars etc. (what wxCanvas used to be)
     if ( m_drawingArea )
     // If m_drawingArea, we're a fully-fledged window with drawing area,
     // scrollbars etc. (what wxCanvas used to be)
     if ( m_drawingArea )


@@ -453,25 +264,16 @@ wxWindow::~wxWindow()
         }
     }
     else // Why wasn't this here before? JACS 8/3/2000
         }
     }
     else // Why wasn't this here before? JACS 8/3/2000

+#endif

         DestroyChildren();
 
 
     // Destroy the window
         DestroyChildren();
 
 
     // Destroy the window

-    if (GetMainWidget())
-    {
-        // If this line (XtDestroyWidget) causes a crash, you may comment it out.
-        // Child widgets will get destroyed automatically when a frame
-        // or dialog is destroyed, but before that you may get some memory
-        // leaks and potential layout problems if you delete and then add
-        // child windows.
-
-        // GRG, Feb/2000: commented this out when adding support for
-        //   wxSCROLL[WIN]_THUMBRELEASE events. Also it was reported
-        //   that this call crashed wxMotif under OS/2, so it seems
-        //   that leaving it out is the right thing to do.
-        // SN, Feb/2000: newgrid/griddemo shows why it is needed :-(
-        XtDestroyWidget((Widget) GetMainWidget());
-        SetMainWidget((WXWidget) NULL);
+    if (GetMainWindow())
+    {
+        // TODO
+        // XtDestroyWidget((Widget) GetMainWidget());
+        SetMainWindow((WXWindow) NULL);

     }
 }
 
     }
 }
 


@@ -480,8 +282,10 @@ wxWindow::~wxWindow()
 // ----------------------------------------------------------------------------
 
 // Helper function
 // ----------------------------------------------------------------------------
 
 // Helper function

-void wxWindow::CreateScrollbar(wxOrientation orientation)
+void wxWindowX11::CreateScrollbar(wxOrientation orientation)

 {
 {

+    // TODO
+#if 0

     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);


@@ -559,10 +363,13 @@ void wxWindow::CreateScrollbar(wxOrientation orientation)
     }
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
     }
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);

+#endif

 }
 
 }
 

-void wxWindow::DestroyScrollbar(wxOrientation orientation)
+void wxWindowX11::DestroyScrollbar(wxOrientation orientation)

 {
 {

+    // TODO
+#if 0

     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);


@@ -599,22 +406,30 @@ void wxWindow::DestroyScrollbar(wxOrientation orientation)
 
     }
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
 
     }
     XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);

+#endif

 }
 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 

-void wxWindow::SetFocus()
+void wxWindowX11::SetFocus()

 {
 {

+    // TODO
+#if 0

     Widget wMain = (Widget) GetMainWidget();
     XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
     XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
     Widget wMain = (Widget) GetMainWidget();
     XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
     XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);

+#endif

 }
 
 // Get the window with the focus
 wxWindow *wxWindowBase::FindFocus()
 {
 }
 
 // Get the window with the focus
 wxWindow *wxWindowBase::FindFocus()
 {

+    // TODO
+    return NULL;
+#if 0
+

     // TODO Problems:
     // (1) Can there be multiple focussed widgets in an application?
     // In which case we need to find the top-level window that's
     // TODO Problems:
     // (1) Can there be multiple focussed widgets in an application?
     // In which case we need to find the top-level window that's


@@ -639,107 +454,109 @@ wxWindow *wxWindowBase::FindFocus()
     }
 
     return winFocus;
     }
 
     return winFocus;

+#endif

 }
 
 }
 

-bool wxWindow::Enable(bool enable)
+bool wxWindowX11::Enable(bool enable)

 {
     if ( !wxWindowBase::Enable(enable) )
         return FALSE;
 
 {
     if ( !wxWindowBase::Enable(enable) )
         return FALSE;
 

+    // TODO
+#if 0

     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
     {
         XtSetSensitive(wMain, enable);
         XmUpdateDisplay(wMain);
     }
     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
     {
         XtSetSensitive(wMain, enable);
         XmUpdateDisplay(wMain);
     }

+#endif

 
     return TRUE;
 }
 
 
     return TRUE;
 }
 

-bool wxWindow::Show(bool show)
+bool wxWindowX11::Show(bool show)

 {
     if ( !wxWindowBase::Show(show) )
         return FALSE;
 
 {
     if ( !wxWindowBase::Show(show) )
         return FALSE;
 

-    if (m_borderWidget || m_scrolledWindow)
-    {
-        MapOrUnmap(m_drawingArea, show);
-        MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
-    }
-    else
-    {
-        if ( !MapOrUnmap(GetTopWidget(), show) )
-            MapOrUnmap(GetMainWidget(), show);
-    }
-
-#if 0

     Window xwin = (Window) GetXWindow();
     Display *xdisp = (Display*) GetXDisplay();
     if (show)
         XMapWindow(xdisp, xwin);
     else
         XUnmapWindow(xdisp, xwin);
     Window xwin = (Window) GetXWindow();
     Display *xdisp = (Display*) GetXDisplay();
     if (show)
         XMapWindow(xdisp, xwin);
     else
         XUnmapWindow(xdisp, xwin);

-#endif

 
     return TRUE;
 }
 
 // Raise the window to the top of the Z order
 
     return TRUE;
 }
 
 // Raise the window to the top of the Z order

-void wxWindow::Raise()
+void wxWindowX11::Raise()

 {
 {

-    Widget wTop = (Widget) GetTopWidget();
-    Window window = XtWindow(wTop);
-    XRaiseWindow(XtDisplay(wTop), window);
+    Window window = GetTopWindow();
+    if (window)
+        XRaiseWindow(wxGetDisplay(), window);

 }
 
 // Lower the window to the bottom of the Z order
 }
 
 // Lower the window to the bottom of the Z order

-void wxWindow::Lower()
+void wxWindowX11::Lower()

 {
 {

-    Widget wTop = (Widget) GetTopWidget();
-    Window window = XtWindow(wTop);
-    XLowerWindow(XtDisplay(wTop), window);
+    Window window = GetTopWindow();
+    if (window)
+        XLowerWindow(wxGetDisplay(), window);

 }
 
 }
 

-void wxWindow::SetTitle(const wxString& title)
+void wxWindowX11::SetTitle(const wxString& title)

 {
 {

-    XtVaSetValues((Widget)GetMainWidget(), XmNtitle, title.c_str(), NULL);
+    // TODO
+//    XtVaSetValues((Widget)GetMainWidget(), XmNtitle, title.c_str(), NULL);

 }
 
 }
 

-wxString wxWindow::GetTitle() const
+wxString wxWindowX11::GetTitle() const

 {
 {

+    // TODO
+    return wxEmptyString;
+#if 0

     char *title;
     XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &title, NULL);
 
     return wxString(title);
     char *title;
     XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &title, NULL);
 
     return wxString(title);

+#endif

 }
 
 }
 

-void wxWindow::DoCaptureMouse()
+void wxWindowX11::DoCaptureMouse()

 {
     g_captureWindow = this;
     if ( m_winCaptured )
         return;
 
 {
     g_captureWindow = this;
     if ( m_winCaptured )
         return;
 

+    // TODO
+#if 0

     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
         XtAddGrab(wMain, TRUE, FALSE);
     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
         XtAddGrab(wMain, TRUE, FALSE);

+#endif

 
     m_winCaptured = TRUE;
 }
 
 
     m_winCaptured = TRUE;
 }
 

-void wxWindow::DoReleaseMouse()
+void wxWindowX11::DoReleaseMouse()

 {
     g_captureWindow = NULL;
     if ( !m_winCaptured )
         return;
 
 {
     g_captureWindow = NULL;
     if ( !m_winCaptured )
         return;
 

+    // TODO
+#if 0

     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
         XtRemoveGrab(wMain);
     Widget wMain = (Widget)GetMainWidget();
     if ( wMain )
         XtRemoveGrab(wMain);

+#endif

 
     m_winCaptured = FALSE;
 }
 
 
     m_winCaptured = FALSE;
 }
 

-bool wxWindow::SetFont(const wxFont& font)
+bool wxWindowX11::SetFont(const wxFont& font)

 {
     if ( !wxWindowBase::SetFont(font) )
     {
 {
     if ( !wxWindowBase::SetFont(font) )
     {


@@ -752,7 +569,7 @@ bool wxWindow::SetFont(const wxFont& font)
     return TRUE;
 }
 
     return TRUE;
 }
 

-bool wxWindow::SetCursor(const wxCursor& cursor)
+bool wxWindowX11::SetCursor(const wxCursor& cursor)

 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {
 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {


@@ -760,8 +577,6 @@ bool wxWindow::SetCursor(const wxCursor& cursor)
         return FALSE;
     }
 
         return FALSE;
     }
 

-    //    wxASSERT_MSG( m_cursor.Ok(),
-    //                  wxT("cursor must be valid after call to the base version"));

     wxCursor* cursor2 = NULL;
     if (m_cursor.Ok())
         cursor2 = & m_cursor;
     wxCursor* cursor2 = NULL;
     if (m_cursor.Ok())
         cursor2 = & m_cursor;


@@ -771,83 +586,84 @@ bool wxWindow::SetCursor(const wxCursor& cursor)
     WXDisplay *dpy = GetXDisplay();
     WXCursor x_cursor = cursor2->GetXCursor(dpy);
 
     WXDisplay *dpy = GetXDisplay();
     WXCursor x_cursor = cursor2->GetXCursor(dpy);
 

-    Widget w = (Widget) GetMainWidget();
-    Window win = XtWindow(w);
+    Window win = (Window) GetMainWindow();

     XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
 
     return TRUE;
 }
 
 // Coordinates relative to the window
     XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
 
     return TRUE;
 }
 
 // Coordinates relative to the window

-void wxWindow::WarpPointer (int x, int y)
+void wxWindowX11::WarpPointer (int x, int y)

 {
 {

-    Widget wClient = (Widget)GetClientWidget();
+    Window wClient = (Window) GetClientWindow();

 
 

-    XWarpPointer(XtDisplay(wClient), None, XtWindow(wClient), 0, 0, 0, 0, x, y);
+    XWarpPointer(wxGetDisplay(), None, wClient, 0, 0, 0, 0, x, y);

 }
 
 // ---------------------------------------------------------------------------
 // scrolling stuff
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // scrolling stuff
 // ---------------------------------------------------------------------------
 

-int wxWindow::GetScrollPos(int orient) const
+int wxWindowX11::GetScrollPos(int orient) const

 {
     if (orient == wxHORIZONTAL)
         return m_scrollPosX;
     else
         return m_scrollPosY;
 {
     if (orient == wxHORIZONTAL)
         return m_scrollPosX;
     else
         return m_scrollPosY;

-
-#if 0
-    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
-    if (scrollBar)
-    {
-        int pos;
-        XtVaGetValues(scrollBar, XmNvalue, &pos, NULL);
-        return pos;
-    }
-    else
-        return 0;
-#endif // 0

 }
 
 // This now returns the whole range, not just the number of positions that we
 // can scroll.
 }
 
 // This now returns the whole range, not just the number of positions that we
 // can scroll.

-int wxWindow::GetScrollRange(int orient) const
+int wxWindowX11::GetScrollRange(int WXUNUSED(orient)) const

 {
 {

+    // TODO
+    return 0;
+#if 0

     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
     wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 
     int range;
     XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
     return range;
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
     wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 
     int range;
     XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
     return range;

+#endif

 }
 
 }
 

-int wxWindow::GetScrollThumb(int orient) const
+int wxWindowX11::GetScrollThumb(int orient) const

 {
 {

+    // TODO
+    return 0;
+
+#if 0

     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
     wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 
     int thumb;
     XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
     return thumb;
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
     wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 
     int thumb;
     XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
     return thumb;

+#endif

 }
 
 }
 

-void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
+void wxWindowX11::SetScrollPos(int WXUNUSED(orient), int WXUNUSED(pos), bool WXUNUSED(refresh))

 {
 {

+    // TODO
+
+#if 0

     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 
     if ( scrollBar )
     {
         XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
     }
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 
     if ( scrollBar )
     {
         XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
     }

-
+#endif

     SetInternalScrollPos((wxOrientation)orient, pos);
 }
 
 // New function that will replace some of the above.
     SetInternalScrollPos((wxOrientation)orient, pos);
 }
 
 // New function that will replace some of the above.

-void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
-                            int range, bool WXUNUSED(refresh))
+void wxWindowX11::SetScrollbar(int WXUNUSED(orient), int WXUNUSED(pos), int WXUNUSED(thumbVisible),
+                            int WXUNUSED(range), bool WXUNUSED(refresh))

 {
 {

+    // TODO
+#if 0

     int oldW, oldH;
     GetSize(& oldW, & oldH);
 
     int oldW, oldH;
     GetSize(& oldW, & oldH);
 


@@ -917,10 +733,11 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
     // Adjusting scrollbars can resize the canvas accidentally
     if (newW != oldW || newH != oldH)
         SetSize(-1, -1, oldW, oldH);
     // Adjusting scrollbars can resize the canvas accidentally
     if (newW != oldW || newH != oldH)
         SetSize(-1, -1, oldW, oldH);

+#endif

 }
 
 // Does a physical scroll
 }
 
 // Does a physical scroll

-void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
+void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)

 {
     int x, y, w, h;
     if (rect)
 {
     int x, y, w, h;
     if (rect)


@@ -934,45 +751,44 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         x = 0; y = 0;
         GetClientSize(& w, & h);
     }
         x = 0; y = 0;
         GetClientSize(& w, & h);
     }

-
+    

     wxNode *cnode = m_children.First();
     while (cnode)
     {
         wxWindow *child = (wxWindow*) cnode->Data();
     wxNode *cnode = m_children.First();
     while (cnode)
     {
         wxWindow *child = (wxWindow*) cnode->Data();

-       int sx = 0;
-       int sy = 0;
-       child->GetSize( &sx, &sy );
+        int sx = 0;
+        int sy = 0;
+        child->GetSize( &sx, &sy );

         wxPoint pos( child->GetPosition() );
         wxPoint pos( child->GetPosition() );

-       child->SetSize( pos.x + dx, pos.y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
-       cnode = cnode->Next();
+        child->SetSize( pos.x + dx, pos.y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
+        cnode = cnode->Next();

     }
     }

-
+    

     int x1 = (dx >= 0) ? x : x - dx;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);
     int h1 = h - abs(dy);
     int x2 = (dx >= 0) ? x + dx : x;
     int y2 = (dy >= 0) ? y + dy : y;
     int x1 = (dx >= 0) ? x : x - dx;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);
     int h1 = h - abs(dy);
     int x2 = (dx >= 0) ? x + dx : x;
     int y2 = (dy >= 0) ? y + dy : y;

-
+    

     wxClientDC dc(this);
     wxClientDC dc(this);

-
+    

     dc.SetLogicalFunction (wxCOPY);
     dc.SetLogicalFunction (wxCOPY);

-
-    Widget widget = (Widget) GetMainWidget();
-    Window window = XtWindow(widget);
-    Display* display = XtDisplay(widget);
-
+    
+    Window window = (Window) GetMainWindow();
+    Display* display = wxGetDisplay();
+    

     XCopyArea(display, window, window, (GC) dc.GetGC(),
     XCopyArea(display, window, window, (GC) dc.GetGC(),

-              x1, y1, w1, h1, x2, y2);
-
+        x1, y1, w1, h1, x2, y2);
+    

     dc.SetAutoSetting(TRUE);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBrush(brush); // FIXME: needed?
     dc.SetAutoSetting(TRUE);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBrush(brush); // FIXME: needed?

-
+    

     // We'll add rectangles to the list of update rectangles according to which
     // bits we've exposed.
     wxList updateRects;
     // We'll add rectangles to the list of update rectangles according to which
     // bits we've exposed.
     wxList updateRects;

-
+    

     if (dx > 0)
     {
         wxRect *rect = new wxRect;
     if (dx > 0)
     {
         wxRect *rect = new wxRect;


@@ -980,103 +796,103 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->y = y;
         rect->width = dx;
         rect->height = h;
         rect->y = y;
         rect->width = dx;
         rect->height = h;

-
+        

         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);

-
+        

         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;

-
+        

         updateRects.Append((wxObject*) rect);
     }
     else if (dx < 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     else if (dx < 0)
     {
         wxRect *rect = new wxRect;

-
+        

         rect->x = x + w + dx;
         rect->y = y;
         rect->width = -dx;
         rect->height = h;
         rect->x = x + w + dx;
         rect->y = y;
         rect->width = -dx;
         rect->height = h;

-
+        

         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width,
             rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width,
             rect->height);

-
+        

         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;

-
+        

         updateRects.Append((wxObject*) rect);
     }
     if (dy > 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     if (dy > 0)
     {
         wxRect *rect = new wxRect;

-
+        

         rect->x = x;
         rect->y = y;
         rect->width = w;
         rect->height = dy;
         rect->x = x;
         rect->y = y;
         rect->width = w;
         rect->height = dy;

-
+        

         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);

-
+        

         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;

-
+        

         updateRects.Append((wxObject*) rect);
     }
     else if (dy < 0)
     {
         wxRect *rect = new wxRect;
         updateRects.Append((wxObject*) rect);
     }
     else if (dy < 0)
     {
         wxRect *rect = new wxRect;

-
+        

         rect->x = x;
         rect->y = y + h + dy;
         rect->width = w;
         rect->height = -dy;
         rect->x = x;
         rect->y = y + h + dy;
         rect->width = w;
         rect->height = -dy;

-
+        

         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
         XFillRectangle(display, window,
             (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);

-
+        

         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;
         rect->x = rect->x;
         rect->y = rect->y;
         rect->width = rect->width;
         rect->height = rect->height;

-
+        

         updateRects.Append((wxObject*) rect);
     }
     dc.SetBrush(wxNullBrush);
         updateRects.Append((wxObject*) rect);
     }
     dc.SetBrush(wxNullBrush);

-
+    

     // Now send expose events
     // Now send expose events

-
+    

     wxNode* node = updateRects.First();
     while (node)
     {
         wxRect* rect = (wxRect*) node->Data();
         XExposeEvent event;
     wxNode* node = updateRects.First();
     while (node)
     {
         wxRect* rect = (wxRect*) node->Data();
         XExposeEvent event;

-
+        

         event.type = Expose;
         event.display = display;
         event.send_event = True;
         event.window = window;
         event.type = Expose;
         event.display = display;
         event.send_event = True;
         event.window = window;

-
+        

         event.x = rect->x;
         event.y = rect->y;
         event.width = rect->width;
         event.height = rect->height;
         event.x = rect->x;
         event.y = rect->y;
         event.width = rect->width;
         event.height = rect->height;

-
+        

         event.count = 0;
         event.count = 0;

-
+        

         XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
         XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);

-
+        

         node = node->Next();
         node = node->Next();

-
+        

     }
     }

-
+    

     // Delete the update rects
     node = updateRects.First();
     while (node)
     // Delete the update rects
     node = updateRects.First();
     while (node)


@@ -1085,8 +901,10 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         delete rect;
         node = node->Next();
     }
         delete rect;
         node = node->Next();
     }

+    
+    // TODO

 
 

-    XmUpdateDisplay((Widget) GetMainWidget());
+    // XmUpdateDisplay((Widget) GetMainWidget());

 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------


@@ -1095,7 +913,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 
 #if wxUSE_DRAG_AND_DROP
 
 
 #if wxUSE_DRAG_AND_DROP
 

-void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
+void wxWindowX11::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))

 {
     // TODO
 }
 {
     // TODO
 }


@@ -1103,7 +921,7 @@ void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
 #endif
 
 // Old style file-manager drag&drop
 #endif
 
 // Old style file-manager drag&drop

-void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
+void wxWindowX11::DragAcceptFiles(bool WXUNUSED(accept))

 {
     // TODO
 }
 {
     // TODO
 }


@@ -1114,95 +932,27 @@ void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 

-void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
+void wxWindowX11::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))

 {
     // TODO
 }
 
 #endif // wxUSE_TOOLTIPS
 
 {
     // TODO
 }
 
 #endif // wxUSE_TOOLTIPS
 

-// ----------------------------------------------------------------------------
-// popup menus
-// ----------------------------------------------------------------------------
-
-bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
-{
-    Widget widget = (Widget) GetMainWidget();
-
-    /* The menuId field seems to be usused, so we'll use it to
-    indicate whether a menu is popped up or not:
-    0: Not currently created as a popup
-    -1: Created as a popup, but not active
-    1: Active popup.
-    */
-
-    if (menu->GetParent() && (menu->GetId() != -1))
-        return FALSE;
-
-    if (menu->GetMainWidget()) {
-        menu->DestroyMenu(TRUE);
-    }
-
-    menu->SetId(1); /* Mark as popped-up */
-    menu->CreateMenu(NULL, widget, menu);
-    menu->SetInvokingWindow(this);
-
-    menu->UpdateUI();
-
-    //  menu->SetParent(parent);
-    //  parent->children->Append(menu);  // Store menu for later deletion
-
-    Widget menuWidget = (Widget) menu->GetMainWidget();
-
-    int rootX = 0;
-    int rootY = 0;
-
-    int deviceX = x;
-    int deviceY = y;
-    /*
-    if (this->IsKindOf(CLASSINFO(wxCanvas)))
-    {
-    wxCanvas *canvas = (wxCanvas *) this;
-    deviceX = canvas->GetDC ()->LogicalToDeviceX (x);
-    deviceY = canvas->GetDC ()->LogicalToDeviceY (y);
-    }
-    */
-
-    Display *display = XtDisplay (widget);
-    Window rootWindow = RootWindowOfScreen (XtScreen((Widget)widget));
-    Window thisWindow = XtWindow (widget);
-    Window childWindow;
-    XTranslateCoordinates (display, thisWindow, rootWindow, (int) deviceX, (int) deviceY,
-        &rootX, &rootY, &childWindow);
-
-    XButtonPressedEvent event;
-    event.type = ButtonPress;
-    event.button = 1;
-
-    event.x = deviceX;
-    event.y = deviceY;
-
-    event.x_root = rootX;
-    event.y_root = rootY;
-
-    XmMenuPosition (menuWidget, &event);
-    XtManageChild (menuWidget);
-
-    return TRUE;
-}
-

 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 

-bool wxWindow::PreResize()
+bool wxWindowX11::PreResize()

 {
     return TRUE;
 }
 
 // Get total size
 {
     return TRUE;
 }
 
 // Get total size

-void wxWindow::DoGetSize(int *x, int *y) const
+void wxWindowX11::DoGetSize(int *x, int *y) const

 {
 {

+    // TODO
+#if 0

     if (m_drawingArea)
     {
         CanvasGetSize(x, y);
     if (m_drawingArea)
     {
         CanvasGetSize(x, y);


@@ -1213,10 +963,13 @@ void wxWindow::DoGetSize(int *x, int *y) const
     Dimension xx, yy;
     XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
     if(x) *x = xx; if(y) *y = yy;
     Dimension xx, yy;
     XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
     if(x) *x = xx; if(y) *y = yy;

+#endif

 }
 
 }
 

-void wxWindow::DoGetPosition(int *x, int *y) const
+void wxWindowX11::DoGetPosition(int *x, int *y) const

 {
 {

+    // TODO
+#if 0

     if (m_drawingArea)
     {
         CanvasGetPosition(x, y);
     if (m_drawingArea)
     {
         CanvasGetPosition(x, y);


@@ -1236,14 +989,14 @@ void wxWindow::DoGetPosition(int *x, int *y) const
     }
 
     if(x) *x = xx; if(y) *y = yy;
     }
 
     if(x) *x = xx; if(y) *y = yy;

+#endif

 }
 
 }
 

-void wxWindow::DoScreenToClient(int *x, int *y) const
+void wxWindowX11::DoScreenToClient(int *x, int *y) const

 {
 {

-    Widget widget = (Widget) GetClientWidget();
-    Display *display = XtDisplay((Widget) GetMainWidget());
-    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
-    Window thisWindow = XtWindow(widget);
+    Display *display = wxGetDisplay();
+    Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
+    Window thisWindow = (Window) GetClientWindow();

 
     Window childWindow;
     int xx = *x;
 
     Window childWindow;
     int xx = *x;


@@ -1251,12 +1004,11 @@ void wxWindow::DoScreenToClient(int *x, int *y) const
     XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
 }
 
     XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
 }
 

-void wxWindow::DoClientToScreen(int *x, int *y) const
+void wxWindowX11::DoClientToScreen(int *x, int *y) const

 {
 {

-    Widget widget = (Widget) GetClientWidget();
-    Display *display = XtDisplay(widget);
-    Window rootWindow = RootWindowOfScreen(XtScreen(widget));
-    Window thisWindow = XtWindow(widget);
+    Display *display = wxGetDisplay();
+    Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
+    Window thisWindow = (Window) GetClientWindow();

 
     Window childWindow;
     int xx = *x;
 
     Window childWindow;
     int xx = *x;


@@ -1266,16 +1018,21 @@ void wxWindow::DoClientToScreen(int *x, int *y) const
 
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.

-void wxWindow::DoGetClientSize(int *x, int *y) const
+void wxWindowX11::DoGetClientSize(int *x, int *y) const

 {
 {

+    // TODO
+#if 0

     Widget widget = (Widget) GetClientWidget();
     Dimension xx, yy;
     XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
     if(x) *x = xx; if(y) *y = yy;
     Widget widget = (Widget) GetClientWidget();
     Dimension xx, yy;
     XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
     if(x) *x = xx; if(y) *y = yy;

+#endif

 }
 
 }
 

-void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)

 {
 {

+    // TODO
+#if 0

     // A bit of optimization to help sort out the flickers.
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);
     // A bit of optimization to help sort out the flickers.
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);


@@ -1327,19 +1084,14 @@ void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
         if (managed)
             XtManageChild(widget);
 
         if (managed)
             XtManageChild(widget);
 

-        // How about this bit. Maybe we don't need to generate size events
-        // all the time -- they'll be generated when the window is sized anyway.
-#if 0
-        wxSizeEvent sizeEvent(wxSize(width, height), GetId());
-        sizeEvent.SetEventObject(this);
-
-        GetEventHandler()->ProcessEvent(sizeEvent);
-#endif // 0

     }
     }

+#endif

 }
 
 }
 

-void wxWindow::DoSetClientSize(int width, int height)
+void wxWindowX11::DoSetClientSize(int width, int height)

 {
 {

+    // TODO
+#if 0

     if (m_drawingArea)
     {
         CanvasSetClientSize(width, height);
     if (m_drawingArea)
     {
         CanvasSetClientSize(width, height);


@@ -1357,18 +1109,19 @@ void wxWindow::DoSetClientSize(int width, int height)
     sizeEvent.SetEventObject(this);
 
     GetEventHandler()->ProcessEvent(sizeEvent);
     sizeEvent.SetEventObject(this);
 
     GetEventHandler()->ProcessEvent(sizeEvent);

+#endif

 }
 
 // For implementation purposes - sometimes decorations make the client area
 // smaller
 }
 
 // For implementation purposes - sometimes decorations make the client area
 // smaller

-wxPoint wxWindow::GetClientAreaOrigin() const
+wxPoint wxWindowX11::GetClientAreaOrigin() const

 {
     return wxPoint(0, 0);
 }
 
 // Makes an adjustment to the window position (for example, a frame that has
 // a toolbar that it manages itself).
 {
     return wxPoint(0, 0);
 }
 
 // Makes an adjustment to the window position (for example, a frame that has
 // a toolbar that it manages itself).

-void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
+void wxWindowX11::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)

 {
     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
     {
 {
     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
     {


@@ -1377,8 +1130,10 @@ void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
     }
 }
 
     }
 }
 

-void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
+void wxWindowX11::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)

 {
 {

+    // TODO
+#if 0

     m_minWidth = minW;
     m_minHeight = minH;
     m_maxWidth = maxW;
     m_minWidth = minW;
     m_minHeight = minH;
     m_maxWidth = maxW;


@@ -1405,23 +1160,27 @@ void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, in
         XtVaSetValues(widget, XmNwidthInc, incW, NULL);
     if (incH > -1)
         XtVaSetValues(widget, XmNheightInc, incH, NULL);
         XtVaSetValues(widget, XmNwidthInc, incW, NULL);
     if (incH > -1)
         XtVaSetValues(widget, XmNheightInc, incH, NULL);

+#endif

 }
 
 }
 

-void wxWindow::DoMoveWindow(int x, int y, int width, int height)
+void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)

 {
 {

+    // TODO
+#if 0

     XtVaSetValues((Widget)GetTopWidget(),
                   XmNx, x,
                   XmNy, y,
                   XmNwidth, width,
                   XmNheight, height,
                   NULL);
     XtVaSetValues((Widget)GetTopWidget(),
                   XmNx, x,
                   XmNy, y,
                   XmNwidth, width,
                   XmNheight, height,
                   NULL);

+#endif

 }
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 

-int wxWindow::GetCharHeight() const
+int wxWindowX11::GetCharHeight() const

 {
     wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
 
 {
     wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
 


@@ -1436,7 +1195,7 @@ int wxWindow::GetCharHeight() const
     return (ascent + descent);
 }
 
     return (ascent + descent);
 }
 

-int wxWindow::GetCharWidth() const
+int wxWindowX11::GetCharWidth() const

 {
     wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
 
 {
     wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
 


@@ -1450,7 +1209,7 @@ int wxWindow::GetCharWidth() const
     return overall.width;
 }
 
     return overall.width;
 }
 

-void wxWindow::GetTextExtent(const wxString& string,
+void wxWindowX11::GetTextExtent(const wxString& string,

                              int *x, int *y,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
                              int *x, int *y,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const


@@ -1491,11 +1250,11 @@ void wxWindow::GetTextExtent(const wxString& string,
 // painting
 // ----------------------------------------------------------------------------
 
 // painting
 // ----------------------------------------------------------------------------
 

-void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
+void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)

 {
     m_needsRefresh = TRUE;
 {
     m_needsRefresh = TRUE;

-    Display *display = XtDisplay((Widget) GetMainWidget());
-    Window thisWindow = XtWindow((Widget) GetMainWidget());
+    Display *display = wxGetDisplay();
+    Window thisWindow = (Widget) GetMainWindow();

 
     XExposeEvent dummyEvent;
     int width, height;
 
     XExposeEvent dummyEvent;
     int width, height;


@@ -1535,7 +1294,7 @@ void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
 }
 
     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
 }
 

-void wxWindow::Clear()
+void wxWindowX11::Clear()

 {
     wxClientDC dc(this);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
 {
     wxClientDC dc(this);
     wxBrush brush(GetBackgroundColour(), wxSOLID);


@@ -1543,7 +1302,7 @@ void wxWindow::Clear()
     dc.Clear();
 }
 
     dc.Clear();
 }
 

-void wxWindow::ClearUpdateRects()
+void wxWindowX11::ClearUpdateRects()

 {
     wxRectList::Node* node = m_updateRects.GetFirst();
     while (node)
 {
     wxRectList::Node* node = m_updateRects.GetFirst();
     while (node)


@@ -1556,77 +1315,18 @@ void wxWindow::ClearUpdateRects()
     m_updateRects.Clear();
 }
 
     m_updateRects.Clear();
 }
 

-void wxWindow::DoPaint()
+void wxWindowX11::DoPaint()

 {
 {

-    //TODO : make a temporary gc so we can do the XCopyArea below
-    if (m_backingPixmap && !m_needsRefresh)
-    {
-      wxPaintDC dc(this);
-
-      GC tempGC = (GC) dc.GetBackingGC();
-
-      Widget widget = (Widget) GetMainWidget();
-
-      int scrollPosX = 0;
-      int scrollPosY = 0;
-
-      // We have to test whether it's a wxScrolledWindow (hack!) because
-      // otherwise we don't know how many pixels have been scrolled. We might
-      // solve this in the future by defining virtual wxWindow functions to get
-      // the scroll position in pixels. Or, each kind of scrolled window has to
-      // implement backing stores itself, using generic wxWindows code.
-      wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
-      if ( scrolledWindow )
-      {
-          int x, y;
-          scrolledWindow->CalcScrolledPosition(0, 0, &x, &y);
-
-          scrollPosX = - x;
-          scrollPosY = - y;
-      }
-
-      // TODO: This could be optimized further by only copying the areas in the
-      //       current update region.
-
-      // Only blit the part visible in the client area. The backing pixmap
-      // always starts at 0, 0 but we may be looking at only a portion of it.
-      wxSize clientArea = GetClientSize();
-      int toBlitX = m_pixmapWidth - scrollPosX;
-      int toBlitY = m_pixmapHeight - scrollPosY;
-
-      // Copy whichever is samller, the amount of pixmap we have to copy,
-      // or the size of the client area.
-      toBlitX = wxMin(toBlitX, clientArea.x);
-      toBlitY = wxMin(toBlitY, clientArea.y);
-
-      // Make sure we're not negative
-      toBlitX = wxMax(0, toBlitX);
-      toBlitY = wxMax(0, toBlitY);
-
-      XCopyArea
-      (
-       XtDisplay(widget),
-       (Pixmap) m_backingPixmap,
-       XtWindow (widget),
-       tempGC,
-       scrollPosX, scrollPosY, // Start at the scroll position
-       toBlitX, toBlitY,       // How much of the pixmap to copy
-       0, 0                    // Destination
-      );
-    }
-    else
-    {
-        // Set an erase event first
-        wxEraseEvent eraseEvent(GetId());
-        eraseEvent.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(eraseEvent);
-
-        wxPaintEvent event(GetId());
-        event.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(event);
-
-        m_needsRefresh = FALSE;
-    }
+    // Set an erase event first
+    wxEraseEvent eraseEvent(GetId());
+    eraseEvent.SetEventObject(this);
+    GetEventHandler()->ProcessEvent(eraseEvent);
+    
+    wxPaintEvent event(GetId());
+    event.SetEventObject(this);
+    GetEventHandler()->ProcessEvent(event);
+    
+    m_needsRefresh = FALSE;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1634,7 +1334,7 @@ void wxWindow::DoPaint()
 // ----------------------------------------------------------------------------
 
 // Responds to colour changes: passes event on to children.
 // ----------------------------------------------------------------------------
 
 // Responds to colour changes: passes event on to children.

-void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)

 {
     wxWindowList::Node *node = GetChildren().GetFirst();
     while ( node )
 {
     wxWindowList::Node *node = GetChildren().GetFirst();
     while ( node )


@@ -1652,7 +1352,7 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
     }
 }
 

-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindowX11::OnIdle(wxIdleEvent& WXUNUSED(event))

 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)
 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)


@@ -1663,7 +1363,7 @@ void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
 // accelerators
 // ----------------------------------------------------------------------------
 
 // accelerators
 // ----------------------------------------------------------------------------
 

-bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
+bool wxWindowX11::ProcessAccelerator(wxKeyEvent& event)

 {
     if (!m_acceleratorTable.Ok())
         return FALSE;
 {
     if (!m_acceleratorTable.Ok())
         return FALSE;


@@ -1732,14 +1432,14 @@ bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
 }
 
 // ============================================================================
 }
 
 // ============================================================================

-// Motif-specific stuff from here on
+// X11-specific stuff from here on

 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // function which maintain the global hash table mapping Widgets to wxWindows
 // ----------------------------------------------------------------------------
 
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // function which maintain the global hash table mapping Widgets to wxWindows
 // ----------------------------------------------------------------------------
 

-bool wxAddWindowToTable(Widget w, wxWindow *win)
+bool wxAddWindowToTable(Window w, wxWindow *win)

 {
     wxWindow *oldItem = NULL;
     if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
 {
     wxWindow *oldItem = NULL;
     if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))


@@ -1751,18 +1451,18 @@ bool wxAddWindowToTable(Widget w, wxWindow *win)
 
     wxWidgetHashTable->Put((long) w, win);
 
 
     wxWidgetHashTable->Put((long) w, win);
 

-    wxLogTrace("widget", "Widget 0x%08x <-> window %p (%s)",
+    wxLogTrace("widget", "XWindow 0x%08x <-> window %p (%s)",

                w, win, win->GetClassInfo()->GetClassName());
 
     return TRUE;
 }
 
                w, win, win->GetClassInfo()->GetClassName());
 
     return TRUE;
 }
 

-wxWindow *wxGetWindowFromTable(Widget w)
+wxWindow *wxGetWindowFromTable(Window w)

 {
     return (wxWindow *)wxWidgetHashTable->Get((long) w);
 }
 
 {
     return (wxWindow *)wxWidgetHashTable->Get((long) w);
 }
 

-void wxDeleteWindowFromTable(Widget w)
+void wxDeleteWindowFromTable(Window w)

 {
     wxWidgetHashTable->Delete((long)w);
 }
 {
     wxWidgetHashTable->Delete((long)w);
 }


@@ -1772,10 +1472,13 @@ void wxDeleteWindowFromTable(Widget w)
 // ----------------------------------------------------------------------------
 
 // Add to hash table, add event handler
 // ----------------------------------------------------------------------------
 
 // Add to hash table, add event handler

-bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
-                             WXWidget formWidget, int x, int y, int width, int height)
+bool wxWindowX11::AttachWidget (wxWindow* WXUNUSED(parent), WXWindow mainWidget,
+                             int x, int y, int width, int height)

 {
 {

-    wxAddWindowToTable((Widget) mainWidget, this);
+    wxAddWindowToTable((Window ) mainWidget, this);
+
+    // TODO
+#if 0

     if (CanAddEventHandler())
     {
         XtAddEventHandler((Widget) mainWidget,
     if (CanAddEventHandler())
     {
         XtAddEventHandler((Widget) mainWidget,


@@ -1804,19 +1507,22 @@ bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
             ptr = XtParseTranslationTable ("<Configure>: resize()"));
         XtFree ((char *) ptr);
     }
             ptr = XtParseTranslationTable ("<Configure>: resize()"));
         XtFree ((char *) ptr);
     }

-
+#endif

     if (x == -1)
         x = 0;
     if (y == -1)
         y = 0;
     if (x == -1)
         x = 0;
     if (y == -1)
         y = 0;

+

     SetSize (x, y, width, height);
 
     return TRUE;
 }
 
 // Remove event handler, remove from hash table
     SetSize (x, y, width, height);
 
     return TRUE;
 }
 
 // Remove event handler, remove from hash table

-bool wxWindow::DetachWidget(WXWidget widget)
+bool wxWindowX11::DetachWidget(WXWindow widget)

 {
 {

+    // TODO
+#if 0

     if (CanAddEventHandler())
     {
         XtRemoveEventHandler((Widget) widget,
     if (CanAddEventHandler())
     {
         XtRemoveEventHandler((Widget) widget,


@@ -1825,36 +1531,29 @@ bool wxWindow::DetachWidget(WXWidget widget)
             wxPanelItemEventHandler,
             (XtPointer)this);
     }
             wxPanelItemEventHandler,
             (XtPointer)this);
     }

+#endif

 
 

-    wxDeleteWindowFromTable((Widget) widget);
+    wxDeleteWindowFromTable((Window) widget);

     return TRUE;
 }
 
 // ----------------------------------------------------------------------------
     return TRUE;
 }
 
 // ----------------------------------------------------------------------------

-// Motif-specific accessors
+// X11-specific accessors

 // ----------------------------------------------------------------------------
 
 // Get the underlying X window
 // ----------------------------------------------------------------------------
 
 // Get the underlying X window

-WXWindow wxWindow::GetXWindow() const
+WXWindow wxWindowX11::GetXWindow() const

 {
 {

-    Widget wMain = (Widget)GetMainWidget();
-    if ( wMain )
-        return (WXWindow) XtWindow(wMain);
-    else
-        return (WXWindow) 0;
+    return GetMainWindow();

 }
 
 // Get the underlying X display
 }
 
 // Get the underlying X display

-WXDisplay *wxWindow::GetXDisplay() const
+WXDisplay *wxWindowX11::GetXDisplay() const

 {
 {

-    Widget wMain = (Widget)GetMainWidget();
-    if ( wMain )
-        return (WXDisplay*) XtDisplay(wMain);
-    else
-        return (WXDisplay*) NULL;
+    return wxGetDisplay();

 }
 
 }
 

-WXWidget wxWindow::GetMainWidget() const
+WXWindow wxWindowX11::GetMainWindow() const

 {
     if (m_drawingArea)
         return m_drawingArea;
 {
     if (m_drawingArea)
         return m_drawingArea;


@@ -1862,28 +1561,31 @@ WXWidget wxWindow::GetMainWidget() const
         return m_mainWidget;
 }
 
         return m_mainWidget;
 }
 

-WXWidget wxWindow::GetClientWidget() const
+WXWindow wxWindowX11::GetClientWidget() const

 {
 {

-    if (m_drawingArea != (WXWidget) 0)
+    if (m_drawingArea != (WXWindow) 0)

         return m_drawingArea;
     else
         return m_drawingArea;
     else

-        return GetMainWidget();
+        return GetMainWindow();

 }
 
 }
 

-WXWidget wxWindow::GetTopWidget() const
+WXWindow wxWindowX11::GetTopWindow() const

 {
 {

-    return GetMainWidget();
+    return GetMainWindow();

 }
 
 }
 

-WXWidget wxWindow::GetLabelWidget() const
+WXWindow wxWindowX11::GetLabelWindow() const

 {
 {

-    return GetMainWidget();
+    return GetMainWindow();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// Motif callbacks
+// callbacks

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

+// TODO
+#if 0
+

 // All widgets should have this as their resize proc.
 // OnSize sent to wxWindow via client data.
 void wxWidgetResizeProc(Widget w, XConfigureEvent *WXUNUSED(event), String WXUNUSED(args)[], int *WXUNUSED(num_args))
 // All widgets should have this as their resize proc.
 // OnSize sent to wxWindow via client data.
 void wxWidgetResizeProc(Widget w, XConfigureEvent *WXUNUSED(event), String WXUNUSED(args)[], int *WXUNUSED(num_args))


@@ -2268,10 +1970,10 @@ static void wxPanelItemEventHandler(Widget    wid,
 
     // TODO: probably the key to allowing default behaviour to happen. Say we
     // set a m_doDefault flag to FALSE at the start of this function. Then in
 
     // TODO: probably the key to allowing default behaviour to happen. Say we
     // set a m_doDefault flag to FALSE at the start of this function. Then in

-    // e.g. wxWindow::OnMouseEvent we can call Default() which sets this flag to
+    // e.g. wxWindowX11::OnMouseEvent we can call Default() which sets this flag to

     // TRUE, indicating that default processing can happen. Thus, behaviour can
     // appear to be overridden just by adding an event handler and not calling
     // TRUE, indicating that default processing can happen. Thus, behaviour can
     // appear to be overridden just by adding an event handler and not calling

-    // wxWindow::OnWhatever. ALSO, maybe we can use this instead of the current
+    // wxWindowX11::OnWhatever. ALSO, maybe we can use this instead of the current

     // way of handling drawing area events, to simplify things.
     *continueToDispatch = True;
 }
     // way of handling drawing area events, to simplify things.
     *continueToDispatch = True;
 }


@@ -2376,13 +2078,18 @@ void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event,
     }
 }
 
     }
 }
 

+#endif
+    // 0
+

 // ----------------------------------------------------------------------------
 // CanvaseXXXSize() functions
 // ----------------------------------------------------------------------------
 
 // SetSize, but as per old wxCanvas (with drawing widget etc.)
 // ----------------------------------------------------------------------------
 // CanvaseXXXSize() functions
 // ----------------------------------------------------------------------------
 
 // SetSize, but as per old wxCanvas (with drawing widget etc.)

-void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
+void wxWindowX11::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)

 {
 {

+    // TODO
+#if 0

     // A bit of optimization to help sort out the flickers.
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);
     // A bit of optimization to help sort out the flickers.
     int oldX, oldY, oldW, oldH;
     GetSize(& oldW, & oldH);


@@ -2508,19 +2215,14 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
     if (managed)
         XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
     if (managed)
         XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);

-
-#if 0
-    int ww, hh;
-    GetClientSize (&ww, &hh);
-    wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
-    sizeEvent.SetEventObject(this);
-
-    GetEventHandler()->ProcessEvent(sizeEvent);
-#endif // 0
+#endif
+    // 0

 }
 
 }
 

-void wxWindow::CanvasSetClientSize (int w, int h)
+void wxWindowX11::CanvasSetClientSize (int w, int h)

 {
 {

+// TODO
+#if 0

     Widget drawingArea = (Widget) m_drawingArea;
 
     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
     Widget drawingArea = (Widget) m_drawingArea;
 
     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);


@@ -2530,44 +2232,26 @@ void wxWindow::CanvasSetClientSize (int w, int h)
     if (h > -1)
         XtVaSetValues(drawingArea, XmNheight, h, NULL);
 
     if (h > -1)
         XtVaSetValues(drawingArea, XmNheight, h, NULL);
 

-#if 0
-    // TODO: is this necessary?
-    allowRepainting = FALSE;
-
-    XSync (XtDisplay (drawingArea), FALSE);
-    XEvent event;
-    while (XtAppPending (wxTheApp->appContext))
-    {
-        XFlush (XtDisplay (drawingArea));
-        XtAppNextEvent (wxTheApp->appContext, &event);
-        XtDispatchEvent (&event);
-    }
-#endif // 0
-

     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
     XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);

-
-#if 0
-    allowRepainting = TRUE;
-    DoRefresh ();
-
-    wxSizeEvent sizeEvent(wxSize(w, h), GetId());
-    sizeEvent.SetEventObject(this);
-
-    GetEventHandler()->ProcessEvent(sizeEvent);

 #endif // 0
 }
 
 #endif // 0
 }
 

-void wxWindow::CanvasGetClientSize (int *w, int *h) const
+void wxWindowX11::CanvasGetClientSize (int *w, int *h) const

 {
 {

+// TODO
+#if 0

     // Must return the same thing that was set via SetClientSize
     Dimension xx, yy;
     XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
     *w = xx;
     *h = yy;
     // Must return the same thing that was set via SetClientSize
     Dimension xx, yy;
     XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
     *w = xx;
     *h = yy;

+#endif

 }
 
 }
 

-void wxWindow::CanvasGetSize (int *w, int *h) const
+void wxWindowX11::CanvasGetSize (int *w, int *h) const

 {
 {

+// TODO
+#if 0

     Dimension xx, yy;
     if ((Widget) m_borderWidget)
         XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
     Dimension xx, yy;
     if ((Widget) m_borderWidget)
         XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);


@@ -2578,10 +2262,13 @@ void wxWindow::CanvasGetSize (int *w, int *h) const
 
     *w = xx;
     *h = yy;
 
     *w = xx;
     *h = yy;

+#endif

 }
 
 }
 

-void wxWindow::CanvasGetPosition (int *x, int *y) const
+void wxWindowX11::CanvasGetPosition (int *x, int *y) const

 {
 {

+// TODO
+#if 0

     Position xx, yy;
     XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
 
     Position xx, yy;
     XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
 


@@ -2597,6 +2284,7 @@ void wxWindow::CanvasGetPosition (int *x, int *y) const
 
     *x = xx;
     *y = yy;
 
     *x = xx;
     *y = yy;

+#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -2605,6 +2293,8 @@ void wxWindow::CanvasGetPosition (int *x, int *y) const
 
 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {
 
 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {

+    // TODO
+#if 0

     switch (xevent->xany.type)
     {
         case EnterNotify:  // never received here - yes ? MB
     switch (xevent->xany.type)
     {
         case EnterNotify:  // never received here - yes ? MB


@@ -2742,6 +2432,7 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
             return TRUE;
         }
     }
             return TRUE;
         }
     }

+#endif

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -2755,10 +2446,6 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win
             char buf[20];
 
             KeySym keySym;
             char buf[20];
 
             KeySym keySym;

-#if 0
-            XComposeStatus compose;
-            (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
-#endif // 0

             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
 
             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
             int id = wxCharCodeXToWX (keySym);
 


@@ -2793,6 +2480,8 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win
 // Colour stuff
 // ----------------------------------------------------------------------------
 
 // Colour stuff
 // ----------------------------------------------------------------------------
 

+#if 0
+

 #define YAllocColor XAllocColor
 XColor g_itemColors[5];
 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
 #define YAllocColor XAllocColor
 XColor g_itemColors[5];
 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)


@@ -2852,46 +2541,38 @@ int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
     return (result);
 
 }
     return (result);
 
 }

+#endif

 
 // Changes the foreground and background colours to be derived from the current
 // background colour. To change the foreground colour, you must call
 // SetForegroundColour explicitly.
 
 // Changes the foreground and background colours to be derived from the current
 // background colour. To change the foreground colour, you must call
 // SetForegroundColour explicitly.

-void wxWindow::ChangeBackgroundColour()
+void wxWindowX11::ChangeBackgroundColour()

 {
 {

+    // TODO
+#if 0

     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
         DoChangeBackgroundColour(mainWidget, m_backgroundColour);
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
         DoChangeBackgroundColour(mainWidget, m_backgroundColour);

-
-    // This not necessary
-#if 0
-
-    if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
-    {
-        DoChangeBackgroundColour(m_scrolledWindow, m_backgroundColour);
-        // Have to set the scrollbar colours back since
-        // the scrolled window seemed to change them
-        wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-
-        if (m_hScrollBar)
-            DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
-        if (m_vScrollBar)
-            DoChangeBackgroundColour(m_vScrollBar, backgroundColour);
-    }

 #endif
 }
 
 #endif
 }
 

-void wxWindow::ChangeForegroundColour()
+void wxWindowX11::ChangeForegroundColour()

 {
 {

+    // TODO
+#if 0

     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
         DoChangeForegroundColour(mainWidget, m_foregroundColour);
     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
         DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
         DoChangeForegroundColour(mainWidget, m_foregroundColour);
     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
         DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);

+#endif

 }
 
 // Change a widget's foreground and background colours.
 }
 
 // Change a widget's foreground and background colours.

-void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
+void wxWindowX11::DoChangeForegroundColour(WXWindow widget, wxColour& foregroundColour)

 {
 {

+    // TODO
+#if 0

     // When should we specify the foreground, if it's calculated
     // by wxComputeColours?
     // Solution: say we start with the default (computed) foreground colour.
     // When should we specify the foreground, if it's calculated
     // by wxComputeColours?
     // Solution: say we start with the default (computed) foreground colour.


@@ -2907,10 +2588,13 @@ void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundCol
                   XmNforeground, foregroundColour.AllocColour(XtDisplay(w)),
                   NULL
                  );
                   XmNforeground, foregroundColour.AllocColour(XtDisplay(w)),
                   NULL
                  );

+#endif

 }
 
 }
 

-void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
+void wxWindowX11::DoChangeBackgroundColour(WXWindow widget, wxColour& backgroundColour, bool changeArmColour)

 {
 {

+    // TODO
+#if 0

     wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
         (wxColour*) NULL);
 
     wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
         (wxColour*) NULL);
 


@@ -2925,9 +2609,10 @@ void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundCol
         XtVaSetValues ((Widget) widget,
         XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
         NULL);
         XtVaSetValues ((Widget) widget,
         XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
         NULL);

+#endif

 }
 
 }
 

-bool wxWindow::SetBackgroundColour(const wxColour& col)
+bool wxWindowX11::SetBackgroundColour(const wxColour& col)

 {
     if ( !wxWindowBase::SetBackgroundColour(col) )
         return FALSE;
 {
     if ( !wxWindowBase::SetBackgroundColour(col) )
         return FALSE;


@@ -2937,7 +2622,7 @@ bool wxWindow::SetBackgroundColour(const wxColour& col)
     return TRUE;
 }
 
     return TRUE;
 }
 

-bool wxWindow::SetForegroundColour(const wxColour& col)
+bool wxWindowX11::SetForegroundColour(const wxColour& col)

 {
     if ( !wxWindowBase::SetForegroundColour(col) )
         return FALSE;
 {
     if ( !wxWindowBase::SetForegroundColour(col) )
         return FALSE;


@@ -2947,8 +2632,10 @@ bool wxWindow::SetForegroundColour(const wxColour& col)
     return TRUE;
 }
 
     return TRUE;
 }
 

-void wxWindow::ChangeFont(bool keepOriginalSize)
+void wxWindowX11::ChangeFont(bool keepOriginalSize)

 {
 {

+    // TODO
+#if 0

     // Note that this causes the widget to be resized back
     // to its original size! We therefore have to set the size
     // back again. TODO: a better way in Motif?
     // Note that this causes the widget to be resized back
     // to its original size! We therefore have to set the size
     // back again. TODO: a better way in Motif?


@@ -2971,6 +2658,7 @@ void wxWindow::ChangeFont(bool keepOriginalSize)
             SetSize(-1, -1, width, height);
         }
     }
             SetSize(-1, -1, width, height);
         }
     }

+#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------