Added script to help make wxMotif via configure; nativdlg sample works again;

[wxWidgets.git] / src / motif / window.cpp

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
index dffcfcc268fef8df60a791430ef77d271e18e380..9be496a55ae1bfe622f7ccc05b7ffa2d189a1158 100644 (file)
--- a/src/motif/window.cpp
+++ b/src/motif/window.cpp
@@ -31,7 +31,7 @@
 #include "wx/menuitem.h"
 #include "wx/log.h"
 
 #include "wx/menuitem.h"
 #include "wx/log.h"
 

-#if  USE_DRAG_AND_DROP
+#if  wxUSE_DRAG_AND_DROP

 #include "wx/dnd.h"
 #endif
 
 #include "wx/dnd.h"
 #endif
 


@@ -52,6 +52,8 @@ void wxCanvasRepaintProc (Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
 void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
 void wxCanvasMotionEvent (Widget, XButtonEvent * event);
 void wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
 void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
 void wxCanvasMotionEvent (Widget, XButtonEvent * event);
 void wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event);

+static void wxScrollBarCallback(Widget widget, XtPointer clientData,
+                        XmScaleCallbackStruct *cbs);

 void wxPanelItemEventHandler (Widget    wid,
                               XtPointer client_data,
                               XEvent*   event,
 void wxPanelItemEventHandler (Widget    wid,
                               XtPointer client_data,
                               XEvent*   event,


@@ -99,14 +101,15 @@ wxWindow::wxWindow()
     m_caretWidth = 0; m_caretHeight = 0;
     m_caretEnabled = FALSE;
     m_caretShown = FALSE;
     m_caretWidth = 0; m_caretHeight = 0;
     m_caretEnabled = FALSE;
     m_caretShown = FALSE;

-    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;

     m_foregroundColour = *wxBLACK;
     m_foregroundColour = *wxBLACK;

-    m_defaultForegroundColour = *wxBLACK ;
-    m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;

 
 

-#if  USE_DRAG_AND_DROP
+#if  wxUSE_DRAG_AND_DROP

     m_pDropTarget = NULL;
 #endif
     m_pDropTarget = NULL;
 #endif

+    m_clientObject = (wxClientData*) NULL;
+    m_clientData = NULL;

 
     /// Motif-specific
     m_mainWidget = (WXWidget) 0;
 
     /// Motif-specific
     m_mainWidget = (WXWidget) 0;


@@ -122,8 +125,6 @@ wxWindow::wxWindow()
     m_drawingArea = (WXWidget) 0;
     m_hScroll = FALSE;
     m_vScroll = FALSE;
     m_drawingArea = (WXWidget) 0;
     m_hScroll = FALSE;
     m_vScroll = FALSE;

-    m_hScrollingEnabled = FALSE;
-    m_vScrollingEnabled = FALSE;

     m_backingPixmap = (WXPixmap) 0;
     m_pixmapWidth = 0;
     m_pixmapHeight = 0;
     m_backingPixmap = (WXPixmap) 0;
     m_pixmapWidth = 0;
     m_pixmapHeight = 0;


@@ -132,72 +133,69 @@ wxWindow::wxWindow()
     m_lastTS = 0;
     m_lastButton = 0;
     m_canAddEventHandler = FALSE;
     m_lastTS = 0;
     m_lastButton = 0;
     m_canAddEventHandler = FALSE;

-    m_paintRegion = (WXRegion) 0;
+    m_scrollPosX = 0;
+    m_scrollPosY = 0;

 }
 
 // Destructor
 wxWindow::~wxWindow()
 {
 }
 
 // Destructor
 wxWindow::~wxWindow()
 {

-  //// Motif-specific
+    //// Motif-specific

 
 

-  if (m_paintRegion)
-    XDestroyRegion ((Region) m_paintRegion);
-  m_paintRegion = (WXRegion) 0;
-
-  if (GetMainWidget())
-    DetachWidget(GetMainWidget()); // Removes event handlers
+    if (GetMainWidget())
+        DetachWidget(GetMainWidget()); // Removes event handlers

 
 

-  // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
-  if (m_drawingArea)
-  {
-    // Destroy children before destroying self
-    DestroyChildren();
+    // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
+    if (m_drawingArea)
+    {
+        // Destroy children before destroying self
+        DestroyChildren();

 
 

-    if (m_backingPixmap)
-      XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
+        if (m_backingPixmap)
+        XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);

 
 

-    Widget w = (Widget) m_drawingArea;
-    wxDeleteWindowFromTable(w);
+        Widget w = (Widget) m_drawingArea;
+        wxDeleteWindowFromTable(w);

 
 

-    if (w)
-      XtDestroyWidget(w);
-    m_mainWidget = (WXWidget) 0;
+        if (w)
+            XtDestroyWidget(w);
+        m_mainWidget = (WXWidget) 0;

 
 

-    // Only if we're _really_ a canvas (not a dialog box/panel)
-    if (m_scrolledWindow)
-    {
-      wxDeleteWindowFromTable((Widget) m_scrolledWindow);
-    }
+        // Only if we're _really_ a canvas (not a dialog box/panel)
+        if (m_scrolledWindow)
+        {
+            wxDeleteWindowFromTable((Widget) m_scrolledWindow);
+        }

 
 

-    if (m_hScrollBar)
-    {
-      XtUnmanageChild ((Widget) m_hScrollBar);
-      XtDestroyWidget ((Widget) m_hScrollBar);
-    }
-    if (m_vScrollBar)
-    {
-      XtUnmanageChild ((Widget) m_vScrollBar);
-      XtDestroyWidget ((Widget) m_vScrollBar);
-    }
-    if (m_scrolledWindow)
-    {
-      XtUnmanageChild ((Widget) m_scrolledWindow);
-      XtDestroyWidget ((Widget) m_scrolledWindow);
-    }
+        if (m_hScrollBar)
+        {
+            XtUnmanageChild ((Widget) m_hScrollBar);
+            XtDestroyWidget ((Widget) m_hScrollBar);
+        }
+        if (m_vScrollBar)
+        {
+            XtUnmanageChild ((Widget) m_vScrollBar);
+            XtDestroyWidget ((Widget) m_vScrollBar);
+        }
+        if (m_scrolledWindow)
+        {
+            XtUnmanageChild ((Widget) m_scrolledWindow);
+            XtDestroyWidget ((Widget) m_scrolledWindow);
+        }

 
 

-    if (m_borderWidget)
-    {
-      XtDestroyWidget ((Widget) m_borderWidget);
-      m_borderWidget = (WXWidget) 0;
+        if (m_borderWidget)
+        {
+            XtDestroyWidget ((Widget) m_borderWidget);
+            m_borderWidget = (WXWidget) 0;
+        }

     }
     }

-  }

 
 

-  //// Generic stuff
+    //// Generic stuff

 
        // Have to delete constraints/sizer FIRST otherwise
        // sizers may try to look at deleted windows as they
        // delete themselves.
 
        // Have to delete constraints/sizer FIRST otherwise
        // sizers may try to look at deleted windows as they
        // delete themselves.

-#if USE_CONSTRAINTS
+#if wxUSE_CONSTRAINTS

     DeleteRelatedConstraints();
     if (m_constraints)
     {
     DeleteRelatedConstraints();
     if (m_constraints)
     {


@@ -238,8 +236,10 @@ wxWindow::~wxWindow()
     // dangling pointers.
     wxPendingDelete.DeleteObject(this);
 
     // dangling pointers.
     wxPendingDelete.DeleteObject(this);
 

-    if ( m_windowValidator )
-           delete m_windowValidator;
+    if ( m_windowValidator ) delete m_windowValidator;
+    if (m_clientObject) delete m_clientObject;
+
+    ClearUpdateRects();

 }
 
 // Destroy the window (delayed, if a managed window)
 }
 
 // Destroy the window (delayed, if a managed window)


@@ -269,7 +269,7 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     m_sizerParent = NULL;
     m_autoLayout = FALSE;
     m_windowValidator = NULL;
     m_sizerParent = NULL;
     m_autoLayout = FALSE;
     m_windowValidator = NULL;

-#if USE_DRAG_AND_DROP
+#if wxUSE_DRAG_AND_DROP

     m_pDropTarget = NULL;
 #endif
     m_caretWidth = 0; m_caretHeight = 0;
     m_pDropTarget = NULL;
 #endif
     m_caretWidth = 0; m_caretHeight = 0;


@@ -281,6 +281,8 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     m_maxSizeY = -1;
     m_defaultItem = NULL;
     m_windowParent = NULL;
     m_maxSizeY = -1;
     m_defaultItem = NULL;
     m_windowParent = NULL;

+    m_clientObject = (wxClientData*) NULL;
+    m_clientData = NULL;

 
     // Motif-specific
     m_canAddEventHandler = FALSE;
 
     // Motif-specific
     m_canAddEventHandler = FALSE;


@@ -297,14 +299,13 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     m_drawingArea = (WXWidget) 0;
     m_hScroll = FALSE;
     m_vScroll = FALSE;
     m_drawingArea = (WXWidget) 0;
     m_hScroll = FALSE;
     m_vScroll = FALSE;

-    m_hScrollingEnabled = FALSE;
-    m_vScrollingEnabled = FALSE;

     m_backingPixmap = (WXPixmap) 0;
     m_pixmapWidth = 0;
     m_pixmapHeight = 0;
     m_pixmapOffsetX = 0;
     m_pixmapOffsetY = 0;
     m_backingPixmap = (WXPixmap) 0;
     m_pixmapWidth = 0;
     m_pixmapHeight = 0;
     m_pixmapOffsetX = 0;
     m_pixmapOffsetY = 0;

-    m_paintRegion = (WXRegion) 0;
+    m_scrollPosX = 0;
+    m_scrollPosY = 0;

 
     if (!parent)
         return FALSE;
 
     if (!parent)
         return FALSE;


@@ -320,10 +321,9 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     else
        m_windowId = id;
 
     else
        m_windowId = id;
 

-    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;

     m_foregroundColour = *wxBLACK;
     m_foregroundColour = *wxBLACK;

-    m_defaultForegroundColour = *wxBLACK ;
-    m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;

 
     m_windowStyle = style;
 
 
     m_windowStyle = style;
 


@@ -419,7 +419,69 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
   XtAddEventHandler ((Widget) m_drawingArea, PointerMotionHintMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask,
     False, (XtEventHandler) wxCanvasEnterLeave, (XtPointer) this);
 
   XtAddEventHandler ((Widget) m_drawingArea, PointerMotionHintMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask,
     False, (XtEventHandler) wxCanvasEnterLeave, (XtPointer) this);
 

-    return TRUE;
+  // Add scrollbars if required
+  if (m_windowStyle & wxHSCROLL)
+  {
+      Widget hScrollBar = XtVaCreateManagedWidget ("hsb",
+                                    xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
+                                               XmNorientation, XmHORIZONTAL,
+                                               NULL);
+      //         XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+         XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+
+      XtVaSetValues (hScrollBar,
+                    XmNincrement, 1,
+                    XmNvalue, 0,
+                    NULL);
+
+      m_hScrollBar = (WXWidget) hScrollBar;
+      m_hScroll = TRUE;
+  }
+  if (m_windowStyle & wxVSCROLL)
+  {
+      Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
+                                    xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
+                                               XmNorientation, XmVERTICAL,
+                                               NULL);
+      //         XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+         XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+
+      XtVaSetValues (vScrollBar,
+                    XmNincrement, 1,
+                    XmNvalue, 0,
+                    NULL);
+
+      m_vScrollBar = (WXWidget) vScrollBar;
+      m_vScroll = TRUE;
+  }
+
+  if (m_hScrollBar || m_vScrollBar)
+    XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
+
+  if (m_hScrollBar)
+       XtRealizeWidget ((Widget) m_hScrollBar);
+  if (m_vScrollBar)
+       XtRealizeWidget ((Widget) m_vScrollBar);
+
+  // Without this, the cursor may not be restored properly
+  // (e.g. in splitter sample).
+  SetCursor(*wxSTANDARD_CURSOR);
+  SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+  SetSize(pos.x, pos.y, size.x, size.y);
+
+  return TRUE;

 }
 
 void wxWindow::SetFocus()
 }
 
 void wxWindow::SetFocus()


