Correct definition of sorting function.

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

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
index 49f55797310258490af141d7c90b250258c16d50..207afc3ed056f31ce74a1d30f2b327fb8730f23e 100644 (file)
--- a/src/motif/window.cpp
+++ b/src/motif/window.cpp
@@ -17,10 +17,13 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "window.h"
 #endif
 
     #pragma implementation "window.h"
 #endif
 

+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+

 #ifdef __VMS
 #define XtDisplay XTDISPLAY
 #define XtWindow XTWINDOW
 #ifdef __VMS
 #define XtDisplay XTDISPLAY
 #define XtWindow XTWINDOW


@@ -145,7 +148,6 @@ static int str16len(const char *s)
 
     BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
 
     BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)

-        EVT_IDLE(wxWindow::OnIdle)

     END_EVENT_TABLE()
 
 // ============================================================================
     END_EVENT_TABLE()
 
 // ============================================================================


@@ -172,11 +174,6 @@ bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
     if ( !w )
         return FALSE;
 
     if ( !w )
         return FALSE;
 

-    if ( domap )
-        XtMapWidget(w);
-    else
-        XtUnmapWidget(w);
-

     //   Rationale: a lot of common operations (including but not
     // limited to moving, resizing and appending items to a listbox)
     // unmamange the widget, do their work, then manage it again.
     //   Rationale: a lot of common operations (including but not
     // limited to moving, resizing and appending items to a listbox)
     // unmamange the widget, do their work, then manage it again.


@@ -184,6 +181,19 @@ bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
     // or that most controls are shown every time they are moved or resized!
     XtSetMappedWhenManaged( w, domap );
 
     // or that most controls are shown every time they are moved or resized!
     XtSetMappedWhenManaged( w, domap );
 

+    // if the widget is not unmanaged, it still intercepts
+    // mouse events, even if it is not mapped (and hence invisible)
+    if ( domap )
+    {
+        XtManageChild(w);
+        // XtMapWidget(w);
+    }
+    else
+    {
+        XtUnmanageChild(w);
+        // XtUnmapWidget(w);
+    }
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -193,21 +203,13 @@ bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
 
 void wxWindow::Init()
 {
 
 void wxWindow::Init()
 {

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

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

-    m_button1Pressed =
-    m_button2Pressed =
-    m_button3Pressed = FALSE;
-

     m_winCaptured = FALSE;
 
     m_isShown = TRUE;
     m_winCaptured = FALSE;
 
     m_isShown = TRUE;

-    m_isBeingDeleted = FALSE;

     
     m_hScrollBar =
     m_vScrollBar =
     
     m_hScrollBar =
     m_vScrollBar =


@@ -215,9 +217,6 @@ void wxWindow::Init()
     m_scrolledWindow =
     m_drawingArea = (WXWidget) 0;
 
     m_scrolledWindow =
     m_drawingArea = (WXWidget) 0;
 

-    m_hScroll =
-    m_vScroll = FALSE;
-

     m_scrollPosX =
     m_scrollPosY = 0;
 
     m_scrollPosX =
     m_scrollPosY = 0;
 


@@ -230,7 +229,6 @@ void wxWindow::Init()
 
     m_lastTS = 0;
     m_lastButton = 0;
 
     m_lastTS = 0;
     m_lastButton = 0;

-    m_canAddEventHandler = FALSE;

 }
 
 // real construction (Init() must have been called before!)
 }
 
 // real construction (Init() must have been called before!)


@@ -277,36 +275,7 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
 
     Widget parentWidget = (Widget) parent->GetClientWidget();
     XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
 
     Widget parentWidget = (Widget) parent->GetClientWidget();