@@ -486,7 +548,7 @@ wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
                return NULL;
 }
 
                return NULL;
 }
 

-#if    USE_DRAG_AND_DROP
+#if    wxUSE_DRAG_AND_DROP

 
 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 {
 
 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 {


@@ -526,20 +588,39 @@ void wxWindow::GetSize(int *x, int *y) const
 
 void wxWindow::GetPosition(int *x, int *y) const
 {
 
 void wxWindow::GetPosition(int *x, int *y) const
 {

-  if (m_drawingArea)
-  {
-    CanvasGetPosition(x, y);
-    return;
-  }
-  Widget widget = (Widget) GetTopWidget();
-  Position xx, yy;
-  XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
-  *x = xx; *y = yy;
+    if (m_drawingArea)
+    {
+        CanvasGetPosition(x, y);
+        return;
+    }
+    Widget widget = (Widget) GetTopWidget();
+    Position xx, yy;
+    XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
+
+    // We may be faking the client origin.
+    // So a window that's really at (0, 30) may appear
+    // (to wxWin apps) to be at (0, 0).
+    if (GetParent())
+    {
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        xx -= pt.x;
+        yy -= pt.y;
+    }
+
+    *x = xx; *y = yy;

 }
 
 void wxWindow::ScreenToClient(int *x, int *y) const
 {
 }
 
 void wxWindow::ScreenToClient(int *x, int *y) const
 {

-    // TODO
+  Widget widget = (Widget) GetClientWidget();
+  Display *display = XtDisplay((Widget) GetMainWidget());
+  Window rootWindow = RootWindowOfScreen(XtScreen(widget));
+  Window thisWindow = XtWindow(widget);
+
+  Window childWindow;
+  int xx = *x;
+  int yy = *y;
+  XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);

 }
 
 void wxWindow::ClientToScreen(int *x, int *y) const
 }
 
 void wxWindow::ClientToScreen(int *x, int *y) const


@@ -547,15 +628,7 @@ void wxWindow::ClientToScreen(int *x, int *y) const
   Widget widget = (Widget) GetClientWidget();
   Display *display = XtDisplay(widget);
   Window rootWindow = RootWindowOfScreen(XtScreen(widget));
   Widget widget = (Widget) GetClientWidget();
   Display *display = XtDisplay(widget);
   Window rootWindow = RootWindowOfScreen(XtScreen(widget));

-  Window thisWindow;
-  if (this->IsKindOf(CLASSINFO(wxFrame)))
-  {
-    wxFrame *fr = (wxFrame *)this;
-    // TODO
-    //    thisWindow = XtWindow(fr->m_clientArea);
-  }
-  else
-    thisWindow = XtWindow((Widget)widget);
+  Window thisWindow = XtWindow(widget);

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


@@ -568,14 +641,12 @@ void wxWindow::SetCursor(const wxCursor& cursor)
   m_windowCursor = cursor;
   if (m_windowCursor.Ok())
   {
   m_windowCursor = cursor;
   if (m_windowCursor.Ok())
   {

-    /* TODO when wxCursor implemented

     WXDisplay *dpy = GetXDisplay();
     WXDisplay *dpy = GetXDisplay();

-    Cursor x_cursor = cursor.GetXCursor(dpy);
+    WXCursor x_cursor = ((wxCursor&)cursor).GetXCursor(dpy);

 
     Widget w = (Widget) GetMainWidget();
     Window win = XtWindow(w);
 
     Widget w = (Widget) GetMainWidget();
     Window win = XtWindow(w);

-    XDefineCursor((Display*) dpy, win, x_cursor);
-    */
+    XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);

   }
 }
 
   }
 }
 


@@ -583,7 +654,7 @@ void wxWindow::SetCursor(const wxCursor& cursor)
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 void wxWindow::GetClientSize(int *x, int *y) const
 {
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 void wxWindow::GetClientSize(int *x, int *y) const
 {

-  Widget widget = (Widget) GetTopWidget();
+  Widget widget = (Widget) GetClientWidget();

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


@@ -591,6 +662,27 @@ void wxWindow::GetClientSize(int *x, int *y) const
 
 void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
 {
 
 void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
 {

+  // A bit of optimization to help sort out the flickers.
+  int oldX, oldY, oldW, oldH;
+  GetSize(& oldW, & oldH);
+  GetPosition(& oldX, & oldY);
+
+  bool useOldPos = FALSE;
+  bool useOldSize = FALSE;
+
+  if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
+    useOldPos = TRUE;
+  else if (x == oldX && y == oldY)
+    useOldPos = TRUE;
+
+  if ((width == -1) && (height == -1))
+    useOldSize = TRUE;
+  else if (width == oldW && height == oldH)
+    useOldSize = TRUE;
+
+  if (useOldPos && useOldSize)
+    return;
+

   if (m_drawingArea)
   {
     CanvasSetSize(x, y, width, height, sizeFlags);
   if (m_drawingArea)
   {
     CanvasSetSize(x, y, width, height, sizeFlags);


@@ -604,22 +696,35 @@ void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
   if (managed)
     XtUnmanageChild(widget);
 
   if (managed)
     XtUnmanageChild(widget);
 

-  if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-    XtVaSetValues(widget, XmNx, x, NULL);
-  if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-    XtVaSetValues(widget, XmNy, y, NULL);
-  if (width > -1)
-    XtVaSetValues(widget, XmNwidth, width, NULL);
-  if (height > -1)
-    XtVaSetValues(widget, XmNheight, height, NULL);
+  int xx = x; int yy = y;
+  AdjustForParentClientOrigin(xx, yy, sizeFlags);
+
+  if (!useOldPos)
+  {
+    if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+      XtVaSetValues(widget, XmNx, xx, NULL);
+    if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+      XtVaSetValues(widget, XmNy, yy, NULL);
+  }
+  if (!useOldSize)
+  {
+    if (width > -1)
+      XtVaSetValues(widget, XmNwidth, width, NULL);
+    if (height > -1)
+      XtVaSetValues(widget, XmNheight, height, NULL);
+  }

 
   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.
+  /*

   wxSizeEvent sizeEvent(wxSize(width, height), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);
   wxSizeEvent sizeEvent(wxSize(width, height), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);

+  */

 }
 
 void wxWindow::SetClientSize(int width, int height)
 }
 
 void wxWindow::SetClientSize(int width, int height)


@@ -667,22 +772,33 @@ bool wxWindow::Show(bool show)
     {
        if (m_borderWidget || m_scrolledWindow)
        {
     {
        if (m_borderWidget || m_scrolledWindow)
        {

+           if (m_drawingArea)
+             XtMapWidget((Widget) m_drawingArea);

            XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
        }
        else
        {
            XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
        }
        else
        {

-           XtMapWidget((Widget) GetTopWidget());
+           WXWidget topWidget = GetTopWidget();
+           if (GetTopWidget())
+             XtMapWidget((Widget) GetTopWidget());
+           else if (GetMainWidget())
+             XtMapWidget((Widget) GetMainWidget());

        }
     }
     else
     {
        if (m_borderWidget || m_scrolledWindow)
        {
        }
     }
     else
     {
        if (m_borderWidget || m_scrolledWindow)
        {

+           if (m_drawingArea)
+             XtUnmapWidget((Widget) m_drawingArea);

            XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
        }
        else
        {
            XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
        }
        else
        {

-           XtUnmapWidget((Widget) GetTopWidget());
+           if (GetTopWidget())
+             XtUnmapWidget((Widget) GetTopWidget());
+           else if (GetMainWidget())
+             XtUnmapWidget((Widget) GetMainWidget());

        }
     }
 
        }
     }
 


@@ -707,27 +823,80 @@ bool wxWindow::IsShown() const
 
 int wxWindow::GetCharHeight() const
 {
 
 int wxWindow::GetCharHeight() const
 {

-    // TODO
+  if (!m_windowFont.Ok())

     return 0;
     return 0;

+
+  WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
+
+  int direction, ascent, descent;
+  XCharStruct overall;
+  XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+//  return (overall.ascent + overall.descent);
+  return (ascent + descent);

 }
 
 int wxWindow::GetCharWidth() const
 {
 }
 
 int wxWindow::GetCharWidth() const
 {

-    // TODO
+  if (!m_windowFont.Ok())

     return 0;
     return 0;

+
+  WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
+
+  int direction, ascent, descent;
+  XCharStruct overall;
+  XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+  return overall.width;
+}
+
+/* Helper function for 16-bit fonts */
+static int str16len(const char *s)
+{
+  int count = 0;
+
+  while (s[0] && s[1]) {
+    count++;
+    s += 2;
+  }
+
+  return count;

 }
 
 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 }
 
 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,

-                           int *descent, int *externalLeading, const wxFont *theFont, bool) const
+                           int *descent, int *externalLeading, const wxFont *theFont, bool use16) const

 {
   wxFont *fontToUse = (wxFont *)theFont;
   if (!fontToUse)
     fontToUse = (wxFont *) & m_windowFont;
 
 {
   wxFont *fontToUse = (wxFont *)theFont;
   if (!fontToUse)
     fontToUse = (wxFont *) & m_windowFont;
 

-    // TODO
+  if (!fontToUse->Ok())
+    return;
+
+  WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
+
+  int direction, ascent, descent2;
+  XCharStruct overall;
+  int slen;
+  
+  if (use16) slen = str16len(string); else slen = strlen(string);
+
+  if (use16)
+    XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
+           &ascent, &descent2, &overall);
+  else
+     XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
+         &ascent, &descent2, &overall);
+
+  *x = (overall.width);
+  *y = (ascent + descent2);
+  if (descent)
+    *descent = descent2;
+  if (externalLeading)
+    *externalLeading = 0;

 }
 
 }
 

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

 {
     Display *display = XtDisplay((Widget) GetMainWidget());
     Window thisWindow = XtWindow((Widget) GetMainWidget());
 {
     Display *display = XtDisplay((Widget) GetMainWidget());
     Window thisWindow = XtWindow((Widget) GetMainWidget());


@@ -759,7 +928,12 @@ void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
     if (eraseBack)
     {
         wxClientDC dc(this);
     if (eraseBack)
     {
         wxClientDC dc(this);

-        dc.Clear();
+        wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
+        dc.SetBackground(backgroundBrush);
+        if (rect)
+          dc.Clear(*rect);
+        else
+          dc.Clear();

     }
 
     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
     }
 
     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);


@@ -768,7 +942,7 @@ void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
 // Responds to colour changes: passes event on to children.
 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 {
 // Responds to colour changes: passes event on to children.
 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 {

-    wxNode *node = GetChildren()->First();
+    wxNode *node = GetChildren().First();

     while ( node )
     {
         // Only propagate to non-top-level windows
     while ( node )
     {
         // Only propagate to non-top-level windows


@@ -856,21 +1030,20 @@ void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, in
       return;
 
     wxFrame *frame = (wxFrame *)this;
       return;
 
     wxFrame *frame = (wxFrame *)this;

+    Widget widget = (Widget) frame->GetShellWidget();

 
 

-    /* Uncomment when wxFrame implemented

     if (minW > -1)
     if (minW > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNminWidth, minW, NULL);
+      XtVaSetValues(widget, XmNminWidth, minW, NULL);

     if (minH > -1)
     if (minH > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNminHeight, minH, NULL);
+      XtVaSetValues(widget, XmNminHeight, minH, NULL);

     if (maxW > -1)
     if (maxW > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNmaxWidth, maxW, NULL);
+      XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);

     if (maxH > -1)
     if (maxH > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNmaxHeight, maxH, NULL);
+      XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);

     if (incW > -1)
     if (incW > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNwidthInc, incW, NULL);
+      XtVaSetValues(widget, XmNwidthInc, incW, NULL);

     if (incH > -1)
     if (incH > -1)

-      XtVaSetValues((Widget) frame->m_frameShell, XmNheightInc, incH, NULL);
-      */
+      XtVaSetValues(widget, XmNheightInc, incH, NULL);

 }
 
 void wxWindow::Centre(int direction)
 }
 
 void wxWindow::Centre(int direction)


@@ -912,51 +1085,255 @@ void wxWindow::OnEraseBackground(wxEraseEvent& event)
 
 int wxWindow::GetScrollPos(int orient) const
 {
 
 int wxWindow::GetScrollPos(int orient) const
 {

-    // TODO
-    return 0;
+    if (orient == wxHORIZONTAL)
+        return m_scrollPosX;
+    else
+        return m_scrollPosY;
+/*
+       Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
+       if (scrollBar)
+       {
+        int pos;
+        XtVaGetValues(scrollBar,
+            XmNvalue, &pos, NULL);
+        return pos;
+    }
+    else
+        return 0;
+*/

 }
 
 // This now returns the whole range, not just the number
 // of positions that we can scroll.
 int wxWindow::GetScrollRange(int orient) const
 {
 }
 
 // This now returns the whole range, not just the number
 // of positions that we can scroll.
 int wxWindow::GetScrollRange(int orient) const
 {

-    // TODO
-    return 0;
+       Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
+       if (scrollBar)
+       {
+        int range;
+        XtVaGetValues(scrollBar,
+            XmNmaximum, &range, NULL);
+        return range;
+    }
+    else
+        return 0;

 }
 
 int wxWindow::GetScrollThumb(int orient) const
 {
 }
 
 int wxWindow::GetScrollThumb(int orient) const
 {

-    // TODO
-    return 0;
+       Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
+       if (scrollBar)
+       {
+        int thumb;
+        XtVaGetValues(scrollBar,
+            XmNsliderSize, &thumb, NULL);
+        return thumb;
+    }
+    else
+        return 0;

 }
 
 }
 

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

 {
 {

-    // TODO
-    return;
+       Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
+       if (scrollBar)
+       {
+               XtVaSetValues (scrollBar,
+                               XmNvalue, pos,
+                               NULL);
+       }
+        if (orient == wxHORIZONTAL)
+          m_scrollPosX = pos;
+        else
+          m_scrollPosY = pos;
+

 }
 
 // New function that will replace some of the above.
 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
 }
 
 // New function that will replace some of the above.
 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,

-    int range, bool refresh)
+    int range, bool WXUNUSED(refresh))

 {
 {

-    // TODO
+    Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
+    if (!scrollBar)
+        return;
+
+    if (range == 0)
+      range = 1;
+    if (thumbVisible == 0)
+      thumbVisible = 1;
+
+    XtVaSetValues(scrollBar,
+         XmNvalue, pos,
+         XmNminimum, 0,
+         XmNmaximum, range,
+         XmNsliderSize, thumbVisible,
+         NULL);
+
+    if (orient == wxHORIZONTAL)
+        m_scrollPosX = pos;
+    else
+        m_scrollPosY = pos;

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

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

 {
 {

-    // TODO
-    return;
-}
+//  cerr << "Scrolling. delta = " << dx << ", " << dy << endl;
+  int x, y, w, h;
+  if (rect)
+  {
+    // Use specified rectangle
+    x = rect->x; y = rect->y; w = rect->width; h = rect->height;
+  }
+  else
+  {
+    // Use whole client area
+    x = 0; y = 0;
+    GetClientSize(& w, & h);
+  }

 
 

-void wxWindow::SetFont(const wxFont& font)
-{
-    m_windowFont = font;
+  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);
+
+  dc.SetLogicalFunction (wxCOPY);
+
+  Widget widget = (Widget) GetMainWidget();
+  Window window = XtWindow(widget);
+  Display* display = XtDisplay(widget);
+
+  XCopyArea(display, window,
+    window, (GC) dc.GetGC(),
+    x1, y1,
+    w1, h1,
+    x2, y2);
+
+  dc.SetAutoSetting(TRUE);
+  wxBrush brush(GetBackgroundColour(), wxSOLID);
+  dc.SetBrush(brush); // ??
+
+  // We'll add rectangles to the list of update rectangles
+  // according to which bits we've exposed.
+  wxList updateRects;
+       
+  if (dx > 0)
+  {
+    wxRect *rect = new wxRect;
+    rect->x = x;
+    rect->y = y;
+    rect->width = dx;
+    rect->height = h;
+
+    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;
+
+    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;
+
+    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;
+
+    updateRects.Append((wxObject*) rect);
+  }
+  if (dy > 0)
+  {
+    wxRect *rect = new wxRect;
+
+    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);
+
+    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;
+
+    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);
+
+    rect->x = rect->x;
+    rect->y = rect->y;
+    rect->width = rect->width;
+    rect->height = rect->height;
+
+    updateRects.Append((wxObject*) rect);
+  }
+  dc.SetBrush(wxNullBrush);
+
+  // Now send expose events
+
+  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.x = rect->x;
+    event.y = rect->y;
+    event.width = rect->width;
+    event.height = rect->height;
+
+    event.count = 0;
+
+    XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
+
+    node = node->Next();
+
+  }
+
+  // Delete the update rects
+  node = updateRects.First();
+  while (node)
+  {
+    wxRect* rect = (wxRect*) node->Data();
+    delete rect;
+    node = node->Next();
+  }

 
 

-    if (!m_windowFont.Ok())
-           return;
-    // TODO

 }
 
 void wxWindow::OnChar(wxKeyEvent& event)
 }
 
 void wxWindow::OnChar(wxKeyEvent& event)