-    
-    if (style & wxSIMPLE_BORDER)
-    {
-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_IN,
-                                    XmNshadowThickness, 1,
-                                    NULL
-                                   );
-    } else if (style & wxSUNKEN_BORDER)
-    {
-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_IN,
-                                    NULL
-                                   );
-    } else if (style & wxRAISED_BORDER)
-    {
-        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
-                                   (
-                                    "canvasBorder",
-                                    xmFrameWidgetClass, parentWidget,
-                                    XmNshadowType, XmSHADOW_OUT,
-                                    NULL
-                                   );
-    }
+    m_borderWidget = wxCreateBorderWidget( (WXWidget)parentWidget, style );

 
     m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
                                  (
 
     m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
                                  (


@@ -360,12 +329,6 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
     XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
 
     XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
     XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
 

-    // TODO?
-#if 0
-    display = XtDisplay (scrolledWindow);
-    xwindow = XtWindow (drawingArea);
-#endif // 0
-

     XtAddEventHandler(
                       (Widget)m_drawingArea,
                        PointerMotionHintMask | EnterWindowMask |
     XtAddEventHandler(
                       (Widget)m_drawingArea,
                        PointerMotionHintMask | EnterWindowMask |


@@ -378,21 +341,14 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     // 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);
     // 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);
+    wxDoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
+    wxDoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);

 
     XmScrolledWindowSetAreas(
                              (Widget)m_scrolledWindow,
                              (Widget) 0, (Widget) 0,
                              (Widget) m_drawingArea);
 
 
     XmScrolledWindowSetAreas(
                              (Widget)m_scrolledWindow,
                              (Widget) 0, (Widget) 0,
                              (Widget) m_drawingArea);
 

-#if 0
-    if (m_hScrollBar)
-        XtRealizeWidget ((Widget) m_hScrollBar);
-    if (m_vScrollBar)
-        XtRealizeWidget ((Widget) m_vScrollBar);
-#endif // 0
-

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


@@ -417,11 +373,6 @@ wxWindow::~wxWindow()
         DetachWidget(wMain);
     }
 
         DetachWidget(wMain);
     }
 

-    ClearUpdateRects();
-
-    if ( m_parent )
-        m_parent->RemoveChild( this );
-

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


@@ -498,126 +449,107 @@ wxWindow::~wxWindow()
 // scrollbar management
 // ----------------------------------------------------------------------------
 
 // scrollbar management
 // ----------------------------------------------------------------------------
 

+WXWidget wxWindow::DoCreateScrollBar(WXWidget parent,
+                                     wxOrientation orientation,
+                                     void (*callback)())
+{
+    int orient = ( orientation & wxHORIZONTAL ) ? XmHORIZONTAL : XmVERTICAL;
+    Widget sb =
+        XtVaCreateManagedWidget( "scrollBarWidget",
+                                 xmScrollBarWidgetClass, (Widget)parent,
+                                 XmNorientation, orient,
+                                 XmNincrement, 1,
+                                 XmNvalue, 0,
+                                 NULL );
+
+    XtPointer o = (XtPointer)orientation;
+    XtCallbackProc cb = (XtCallbackProc)callback;
+
+    XtAddCallback( sb, XmNvalueChangedCallback, cb, o );
+    XtAddCallback( sb, XmNdragCallback, cb, o );
+    XtAddCallback( sb, XmNincrementCallback, cb, o );
+    XtAddCallback( sb, XmNdecrementCallback, cb, o );
+    XtAddCallback( sb, XmNpageIncrementCallback, cb, o );
+    XtAddCallback( sb, XmNpageDecrementCallback, cb, o );
+    XtAddCallback( sb, XmNtoTopCallback, cb, o );
+    XtAddCallback( sb, XmNtoBottomCallback, cb, o );
+
+    return (WXWidget)sb;
+}
+

 // Helper function
 void wxWindow::CreateScrollbar(wxOrientation orientation)
 {
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
 // Helper function
 void wxWindow::CreateScrollbar(wxOrientation orientation)
 {
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 

-    XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
+    XtVaSetValues( (Widget) m_scrolledWindow,
+                   XmNresizePolicy, XmRESIZE_NONE,
+                   NULL );

 
 

+    wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);

     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
     {
     // Add scrollbars if required
     if (orientation == wxHORIZONTAL)
     {

-        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_hScrollBar = DoCreateScrollBar( m_scrolledWindow, wxHORIZONTAL,
+                                          (void (*)())wxScrollBarCallback );

 
 

-        wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-        DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
+        wxDoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);

 
 

-        XtRealizeWidget(hScrollBar);
+        XtRealizeWidget( (Widget)m_hScrollBar );

 
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) m_hScrollBar,
             NULL);
 
 
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNhorizontalScrollBar, (Widget) m_hScrollBar,
             NULL);
 

-        m_hScroll = TRUE;
-
-        wxAddWindowToTable( hScrollBar, this );
+        wxAddWindowToTable( (Widget)m_hScrollBar, this );

     }
     }

-
-    if (orientation == wxVERTICAL)
+    else if (orientation == wxVERTICAL)

     {
     {

-        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 = DoCreateScrollBar( m_scrolledWindow, wxVERTICAL,
+                                          (void (*)())wxScrollBarCallback );

 
 

-        m_vScrollBar = (WXWidget) vScrollBar;
-        wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-        DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
+        wxDoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);

 
 

-        XtRealizeWidget(vScrollBar);
+        XtRealizeWidget((Widget)m_vScrollBar);

 
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) m_vScrollBar,
             NULL);
 
 
         XtVaSetValues((Widget) m_scrolledWindow,
             XmNverticalScrollBar, (Widget) m_vScrollBar,
             NULL);
 

-        m_vScroll = TRUE;
-
-        wxAddWindowToTable( vScrollBar, this );
+        wxAddWindowToTable( (Widget)m_vScrollBar, this );

     }
 
     }
 

-    XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
+    XtVaSetValues( (Widget) m_scrolledWindow,
+                   XmNresizePolicy, XmRESIZE_ANY,
+                   NULL );

 }
 
 void wxWindow::DestroyScrollbar(wxOrientation orientation)
 {
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 
 }
 
 void wxWindow::DestroyScrollbar(wxOrientation orientation)
 {
     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 

-    XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
-    // Add scrollbars if required
-    if (orientation == wxHORIZONTAL)
-    {
-        if (m_hScrollBar)
-        {
-            wxDeleteWindowFromTable((Widget)m_hScrollBar);
-            XtDestroyWidget((Widget) m_hScrollBar);
-        }
-        m_hScrollBar = (WXWidget) 0;
-        m_hScroll = FALSE;
-
-        XtVaSetValues((Widget) m_scrolledWindow,
-            XmNhorizontalScrollBar, (Widget) 0,
-            NULL);
-
-    }
+    XtVaSetValues((Widget) m_scrolledWindow,
+                  XmNresizePolicy, XmRESIZE_NONE,
+                  NULL);
+    String stringSB = orientation == wxHORIZONTAL ?
+        XmNhorizontalScrollBar : XmNverticalScrollBar;
+    WXWidget* widgetSB = orientation == wxHORIZONTAL ?
+        &m_hScrollBar : &m_vScrollBar;

 
 

-    if (orientation == wxVERTICAL)
+    if( *widgetSB )

     {
     {

-        if (m_vScrollBar)
-        {
-            wxDeleteWindowFromTable((Widget)m_vScrollBar);
-            XtDestroyWidget((Widget) m_vScrollBar);
-        }
-        m_vScrollBar = (WXWidget) 0;
-        m_vScroll = FALSE;
+        wxDeleteWindowFromTable( (Widget)*widgetSB );
+        XtDestroyWidget( (Widget)*widgetSB );
+        *widgetSB = (WXWidget)NULL;
+    }

 
 

-        XtVaSetValues((Widget) m_scrolledWindow,
-            XmNverticalScrollBar, (Widget) 0,
-            NULL);
+    XtVaSetValues( (Widget)m_scrolledWindow,
+                   stringSB, (Widget) 0,
+                   NULL );

 
 

-    }
-    XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
+    XtVaSetValues((Widget) m_scrolledWindow,
+                  XmNresizePolicy, XmRESIZE_ANY,
+                  NULL);

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


@@ -641,7 +573,7 @@ wxWindow *wxWindowBase::FindFocus()
     // (2) The widget with the focus may not be in the widget table
     // depending on which widgets I put in the table
     wxWindow *winFocus = (wxWindow *)NULL;
     // (2) The widget with the focus may not be in the widget table
     // depending on which widgets I put in the table
     wxWindow *winFocus = (wxWindow *)NULL;

-    for ( wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
+    for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {


@@ -682,8 +614,8 @@ bool wxWindow::Show(bool show)
 
     if (m_borderWidget || m_scrolledWindow)
     {
 
     if (m_borderWidget || m_scrolledWindow)
     {

-        MapOrUnmap(m_drawingArea, show);

         MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
         MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);

+        // MapOrUnmap(m_drawingArea, show);

     }
     else
     {
     }
     else
     {


@@ -825,7 +757,9 @@ int wxWindow::GetScrollPos(int orient) const
 int wxWindow::GetScrollRange(int orient) const
 {
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 int wxWindow::GetScrollRange(int orient) const
 {
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);

-    wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
+    // CE scintilla windows don't always have these scrollbars 
+    // and it tends to pile up a whole bunch of asserts
+    //wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );

 
     int range = 0;
     if (scrollBar) 
 
     int range = 0;
     if (scrollBar) 


@@ -836,10 +770,11 @@ int wxWindow::GetScrollRange(int orient) const
 int wxWindow::GetScrollThumb(int orient) const
 {
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 int wxWindow::GetScrollThumb(int orient) const
 {
     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);

-    wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
+    //wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );

 
 

-    int thumb;
-    XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
+    int thumb = 0;
+    if (scrollBar)
+        XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);

     return thumb;
 }
 
     return thumb;
 }
 


@@ -968,7 +903,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBrush(brush); // FIXME: needed?
 
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBrush(brush); // FIXME: needed?
 

-    wxWindowList::Node *cnode = m_children.GetFirst();
+    wxWindowList::compatibility_iterator cnode = m_children.GetFirst();

     while (cnode)
     {
         wxWindow *child = cnode->GetData();
     while (cnode)
     {
         wxWindow *child = cnode->GetData();


@@ -1064,7 +999,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 
     // Now send expose events
 
 
     // Now send expose events
 

-    wxList::Node* node = updateRects.GetFirst();
+    wxList::compatibility_iterator  node = updateRects.GetFirst();

     while (node)
     {
         wxRect* rect = (wxRect*) node->GetData();
     while (node)
     {
         wxRect* rect = (wxRect*) node->GetData();


@@ -1140,6 +1075,12 @@ void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
 
 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
 {
 
 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
 {

+    if ( x == -1 && y == -1 )
+    {
+        wxPoint mouse = ScreenToClient(wxGetMousePosition());
+        x = mouse.x; y = mouse.y;
+    }
+

     Widget widget = (Widget) GetMainWidget();
 
     /* The menuId field seems to be usused, so we'll use it to
     Widget widget = (Widget) GetMainWidget();
 
     /* The menuId field seems to be usused, so we'll use it to


@@ -1334,7 +1275,7 @@ void wxWindow::DoSetSizeIntr(int x, int y, int width, int height,
     wxSize size(-1, -1);
     if ( width <= 0 )
     {
     wxSize size(-1, -1);
     if ( width <= 0 )
     {

-        if ( sizeFlags & wxSIZE_AUTO_WIDTH && !fromCtor )
+        if ( ( sizeFlags & wxSIZE_AUTO_WIDTH ) && !fromCtor )

         {
             size = DoGetBestSize();
             width = size.x;
         {
             size = DoGetBestSize();
             width = size.x;


@@ -1347,7 +1288,7 @@ void wxWindow::DoSetSizeIntr(int x, int y, int width, int height,
 
     if ( height == -1 )
     {
 
     if ( height == -1 )
     {

-        if( sizeFlags & wxSIZE_AUTO_HEIGHT && !fromCtor )
+        if( ( sizeFlags & wxSIZE_AUTO_HEIGHT ) && !fromCtor )

         {
             if( size.x == -1 ) size = DoGetBestSize();
             height = size.y;
         {
             if( size.x == -1 ) size = DoGetBestSize();
             height = size.y;


@@ -1438,36 +1379,6 @@ wxPoint wxWindow::GetClientAreaOrigin() const
     return wxPoint(0, 0);
 }
 
     return wxPoint(0, 0);
 }
 

-void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
-{
-    m_minWidth = minW;
-    m_minHeight = minH;
-    m_maxWidth = maxW;
-    m_maxHeight = maxH;
-
-    wxFrame *frame = wxDynamicCast(this, wxFrame);
-    if ( !frame )
-    {
-        // TODO what about dialogs?
-        return;
-    }
-
-    Widget widget = (Widget) frame->GetShellWidget();
-
-    if (minW > -1)
-        XtVaSetValues(widget, XmNminWidth, minW, NULL);
-    if (minH > -1)
-        XtVaSetValues(widget, XmNminHeight, minH, NULL);
-    if (maxW > -1)
-        XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
-    if (maxH > -1)
-        XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
-    if (incW > -1)
-        XtVaSetValues(widget, XmNwidthInc, incW, NULL);
-    if (incH > -1)
-        XtVaSetValues(widget, XmNheightInc, incH, NULL);
-}
-

 void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
                                 int flags)
 {
 void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
                                 int flags)
 {


@@ -1479,7 +1390,6 @@ void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
             (Widget) m_scrolledWindow;
 
         bool managed = XtIsManaged(borderOrScrolled);
             (Widget) m_scrolledWindow;
 
         bool managed = XtIsManaged(borderOrScrolled);

-

         if (managed)
             XtUnmanageChild (borderOrScrolled);
         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
         if (managed)
             XtUnmanageChild (borderOrScrolled);
         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);


@@ -1506,6 +1416,7 @@ void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
                 w -= 2 * (thick + margin);
             }
 
                 w -= 2 * (thick + margin);
             }
 

+            if( w < 1 ) w = 1;

             XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
         }
 
             XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
         }
 


@@ -1522,6 +1433,7 @@ void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
                 h -= 2 * (thick + margin);
             }
 
                 h -= 2 * (thick + margin);
             }
 

+            if( h < 1 ) h = 1;

             XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
         }
 
             XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
         }
 


@@ -1623,6 +1535,11 @@ void wxWindow::GetTextExtent(const wxString& string,
 // painting
 // ----------------------------------------------------------------------------
 
 // painting
 // ----------------------------------------------------------------------------
 

+void wxWindow::AddUpdateRect(int x, int y, int w, int h)
+{
+    m_updateRegion.Union( x, y, w, h );
+}
+

 void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
 {
     m_needsRefresh = TRUE;
 void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
 {
     m_needsRefresh = TRUE;


@@ -1667,27 +1584,6 @@ 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()
-{
-    wxClientDC dc(this);
-    wxBrush brush(GetBackgroundColour(), wxSOLID);
-    dc.SetBackground(brush);
-    dc.Clear();
-}
-
-void wxWindow::ClearUpdateRects()
-{
-    wxRectList::Node* node = m_updateRects.GetFirst();
-    while (node)
-    {
-        wxRect* rect = node->GetData();
-        delete rect;
-        node = node->GetNext();
-    }
-
-    m_updateRects.Clear();
-}
-

 void wxWindow::DoPaint()
 {
     //TODO : make a temporary gc so we can do the XCopyArea below
 void wxWindow::DoPaint()
 {
     //TODO : make a temporary gc so we can do the XCopyArea below


@@ -1706,7 +1602,7 @@ void wxWindow::DoPaint()
       // 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
       // 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.
+      // implement backing stores itself, using generic wxWidgets code.

       wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
       if ( scrolledWindow )
       {
       wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
       if ( scrolledWindow )
       {


@@ -1769,7 +1665,7 @@ void wxWindow::DoPaint()
 // 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)
 {

-    wxWindowList::Node *node = GetChildren().GetFirst();
+    wxWindowList::compatibility_iterator node = GetChildren().GetFirst();

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


@@ -1785,11 +1681,12 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
     }
 }
 

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

 {
     // 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();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

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


@@ -1873,7 +1770,7 @@ bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ============================================================================
 
 // ----------------------------------------------------------------------------

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

 // ----------------------------------------------------------------------------
 
 bool wxAddWindowToTable(Widget w, wxWindow *win)
 // ----------------------------------------------------------------------------
 
 bool wxAddWindowToTable(Widget w, wxWindow *win)


@@ -1915,14 +1812,12 @@ bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
                              WXWidget formWidget, int x, int y, int width, int height)
 {
     wxAddWindowToTable((Widget) mainWidget, this);
                              WXWidget formWidget, int x, int y, int width, int height)
 {
     wxAddWindowToTable((Widget) mainWidget, this);

-    if (CanAddEventHandler())
-    {
-        XtAddEventHandler((Widget) mainWidget,
-            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
-            False,
-            wxPanelItemEventHandler,
-            (XtPointer) this);
-    }
+    XtAddEventHandler( (Widget) mainWidget,
+                       ButtonPressMask | ButtonReleaseMask
+                     | PointerMotionMask,
+                       False,
+                       wxPanelItemEventHandler,
+                       (XtPointer) this);

 
     if (!formWidget)
     {
 
     if (!formWidget)
     {


@@ -1956,14 +1851,12 @@ bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
 // Remove event handler, remove from hash table
 bool wxWindow::DetachWidget(WXWidget widget)
 {
 // Remove event handler, remove from hash table
 bool wxWindow::DetachWidget(WXWidget widget)
 {

-    if (CanAddEventHandler())
-    {
-        XtRemoveEventHandler((Widget) widget,
-            ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
-            False,
-            wxPanelItemEventHandler,
-            (XtPointer)this);
-    }
+    XtRemoveEventHandler( (Widget) widget,
+                          ButtonPressMask | ButtonReleaseMask
+                        | PointerMotionMask,
+                          False,
+                          wxPanelItemEventHandler,
+                          (XtPointer)this);

 
     wxDeleteWindowFromTable((Widget) widget);
     return TRUE;
 
     wxDeleteWindowFromTable((Widget) widget);
     return TRUE;


@@ -1973,6 +1866,15 @@ bool wxWindow::DetachWidget(WXWidget widget)
 // Motif-specific accessors
 // ----------------------------------------------------------------------------
 
 // Motif-specific accessors
 // ----------------------------------------------------------------------------
 

+WXWindow wxWindow::GetClientXWindow() const
+{
+    Widget wMain = (Widget)GetClientWidget();
+    if ( wMain )
+        return (WXWindow) XtWindow(wMain);
+    else
+        return (WXWindow) 0;
+}
+

 // Get the underlying X window
 WXWindow wxWindow::GetXWindow() const
 {
 // Get the underlying X window
 WXWindow wxWindow::GetXWindow() const
 {


@@ -2025,7 +1927,8 @@ WXWidget wxWindow::GetLabelWidget() const
 
 // All widgets should have this as their resize proc.
 // OnSize sent to wxWindow via client data.
 
 // 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))
+void wxWidgetResizeProc(Widget w, XConfigureEvent *WXUNUSED(event),
+                        String WXUNUSED(args)[], int *WXUNUSED(num_args))

 {
     wxWindow *win = wxGetWindowFromTable(w);
     if (!win)
 {
     wxWindow *win = wxGetWindowFromTable(w);
     if (!win)


@@ -2057,11 +1960,10 @@ static void wxCanvasRepaintProc(Widget drawingArea,
         {
             win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
                                event->xexpose.width, event->xexpose.height);
         {
             win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
                                event->xexpose.width, event->xexpose.height);

-            
+

             if (event -> xexpose.count == 0)
             {
                 win->DoPaint();
             if (event -> xexpose.count == 0)
             {
                 win->DoPaint();

-                win->ClearUpdateRects();

             }
             break;
         }
             }
             break;
         }


@@ -2105,7 +2007,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
                                XmDrawingAreaCallbackStruct * cbs)
 {
     wxWindow *canvas = wxGetWindowFromTable(drawingArea);
                                XmDrawingAreaCallbackStruct * cbs)
 {
     wxWindow *canvas = wxGetWindowFromTable(drawingArea);

-    XEvent local_event;
+    XEvent* xevent = cbs->event;

 
     if (canvas==NULL)
         return;
 
     if (canvas==NULL)
         return;


@@ -2113,9 +2015,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
     if (cbs->reason != XmCR_INPUT)
         return;
 
     if (cbs->reason != XmCR_INPUT)
         return;
 

-    local_event = *(cbs->event);    // We must keep a copy!
-
-    switch (local_event.xany.type)
+    switch (xevent->xany.type)

     {
     case EnterNotify:
     case LeaveNotify:
     {
     case EnterNotify:
     case LeaveNotify:


@@ -2123,175 +2023,21 @@ static void wxCanvasInputEvent(Widget drawingArea,
     case ButtonRelease:
     case MotionNotify:
         {
     case ButtonRelease:
     case MotionNotify:
         {

-            // FIXME: most of this mouse event code is more or less
-            // duplicated in wxTranslateMouseEvent
-            //
-            wxEventType eventType = wxEVT_NULL;
-
-            if (local_event.xany.type == EnterNotify)
-            {
-                //if (local_event.xcrossing.mode!=NotifyNormal)
-                //  return ; // Ignore grab events
-                eventType = wxEVT_ENTER_WINDOW;
-                //            canvas->GetEventHandler()->OnSetFocus();
-            }
-            else if (local_event.xany.type == LeaveNotify)
-            {
-                //if (local_event.xcrossingr.mode!=NotifyNormal)
-                //  return ; // Ignore grab events
-                eventType = wxEVT_LEAVE_WINDOW;
-                //            canvas->GetEventHandler()->OnKillFocus();
-            }
-            else if (local_event.xany.type == MotionNotify)
+            wxMouseEvent wxevent(0);
+            if (wxTranslateMouseEvent(wxevent, canvas, drawingArea, xevent))

             {
             {

-                eventType = wxEVT_MOTION;
+                canvas->GetEventHandler()->ProcessEvent(wxevent);

             }
             }

-
-            else if (local_event.xany.type == ButtonPress)
-            {
-                if (local_event.xbutton.button == Button1)
-                {
-                    eventType = wxEVT_LEFT_DOWN;
-                    canvas->SetButton1(TRUE);
-                }
-                else if (local_event.xbutton.button == Button2)
-                {
-                    eventType = wxEVT_MIDDLE_DOWN;
-                    canvas->SetButton2(TRUE);
-                }
-                else if (local_event.xbutton.button == Button3)
-                {
-                    eventType = wxEVT_RIGHT_DOWN;
-                    canvas->SetButton3(TRUE);
-                }
-            }
-            else if (local_event.xany.type == ButtonRelease)
-            {
-                if (local_event.xbutton.button == Button1)
-                {
-                    eventType = wxEVT_LEFT_UP;
-                    canvas->SetButton1(FALSE);
-                }
-                else if (local_event.xbutton.button == Button2)
-                {
-                    eventType = wxEVT_MIDDLE_UP;
-                    canvas->SetButton2(FALSE);
-                }
-                else if (local_event.xbutton.button == Button3)
-                {
-                    eventType = wxEVT_RIGHT_UP;
-                    canvas->SetButton3(FALSE);
-                }
-            }
-
-            wxMouseEvent wxevent (eventType);
-
-            wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
-                || (event_left_is_down (&local_event)
-                && (eventType != wxEVT_LEFT_UP)));
-            wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
-                || (event_middle_is_down (&local_event)
-                && (eventType != wxEVT_MIDDLE_UP)));
-            wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
-                || (event_right_is_down (&local_event)
-                && (eventType != wxEVT_RIGHT_UP)));
-
-            wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
-            wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
-            wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
-            wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
-            wxevent.SetTimestamp(local_event.xbutton.time);
-
-           if ( eventType == wxEVT_MOTION )
-           {
-                if (local_event.xmotion.is_hint == NotifyHint)
-                {
-                    Window root, child;
-                    Display *dpy = XtDisplay (drawingArea);
-
-                    XQueryPointer (dpy, XtWindow (drawingArea),
-                        &root, &child,
-                        &local_event.xmotion.x_root,
-                        &local_event.xmotion.y_root,
-                        &local_event.xmotion.x,
-                        &local_event.xmotion.y,
-                        &local_event.xmotion.state);
-                }
-                else
-                {
-                }
-           }
-
-            // Now check if we need to translate this event into a double click
-            if (TRUE) // canvas->doubleClickAllowed)
-            {
-                if (wxevent.ButtonDown())
-                {
-                    long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
-
-                    // get button and time-stamp
-                    int button = 0;
-                    if (wxevent.LeftDown())
-                        button = 1;
-                    else if (wxevent.MiddleDown())
-                        button = 2;
-                    else if (wxevent.RightDown())
-                        button = 3;
-                    long ts = wxevent.GetTimestamp();
-
-                    // check, if single or double click
-                    int buttonLast = canvas->GetLastClickedButton();
-                    long lastTS = canvas->GetLastClickTime();
-                    if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
-                    {
-                        // I have a dclick
-                        canvas->SetLastClick(0, ts);
-
-                        wxEventType typeDouble;
-                        if ( eventType == wxEVT_LEFT_DOWN )
-                            typeDouble = wxEVT_LEFT_DCLICK;
-                        else if ( eventType == wxEVT_MIDDLE_DOWN )
-                            typeDouble = wxEVT_MIDDLE_DCLICK;
-                        else if ( eventType == wxEVT_RIGHT_DOWN )
-                            typeDouble = wxEVT_RIGHT_DCLICK;
-                        else
-                            typeDouble = wxEVT_NULL;
-
-                        if ( typeDouble != wxEVT_NULL )
-                        {
-                            wxevent.SetEventType(typeDouble);
-                        }
-                    }
-                    else
-                    {
-                        // not fast enough or different button
-                        canvas->SetLastClick(button, ts);
-                    }
-                }
-            }
-
-            wxevent.SetId(canvas->GetId());
-            wxevent.SetEventObject(canvas);
-            wxevent.m_x = local_event.xbutton.x;
-            wxevent.m_y = local_event.xbutton.y;
-            canvas->GetEventHandler()->ProcessEvent (wxevent);
-#if 0
-            if (eventType == wxEVT_ENTER_WINDOW ||
-                    eventType == wxEVT_LEAVE_WINDOW ||
-                    eventType == wxEVT_MOTION
-               )
-                return;
-#endif // 0

             break;
             break;

-      }
+        }

     case KeyPress:
         {
             wxKeyEvent event (wxEVT_CHAR);
     case KeyPress:
         {
             wxKeyEvent event (wxEVT_CHAR);

-            if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
+            if (wxTranslateKeyEvent (event, canvas, (Widget) 0, xevent))

             {
                 // Implement wxFrame::OnCharHook by checking ancestor.
             {
                 // Implement wxFrame::OnCharHook by checking ancestor.

-                wxWindow *parent = canvas->GetParent();
-                while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
+                wxWindow *parent = canvas;
+                while (parent && !parent->IsTopLevel())

                     parent = parent->GetParent();
 
                 if (parent)
                     parent = parent->GetParent();
 
                 if (parent)


@@ -2308,16 +2054,16 @@ static void wxCanvasInputEvent(Widget drawingArea,
                 // Only process OnChar if OnKeyDown didn't swallow it
                 if (!canvas->GetEventHandler()->ProcessEvent (event))
                 {
                 // Only process OnChar if OnKeyDown didn't swallow it
                 if (!canvas->GetEventHandler()->ProcessEvent (event))
                 {

-                  event.SetEventType(wxEVT_CHAR);
-                  canvas->GetEventHandler()->ProcessEvent (event);
-        }
+                    event.SetEventType(wxEVT_CHAR);
+                    canvas->GetEventHandler()->ProcessEvent (event);
+                }

             }
             break;
         }
     case KeyRelease:
         {
             wxKeyEvent event (wxEVT_KEY_UP);
             }
             break;
         }
     case KeyRelease:
         {
             wxKeyEvent event (wxEVT_KEY_UP);

-            if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
+            if (wxTranslateKeyEvent (event, canvas, (Widget) 0, xevent))

             {
                 canvas->GetEventHandler()->ProcessEvent (event);
             }
             {
                 canvas->GetEventHandler()->ProcessEvent (event);
             }


@@ -2325,7 +2071,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
         }
     case FocusIn:
         {
         }
     case FocusIn:
         {

-            if (local_event.xfocus.detail != NotifyPointer)
+            if (xevent->xfocus.detail != NotifyPointer)

             {
                 wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
                 event.SetEventObject(canvas);
             {
                 wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
                 event.SetEventObject(canvas);


@@ -2335,7 +2081,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
         }
     case FocusOut:
         {
         }
     case FocusOut:
         {

-            if (local_event.xfocus.detail != NotifyPointer)
+            if (xevent->xfocus.detail != NotifyPointer)

             {
                 wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
                 event.SetEventObject(canvas);
             {
                 wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
                 event.SetEventObject(canvas);


@@ -2380,7 +2126,7 @@ static void wxScrollBarCallback(Widget scrollbar,
                                 XmScrollBarCallbackStruct *cbs)
 {
     wxWindow *win = wxGetWindowFromTable(scrollbar);
                                 XmScrollBarCallbackStruct *cbs)
 {
     wxWindow *win = wxGetWindowFromTable(scrollbar);

-    int orientation = (int) clientData;
+    wxOrientation orientation = (wxOrientation)(int)clientData;

 
     wxEventType eventType = wxEVT_NULL;
     switch (cbs->reason)
 
     wxEventType eventType = wxEVT_NULL;
     switch (cbs->reason)


@@ -2435,8 +2181,7 @@ static void wxScrollBarCallback(Widget scrollbar,
 
     wxScrollWinEvent event(eventType,
                            cbs->value,
 
     wxScrollWinEvent event(eventType,
                            cbs->value,

-                           ((orientation == XmHORIZONTAL) ?
-                            wxHORIZONTAL : wxVERTICAL));
+                           orientation);

     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent(event);
 }
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent(event);
 }


@@ -2458,16 +2203,12 @@ void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event,
             window = (Window) win -> GetXWindow();
             display = (Display *) win -> GetXDisplay();
 
             window = (Window) win -> GetXWindow();
             display = (Display *) win -> GetXDisplay();
 

+            win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
+                               event->xexpose.width, event->xexpose.height);
+

             if (event -> xexpose.count == 0)
             {
                 win->DoPaint();
             if (event -> xexpose.count == 0)
             {
                 win->DoPaint();

-
-                win->ClearUpdateRects();
-            }
-            else
-            {
-                win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
-                                   event->xexpose.width, event->xexpose.height);

             }
 
             break;
             }
 
             break;


@@ -2479,30 +2220,49 @@ void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event,
 // TranslateXXXEvent() functions
 // ----------------------------------------------------------------------------
 
 // TranslateXXXEvent() functions
 // ----------------------------------------------------------------------------
 

-bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
+bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win,
+                           Widget widget, const XEvent *xevent)

 {
     switch (xevent->xany.type)
     {
 {
     switch (xevent->xany.type)
     {

-        case EnterNotify:  // never received here - yes ? MB
-        case LeaveNotify:  // never received here - yes ? MB
+        case EnterNotify:
+        case LeaveNotify:
+#if 0
+            fprintf(stderr, "Widget 0x%p <-> window %p (%s), %s\n",
+                    (WXWidget)widget, win, win->GetClassInfo()->GetClassName(),
+                    (xevent->xany.type == EnterNotify ? "ENTER" : "LEAVE"));
+#endif

         case ButtonPress:
         case ButtonRelease:
         case MotionNotify:
         {
         case ButtonPress:
         case ButtonRelease:
         case MotionNotify:
         {

+            int eventx = xevent->xbutton.x, eventy = xevent->xbutton.y;
+

             wxEventType eventType = wxEVT_NULL;
 
             wxEventType eventType = wxEVT_NULL;
 

-            // FIXME: this is never true I think - MB
-            //

             if (xevent->xany.type == LeaveNotify)
             {
             if (xevent->xany.type == LeaveNotify)
             {

-                win->SetButton1(FALSE);
-                win->SetButton2(FALSE);
-                win->SetButton3(FALSE);
-                return FALSE;
+                eventType = wxEVT_LEAVE_WINDOW;
+            }
+            if (xevent->xany.type == EnterNotify)
+            {
+                eventType = wxEVT_ENTER_WINDOW;

             }
             else if (xevent->xany.type == MotionNotify)
             {
                 eventType = wxEVT_MOTION;
             }
             else if (xevent->xany.type == MotionNotify)
             {
                 eventType = wxEVT_MOTION;

+
+                if (xevent->xmotion.is_hint == NotifyHint)
+                {
+                    Window root, child;
+                    int x_root, y_root;
+                    unsigned int state;
+                    Display *dpy = XtDisplay (widget);
+
+                    XQueryPointer (dpy, XtWindow (widget),
+                        &root, &child,
+                        &x_root, &y_root, &eventx, &eventy, &state);
+                }

             }
             else if (xevent->xany.type == ButtonPress)
             {
             }
             else if (xevent->xany.type == ButtonPress)
             {


@@ -2511,30 +2271,28 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_DOWN;
                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_DOWN;

-                    win->SetButton1(TRUE);

                     button = 1;
                 }
                 else if (xevent->xbutton.button == Button2)
                 {
                     eventType = wxEVT_MIDDLE_DOWN;
                     button = 1;
                 }
                 else if (xevent->xbutton.button == Button2)
                 {
                     eventType = wxEVT_MIDDLE_DOWN;

-                    win->SetButton2(TRUE);

                     button = 2;
                 }
                 else if (xevent->xbutton.button == Button3)
                 {
                     eventType = wxEVT_RIGHT_DOWN;
                     button = 2;
                 }
                 else if (xevent->xbutton.button == Button3)
                 {
                     eventType = wxEVT_RIGHT_DOWN;

-                    win->SetButton3(TRUE);

                     button = 3;
                 }
 
                 // check for a double click
                 //
                     button = 3;
                 }
 
                 // check for a double click
                 //

-                long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
+                long dclickTime = XtGetMultiClickTime(xevent->xany.display);

                 long ts = wxevent.GetTimestamp();
 
                 int buttonLast = win->GetLastClickedButton();
                 long lastTS = win->GetLastClickTime();
                 long ts = wxevent.GetTimestamp();
 
                 int buttonLast = win->GetLastClickedButton();
                 long lastTS = win->GetLastClickTime();

-                if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
+                if ( buttonLast && buttonLast == button &&
+                     (ts - lastTS) < dclickTime )

                 {
                     // I have a dclick
                     win->SetLastClick(0, ts);
                 {
                     // I have a dclick
                     win->SetLastClick(0, ts);


@@ -2556,19 +2314,17 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_UP;
                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_UP;

-                    win->SetButton1(FALSE);

                 }
                 else if (xevent->xbutton.button == Button2)
                 {
                     eventType = wxEVT_MIDDLE_UP;
                 }
                 else if (xevent->xbutton.button == Button2)
                 {
                     eventType = wxEVT_MIDDLE_UP;

-                    win->SetButton2(FALSE);

                 }
                 else if (xevent->xbutton.button == Button3)
                 {
                     eventType = wxEVT_RIGHT_UP;
                 }
                 else if (xevent->xbutton.button == Button3)
                 {
                     eventType = wxEVT_RIGHT_UP;

-                    win->SetButton3(FALSE);

                 }
                 }

-                else return FALSE;
+                else
+                    return FALSE;

             }
             else
             {
             }
             else
             {


@@ -2583,7 +2339,7 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
             int x2, y2;
             win->GetPosition(&x2, &y2);
 
             int x2, y2;
             win->GetPosition(&x2, &y2);
 

-            // The button x/y must be translated to wxWindows
+            // The button x/y must be translated to wxWidgets

             // window space - the widget might be a label or button,
             // within a form.
             int dx = 0;
             // window space - the widget might be a label or button,
             // within a form.
             int dx = 0;


@@ -2594,8 +2350,8 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
                 dy = y1;
             }
 
                 dy = y1;
             }
 

-            wxevent.m_x = xevent->xbutton.x + dx;
-            wxevent.m_y = xevent->xbutton.y + dy;
+            wxevent.m_x = eventx + dx;
+            wxevent.m_y = eventy + dy;

 
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
                 || (event_left_is_down (xevent)
 
             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
                 || (event_left_is_down (xevent)


@@ -2622,7 +2378,7 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
 }
 
 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,
 }
 
 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,

-                         Widget WXUNUSED(widget), XEvent *xevent)
+                         Widget WXUNUSED(widget), const XEvent *xevent)

 {
     switch (xevent->xany.type)
     {
 {
     switch (xevent->xany.type)
     {


@@ -2736,30 +2492,16 @@ void wxWindow::ChangeBackgroundColour()
 {
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
 {
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )

-        DoChangeBackgroundColour(mainWidget, m_backgroundColour);
+        wxDoChangeBackgroundColour(mainWidget, m_backgroundColour);

 }
 
 void wxWindow::ChangeForegroundColour()
 {
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )
 }
 
 void wxWindow::ChangeForegroundColour()
 {
     WXWidget mainWidget = GetMainWidget();
     if ( mainWidget )

-        DoChangeForegroundColour(mainWidget, m_foregroundColour);
+        wxDoChangeForegroundColour(mainWidget, m_foregroundColour);

     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )

-        DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
-}
-
-// Change a widget's foreground and background colours.
-void wxWindow::DoChangeForegroundColour(WXWidget widget,
-                                        wxColour& foregroundColour)
-{
-    wxDoChangeForegroundColour( widget, foregroundColour );
-}
-
-void wxWindow::DoChangeBackgroundColour(WXWidget widget,
-                                        wxColour& backgroundColour,
-                                        bool changeArmColour)
-{
-    wxDoChangeBackgroundColour( widget, backgroundColour, changeArmColour );
+        wxDoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);

 }
 
 bool wxWindow::SetBackgroundColour(const wxColour& col)
 }
 
 bool wxWindow::SetBackgroundColour(const wxColour& col)


@@ -2831,7 +2573,7 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt)
 // Get the current mouse position.
 wxPoint wxGetMousePosition()
 {
 // Get the current mouse position.
 wxPoint wxGetMousePosition()
 {

-    Display *display = (Display*) wxGetDisplay();
+    Display *display = wxGlobalDisplay();

     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
     Window rootReturn, childReturn;
     int rootX, rootY, winX, winY;
     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
     Window rootReturn, childReturn;
     int rootX, rootY, winX, winY;