@@ -978,7 +1355,8 @@ void wxWindow::OnPaint(wxPaintEvent& event)
 
 bool wxWindow::IsEnabled() const
 {
 
 bool wxWindow::IsEnabled() const
 {

-    // TODO
+    // TODO. Is this right?
+    // return XtGetSensitive((Widget) GetMainWidget());

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -993,7 +1371,7 @@ bool wxWindow::IsEnabled() const
 // it's an application error (pops up a dialog)
 bool wxWindow::TransferDataToWindow()
 {
 // it's an application error (pops up a dialog)
 bool wxWindow::TransferDataToWindow()
 {

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();


@@ -1013,7 +1391,7 @@ bool wxWindow::TransferDataToWindow()
 // validation failed: don't quit
 bool wxWindow::TransferDataFromWindow()
 {
 // validation failed: don't quit
 bool wxWindow::TransferDataFromWindow()
 {

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();


@@ -1029,7 +1407,7 @@ bool wxWindow::TransferDataFromWindow()
 
 bool wxWindow::Validate()
 {
 
 bool wxWindow::Validate()
 {

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();


@@ -1052,30 +1430,45 @@ wxWindow *wxWindow::FindFocus()
 
 void wxWindow::AddChild(wxWindow *child)
 {
 
 void wxWindow::AddChild(wxWindow *child)
 {

-    GetChildren()->Append(child);
+    GetChildren().Append(child);

     child->m_windowParent = this;
 }
 
 void wxWindow::RemoveChild(wxWindow *child)
 {
     child->m_windowParent = this;
 }
 
 void wxWindow::RemoveChild(wxWindow *child)
 {

-    if (GetChildren())
-        GetChildren()->DeleteObject(child);
+    GetChildren().DeleteObject(child);

     child->m_windowParent = NULL;
 }
 
     child->m_windowParent = NULL;
 }
 

+// Reparents this window to have the new parent.
+bool wxWindow::Reparent(wxWindow* WXUNUSED(parent))
+{
+    // For now, we indicate that this isn't implemented.
+    return FALSE;
+}
+

 void wxWindow::DestroyChildren()
 {
 void wxWindow::DestroyChildren()
 {

-  if (GetChildren()) {
+    wxNode *node = GetChildren().First();
+    while (node)
+    {
+      wxNode* next = node->Next();
+      wxWindow* child = (wxWindow*) node->Data();
+      delete child;
+      node = next;
+    }
+    GetChildren().Clear();
+#if 0

     wxNode *node;
     wxNode *node;

-    while ((node = GetChildren()->First()) != (wxNode *)NULL) {
+    while ((node = GetChildren().First()) != (wxNode *)NULL) {

       wxWindow *child;
       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
         delete child;
       wxWindow *child;
       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
         delete child;

-               if ( GetChildren()->Member(child) )
+               if ( GetChildren().Member(child) )

                        delete node;
       }
     } /* while */
                        delete node;
       }
     } /* while */

-  }
+#endif

 }
 
 void wxWindow::MakeModal(bool modal)
 }
 
 void wxWindow::MakeModal(bool modal)


@@ -1290,7 +1683,7 @@ bool wxWindow::DoPhase(int phase)
   {
     noChanges = 0;
     noFailures = 0;
   {
     noChanges = 0;
     noFailures = 0;

-    wxNode *node = GetChildren()->First();
+    wxNode *node = GetChildren().First();

     while (node)
     {
       wxWindow *child = (wxWindow *)node->Data();
     while (node)
     {
       wxWindow *child = (wxWindow *)node->Data();


@@ -1335,7 +1728,7 @@ void wxWindow::ResetConstraints()
     constr->centreX.SetDone(FALSE);
     constr->centreY.SetDone(FALSE);
   }
     constr->centreX.SetDone(FALSE);
     constr->centreY.SetDone(FALSE);
   }

-  wxNode *node = GetChildren()->First();
+  wxNode *node = GetChildren().First();

   while (node)
   {
     wxWindow *win = (wxWindow *)node->Data();
   while (node)
   {
     wxWindow *win = (wxWindow *)node->Data();


@@ -1394,7 +1787,7 @@ void wxWindow::SetConstraintSizes(bool recurse)
 
   if (recurse)
   {
 
   if (recurse)
   {

-    wxNode *node = GetChildren()->First();
+    wxNode *node = GetChildren().First();

     while (node)
     {
       wxWindow *win = (wxWindow *)node->Data();
     while (node)
     {
       wxWindow *win = (wxWindow *)node->Data();


@@ -1531,9 +1924,7 @@ bool wxWindow::Close(bool force)
 wxObject* wxWindow::GetChild(int number) const
 {
   // Return a pointer to the Nth object in the window
 wxObject* wxWindow::GetChild(int number) const
 {
   // Return a pointer to the Nth object in the window

-  if (!GetChildren())
-    return(NULL) ;
-  wxNode *node = GetChildren()->First();
+  wxNode *node = GetChildren().First();

   int n = number;
   while (node && n--)
     node = node->Next() ;
   int n = number;
   while (node && n--)
     node = node->Next() ;


@@ -1553,7 +1944,7 @@ void wxWindow::OnDefaultAction(wxControl *initiatingItem)
 
 void wxWindow::Clear()
 {
 
 void wxWindow::Clear()
 {

-       wxClientDC dc(this);
+    wxClientDC dc(this);

     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBackground(brush);
     dc.Clear();
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBackground(brush);
     dc.Clear();


@@ -1564,7 +1955,7 @@ void wxWindow::Fit()
 {
        int maxX = 0;
        int maxY = 0;
 {
        int maxX = 0;
        int maxY = 0;

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *win = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *win = (wxWindow *)node->Data();


@@ -1591,13 +1982,34 @@ void wxWindow::SetValidator(const wxValidator& validator)
                m_windowValidator->SetWindow(this) ;
 }
 
                m_windowValidator->SetWindow(this) ;
 }
 

+void wxWindow::SetClientObject( wxClientData *data )
+{
+  if (m_clientObject) delete m_clientObject;
+  m_clientObject = data;
+}
+
+wxClientData *wxWindow::GetClientObject()
+{
+  return m_clientObject;
+}
+
+void wxWindow::SetClientData( void *data )
+{
+  m_clientData = data;
+}
+
+void *wxWindow::GetClientData()
+{
+  return m_clientData;
+}
+

 // Find a window by id or name
 wxWindow *wxWindow::FindWindow(long id)
 {
        if ( GetId() == id)
                return this;
 
 // Find a window by id or name
 wxWindow *wxWindow::FindWindow(long id)
 {
        if ( GetId() == id)
                return this;
 

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();


@@ -1614,7 +2026,7 @@ wxWindow *wxWindow::FindWindow(const wxString& name)
        if ( GetName() == name)
                return this;
 
        if ( GetName() == name)
                return this;
 

-       wxNode *node = GetChildren()->First();
+       wxNode *node = GetChildren().First();

        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();
        while ( node )
        {
                wxWindow *child = (wxWindow *)node->Data();


@@ -1628,26 +2040,9 @@ wxWindow *wxWindow::FindWindow(const wxString& name)
 
 void wxWindow::OnIdle(wxIdleEvent& event)
 {
 
 void wxWindow::OnIdle(wxIdleEvent& event)
 {

-/* TODO: you may need to do something like this
- * if your GUI doesn't generate enter/leave events
-
-    // Check if we need to send a LEAVE event
-    if (m_mouseInWindow)
-    {
-        POINT pt;
-        ::GetCursorPos(&pt);
-        if (::WindowFromPoint(pt) != (HWND) GetHWND())
-        {
-            // Generate a LEAVE event
-            m_mouseInWindow = FALSE;
-            MSWOnMouseLeave(pt.x, pt.y, 0);
-        }
-    }
-*/
-

     // 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)

-       UpdateWindowUI();
+    UpdateWindowUI();

 }
 
 // Raise the window to the top of the Z order
 }
 
 // Raise the window to the top of the Z order


@@ -1670,9 +2065,9 @@ bool wxWindow::AcceptsFocus() const
 }
 
 // Update region access
 }
 
 // Update region access

-wxRegion wxWindow::GetUpdateRegion() const
+wxRegion& wxWindow::GetUpdateRegion() const

 {
 {

-    return m_updateRegion;
+    return (wxRegion&) m_updateRegion;

 }
 
 bool wxWindow::IsExposed(int x, int y, int w, int h) const
 }
 
 bool wxWindow::IsExposed(int x, int y, int w, int h) const


@@ -1727,9 +2122,7 @@ void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *nu
 bool wxAddWindowToTable(Widget w, wxWindow *win)
 {
   wxWindow *oldItem = NULL;
 bool wxAddWindowToTable(Widget w, wxWindow *win)
 {
   wxWindow *oldItem = NULL;

-#if DEBUG

 //  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
 //  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());

-#endif

   if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
   {
     char buf[300];
   if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
   {
     char buf[300];


@@ -1791,75 +2184,41 @@ void wxCanvasRepaintProc (Widget drawingArea, XtPointer clientData,
  XmDrawingAreaCallbackStruct * cbs)
 {
     if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))
  XmDrawingAreaCallbackStruct * cbs)
 {
     if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))

-       return;
+           return;

 
     XEvent * event = cbs->event;
 
     XEvent * event = cbs->event;

-    wxWindow * canvas = (wxWindow *) clientData;
-    Display * display = (Display *) canvas->GetXDisplay();
-    //    GC gc = (GC) canvas->GetDC()->gc;
+    wxWindow * win = (wxWindow *) clientData;
+    Display * display = (Display *) win->GetXDisplay();

 
     switch (event->type)
     {
 
     switch (event->type)
     {

-      case Expose:
-      {
-       /* TODO
-        wxCanvasDC* canvasDC = canvas->GetDC();
-        if (canvasDC)
-       {
-          if (canvasDC->onpaint_reg)
-            XDestroyRegion(canvasDC->onpaint_reg);
-          canvasDC->onpaint_reg = XCreateRegion();
-          
-       }
-       */
-
-       int n = canvas->m_updateRects.Number();
-        XRectangle* xrects = new XRectangle[n];
-        int i;
-       for (i = 0; i < canvas->m_updateRects.Number(); i++)
-       {
-         wxRect* rect = (wxRect*) canvas->m_updateRects.Nth(i)->Data();
-         xrects[i].x = rect->x;
-          xrects[i].y = rect->y;
-          xrects[i].width = rect->width;
-          xrects[i].height = rect->height;
-         /* TODO (?) Actually ignore it I think.
-          if (canvasDC)
-            XUnionRectWithRegion(&(xrects[i]), canvasDC->onpaint_reg,
-              canvasDC->onpaint_reg);
-      */
-       }
-       /* TODO must clip the area being repainted. So we need a gc.
-         * Alternatively, wxPaintDC must do the clipping
-         * when it's created.
-        XSetClipRectangles(display, gc, 0, 0, xrects, n, Unsorted);
-       */
-
-        canvas->DoPaint() ; // xrects, n);
-        delete[] xrects;
-
-        canvas->m_updateRects.Clear();
+        case Expose:
+        {
+            wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
+                                       event->xexpose.width, event->xexpose.height);
+           /*
+            cout << "Expose proc. wxRect: " << rect->x << ", " << rect->y << ", ";
+            cout << rect->width << ", " << rect->height << "\n\n";
+           */

 
 

-       /*
-        if (canvasDC)
-       {
-          XDestroyRegion(canvasDC->onpaint_reg);
-          canvasDC->onpaint_reg = NULL;
-       }
+            win->m_updateRects.Append((wxObject*) rect);

 
 

-       XGCValues gc_val;
-       gc_val.clip_mask = None;
-       XChangeGC(display, gc, GCClipMask, &gc_val);
-       */
+            if (event -> xexpose.count == 0)
+            {
+                wxPaintEvent event(win->GetId());
+                event.SetEventObject(win);
+                win->GetEventHandler()->ProcessEvent(event);

 
 

-       break;
-    }
-    default:
-    {
-       cout << "\n\nNew Event ! is = " << event -> type << "\n";
-       break;
+                win->ClearUpdateRects();
+            }
+            break;
+        }
+        default:
+        {
+               cout << "\n\nNew Event ! is = " << event -> type << "\n";
+               break;
+        }

     }
     }

-  }

 }
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
 }
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)


@@ -1911,6 +2270,30 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
 
   local_event = *(cbs->event); // We must keep a copy!
 
 
   local_event = *(cbs->event); // We must keep a copy!
 

+  /*
+  switch (local_event.xany.type)
+    {
+    case EnterNotify:
+      cout << "EnterNotify\n";
+      break;
+    case LeaveNotify:
+      cout << "LeaveNotify\n";
+      break;
+    case ButtonPress:
+      cout << "ButtonPress\n";
+      break;
+    case ButtonRelease:
+      cout << "ButtonRelease\n";
+      break;
+    case MotionNotify:
+      cout << "MotionNotify\n";
+      break;
+    default:
+      cout << "Something else\n";
+      break;
+  }
+  */
+

   switch (local_event.xany.type)
     {
     case EnterNotify:
   switch (local_event.xany.type)
     {
     case EnterNotify:


@@ -2058,6 +2441,8 @@ void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallba
 
         wxevent.SetId(canvas->GetId());
         wxevent.SetEventObject(canvas);
 
         wxevent.SetId(canvas->GetId());
         wxevent.SetEventObject(canvas);

+        wxevent.m_x = local_event.xbutton.x;
+        wxevent.m_y = local_event.xbutton.y;

        canvas->GetEventHandler()->ProcessEvent (wxevent);
        /*
        if (eventType == wxEVT_ENTER_WINDOW ||
        canvas->GetEventHandler()->ProcessEvent (wxevent);
        /*
        if (eventType == wxEVT_ENTER_WINDOW ||


@@ -2165,6 +2550,27 @@ void wxWindow::DoPaint()
 // SetSize, but as per old wxCanvas (with drawing widget etc.)
 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
 {
 // SetSize, but as per old wxCanvas (with drawing widget etc.)
 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
 {

+  // A bit of optimization to help sort out the flickers.
+  int oldX, oldY, oldW, oldH;
+  GetSize(& oldW, & oldH);
+  GetPosition(& oldX, & oldY);
+
+  bool useOldPos = FALSE;
+  bool useOldSize = FALSE;
+
+  if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
+    useOldPos = TRUE;
+  else if (x == oldX && y == oldY)
+    useOldPos = TRUE;
+
+  if ((w == -1) && (h == -1))
+    useOldSize = TRUE;
+  else if (w == oldW && h == oldH)
+    useOldSize = TRUE;
+
+  if (useOldPos && useOldSize)
+    return;
+

   Widget drawingArea = (Widget) m_drawingArea;
   bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 
   Widget drawingArea = (Widget) m_drawingArea;
   bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 


@@ -2172,19 +2578,28 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
     XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
 
     XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
 

-  if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+  int xx = x; int yy = y;
+  AdjustForParentClientOrigin(xx, yy, sizeFlags);
+
+  if (!useOldPos)
+  {
+    if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))

     {
       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
     {
       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,

-                    XmNx, x, NULL);
+                    XmNx, xx, NULL);

     }
 
     }
 

-  if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+    if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))

     {
       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
     {
       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,

-                    XmNy, y, NULL);
+                    XmNy, yy, NULL);

     }
     }

+  }

 
 

-  if (w > -1)
+  if (!useOldSize)
+  {
+
+    if (w > -1)

     {
       if (m_borderWidget)
        {
     {
       if (m_borderWidget)
        {


@@ -2246,16 +2661,21 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
 
       XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
     }
 
       XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
     }

+  }
+

   if (managed)
     XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
 
   if (managed)
     XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
 

+  /*

   int ww, hh;
   GetClientSize (&ww, &hh);
   wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);
   int ww, hh;
   GetClientSize (&ww, &hh);
   wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);

+  */
+

 }
 
 void wxWindow::CanvasSetClientSize (int w, int h)
 }
 
 void wxWindow::CanvasSetClientSize (int w, int h)


@@ -2288,10 +2708,12 @@ void wxWindow::CanvasSetClientSize (int w, int h)
   DoRefresh ();
   */
 
   DoRefresh ();
   */
 

+  /*

   wxSizeEvent sizeEvent(wxSize(w, h), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);
   wxSizeEvent sizeEvent(wxSize(w, h), GetId());
   sizeEvent.SetEventObject(this);
   
   GetEventHandler()->ProcessEvent(sizeEvent);

+  */

 }
 
 void wxWindow::CanvasGetClientSize (int *w, int *h) const
 }
 
 void wxWindow::CanvasGetClientSize (int *w, int *h) const


@@ -2319,10 +2741,21 @@ void wxWindow::CanvasGetSize (int *w, int *h) const
 
 void wxWindow::CanvasGetPosition (int *x, int *y) const
 {
 
 void wxWindow::CanvasGetPosition (int *x, int *y) const
 {

-  Position xx, yy;
-  XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
-  *x = xx;
-  *y = yy;
+    Position xx, yy;
+    XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
+
+    // We may be faking the client origin.
+    // So a window that's really at (0, 30) may appear
+    // (to wxWin apps) to be at (0, 0).
+    if (GetParent())
+    {
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        xx -= pt.x;
+        yy -= pt.y;
+    }
+
+    *x = xx;
+    *y = yy;

 }
 
 // Add to hash table, add event handler
 }
 
 // Add to hash table, add event handler


@@ -2413,6 +2846,74 @@ void wxPanelItemEventHandler (Widget    wid,
   *continueToDispatch = True;
 }
 
   *continueToDispatch = True;
 }
 

+static void wxScrollBarCallback(Widget scrollbar, XtPointer clientData,
+                        XmScaleCallbackStruct *cbs)
+{
+    Widget scrolledWindow = XtParent (scrollbar);
+    wxWindow *win = (wxWindow *) wxWidgetHashTable->Get ((long) scrolledWindow);
+    int orientation = (int) clientData;
+
+    wxEventType eventType = wxEVT_NULL;
+    switch (cbs->reason)
+    {
+        case XmCR_INCREMENT:
+        {
+            eventType = wxEVT_SCROLL_LINEDOWN;
+            break;
+        }
+        case XmCR_DECREMENT:
+        {
+            eventType = wxEVT_SCROLL_LINEUP;
+            break;
+        }
+        case XmCR_DRAG:
+        {
+            eventType = wxEVT_SCROLL_THUMBTRACK;
+            break;
+        }
+        case XmCR_VALUE_CHANGED:
+        {
+            // TODO: Should this be intercepted too, or will it cause
+            // duplicate events?
+            eventType = wxEVT_SCROLL_THUMBTRACK;
+            break;
+        }
+        case XmCR_PAGE_INCREMENT:
+        {
+            eventType = wxEVT_SCROLL_PAGEDOWN;
+            break;
+        }
+        case XmCR_PAGE_DECREMENT:
+        {
+            eventType = wxEVT_SCROLL_PAGEUP;
+            break;
+        }
+        case XmCR_TO_TOP:
+        {
+            eventType = wxEVT_SCROLL_TOP;
+            break;
+        }
+        case XmCR_TO_BOTTOM:
+        {
+            eventType = wxEVT_SCROLL_BOTTOM;
+            break;
+        }
+        default:
+        {
+            // Should never get here
+            wxFAIL_MSG("Unknown scroll event.");
+            break;
+        }
+    }
+
+    wxScrollEvent event(eventType, win->GetId());
+    event.SetEventObject(win);
+    event.SetPosition(cbs->value);
+    event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
+
+    win->GetEventHandler()->ProcessEvent(event);
+}
+

 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {
   switch (xevent->xany.type)
 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
 {
   switch (xevent->xany.type)


@@ -2557,11 +3058,9 @@ bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEve
   return FALSE;
 }
 
   return FALSE;
 }
 

-// TODO From wxWin 1.68. What does it do exactly?

 #define YAllocColor XAllocColor
 #define YAllocColor XAllocColor

-
-XColor itemColors[5];
-int wxComputeColors (Display *display, wxColour * back, wxColour * fore)
+XColor g_itemColors[5];
+int wxComputeColours (Display *display, wxColour * back, wxColour * fore)

 {
   int result;
   static XmColorProc colorProc;
 {
   int result;
   static XmColorProc colorProc;


@@ -2570,10 +3069,10 @@ int wxComputeColors (Display *display, wxColour * back, wxColour * fore)
 
   if (back)
     {
 
   if (back)
     {

-      itemColors[0].red = (((long) back->Red ()) << 8);
-      itemColors[0].green = (((long) back->Green ()) << 8);
-      itemColors[0].blue = (((long) back->Blue ()) << 8);
-      itemColors[0].flags = DoRed | DoGreen | DoBlue;
+      g_itemColors[0].red = (((long) back->Red ()) << 8);
+      g_itemColors[0].green = (((long) back->Green ()) << 8);
+      g_itemColors[0].blue = (((long) back->Blue ()) << 8);
+      g_itemColors[0].flags = DoRed | DoGreen | DoBlue;

       if (colorProc == (XmColorProc) NULL)
        {
          // Get a ptr to the actual function
       if (colorProc == (XmColorProc) NULL)
        {
          // Get a ptr to the actual function


@@ -2581,19 +3080,19 @@ int wxComputeColors (Display *display, wxColour * back, wxColour * fore)
          // And set it back to motif.
          XmSetColorCalculation (colorProc);
        }
          // And set it back to motif.
          XmSetColorCalculation (colorProc);
        }

-      (*colorProc) (&itemColors[wxBACK_INDEX],
-                   &itemColors[wxFORE_INDEX],
-                   &itemColors[wxSELE_INDEX],
-                   &itemColors[wxTOPS_INDEX],
-                   &itemColors[wxBOTS_INDEX]);
+      (*colorProc) (&g_itemColors[wxBACK_INDEX],
+                   &g_itemColors[wxFORE_INDEX],
+                   &g_itemColors[wxSELE_INDEX],
+                   &g_itemColors[wxTOPS_INDEX],
+                   &g_itemColors[wxBOTS_INDEX]);

       result = wxBACK_COLORS;
     }
   if (fore)
     {
       result = wxBACK_COLORS;
     }
   if (fore)
     {

-      itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
-      itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
-      itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
-      itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
+      g_itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
+      g_itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
+      g_itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
+      g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;

       if (result == wxNO_COLORS)
        result = wxFORE_COLORS;
     }
       if (result == wxNO_COLORS)
        result = wxFORE_COLORS;
     }


@@ -2605,13 +3104,13 @@ int wxComputeColors (Display *display, wxColour * back, wxColour * fore)
     {
       /* 5 Colours to allocate */
       for (int i = 0; i < 5; i++)
     {
       /* 5 Colours to allocate */
       for (int i = 0; i < 5; i++)

-       if (!YAllocColor (dpy, cmap, &itemColors[i]))
+       if (!YAllocColor (dpy, cmap, &g_itemColors[i]))

          result = wxNO_COLORS;
     }
   else if (fore)
     {
       /* Only 1 colour to allocate */
          result = wxNO_COLORS;
     }
   else if (fore)
     {
       /* Only 1 colour to allocate */

-      if (!YAllocColor (dpy, cmap, &itemColors[wxFORE_INDEX]))
+      if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))

        result = wxNO_COLORS;
     }
 
        result = wxNO_COLORS;
     }
 


@@ -2619,54 +3118,179 @@ int wxComputeColors (Display *display, wxColour * back, wxColour * fore)
 
 }
 
 
 }
 

-void wxWindow::ChangeColour(WXWidget widget)
+// 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()

 {
 {

-  // TODO
-#if 0
-  int change;
+    if (GetMainWidget())
+        DoChangeBackgroundColour(GetMainWidget(), m_backgroundColour);
+}
+
+void wxWindow::ChangeForegroundColour()
+{
+    if (GetMainWidget())
+        DoChangeForegroundColour(GetMainWidget(), m_foregroundColour);
+}

 
 

-  // TODO: how to determine whether we can change this item's colours?
-  // We used to have wxUSER_COLOURS. Now perhaps we assume we always
-  // can change it.
-  //  if (!(parent->GetWindowStyleFlag() & wxUSER_COLOURS))
-  //    return;
+// Change a widget's foreground and background colours.

 
 

-  change = wxComputeColors (XtDisplay((Widget)widget), panel->GetBackgroundColour(),
-                           panel->GetLabelColour());
-  if (change == wxBACK_COLORS)
-    XtVaSetValues ((Widget) widget,
-                  XmNbackground, itemColors[wxBACK_INDEX].pixel,
-                  XmNtopShadowColor, itemColors[wxTOPS_INDEX].pixel,
-                  XmNbottomShadowColor, itemColors[wxBOTS_INDEX].pixel,
-                  XmNforeground, itemColors[wxFORE_INDEX].pixel,
-                  NULL);
-  else if (change == wxFORE_COLORS)
-    XtVaSetValues (formWidget,
-                  XmNforeground, itemColors[wxFORE_INDEX].pixel,
+void wxWindow::DoChangeForegroundColour(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);
                   NULL);

+}
+
+void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
+{
+  wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
+                           (wxColour*) NULL);

 
 

-  change = wxComputeColors (XtDisplay((Widget)formWidget), GetBackgroundColour(), GetLabelColour());
-  if (change == wxBACK_COLORS)
-    XtVaSetValues (labelWidget,
-                  XmNbackground, itemColors[wxBACK_INDEX].pixel,
-                  XmNtopShadowColor, itemColors[wxTOPS_INDEX].pixel,
-                  XmNbottomShadowColor, itemColors[wxBOTS_INDEX].pixel,
-                  XmNarmColor, itemColors[wxSELE_INDEX].pixel,
-                  XmNforeground, itemColors[wxFORE_INDEX].pixel,
+  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);
                   NULL);

-  else if (change == wxFORE_COLORS)
-    XtVaSetValues (labelWidget,
-                  XmNforeground, itemColors[wxFORE_INDEX].pixel,
+
+  if (changeArmColour)
+    XtVaSetValues ((Widget) widget,
+                  XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
+               NULL);
+}
+
+void wxWindow::SetBackgroundColour(const wxColour& col)
+{
+    m_backgroundColour = col;
+    ChangeBackgroundColour();
+}
+
+void wxWindow::SetForegroundColour(const wxColour& col)
+{
+    m_foregroundColour = col;
+    ChangeForegroundColour();
+}
+
+void wxWindow::ChangeFont(bool keepOriginalSize)
+{
+    // 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?
+    Widget w = (Widget) GetLabelWidget(); // Usually the main widget
+    if (w && m_windowFont.Ok())
+    {
+        int width, height, width1, height1;
+        GetSize(& width, & height);
+
+// lesstif 0.87 hangs here
+#ifndef LESSTIF_VERSION        
+        XtVaSetValues (w,
+                  XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),

                   NULL);
 #endif
                   NULL);
 #endif

+
+        GetSize(& width1, & height1);
+        if (keepOriginalSize && (width != width1 || height != height1))
+        {
+            SetSize(-1, -1, width, height);
+        }
+    }

 }
 
 }
 

-void wxWindow::ChangeFont(WXWidget widget)
+void wxWindow::SetFont(const wxFont& font)

 {
 {

-  /* TODO
-  if (widget && GetFont() && GetFont()->IsOk())
-    XtVaSetValues ((Widget) widget,
-                  XmNfontList, GetFont()->GetInternalFont (),
-                  NULL);
-  */
+    m_windowFont = font;
+    ChangeFont();
+}
+
+void wxWindow::ClearUpdateRects()
+{
+    wxNode* node = m_updateRects.First();
+    while (node)
+    {
+        wxRect* rect = (wxRect*) node->Data();
+        delete rect;
+        node = node->Next();
+    }
+    m_updateRects.Clear();
+}
+
+bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
+{
+    if (!m_acceleratorTable.Ok())
+        return FALSE;
+
+    int count = m_acceleratorTable.GetCount();
+    wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
+    int i;
+    for (i = 0; i < count; i++)
+    {
+        wxAcceleratorEntry* entry = & (entries[i]);
+        if (entry->MatchesEvent(event))
+        {
+            // Bingo, we have a match. Now find a control
+            // that matches the entry command id.
+
+            // Need to go up to the top of the window hierarchy,
+            // since it might be e.g. a menu item
+            wxWindow* parent = this;
+            while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)) && !parent->IsKindOf(CLASSINFO(wxDialog)))
+                parent = parent->GetParent();
+
+            if (!parent)
+                return FALSE;
+
+            if (parent->IsKindOf(CLASSINFO(wxFrame)))
+            {
+                // Try for a menu command
+                wxFrame* frame = (wxFrame*) parent;
+                if (frame->GetMenuBar())
+                {
+                    wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
+                    if (item)
+                    {
+                        wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
+                        commandEvent.SetEventObject(frame);
+
+                        // If ProcessEvent returns TRUE (it was handled), then
+                        // the calling code will skip the event handling.
+                        return frame->GetEventHandler()->ProcessEvent(commandEvent);
+                    }
+                }
+            }
+
+            // Find a child matching the command id
+            wxWindow* child = parent->FindWindow(entry->GetCommand());
+
+            // No such child
+            if (!child)
+                return FALSE;
+
+            // Now we process those kinds of windows that we can.
+            // For now, only buttons.
+            if (child->IsKindOf(CLASSINFO(wxButton)))
+            {
+                wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
+                commandEvent.SetEventObject(child);
+                return child->GetEventHandler()->ProcessEvent(commandEvent);
+            }
+
+            return FALSE;
+        } // matches event
+    }// for
+
+    // We didn't match the key event against an accelerator.
+    return FALSE;

 }
 }

+