VTK wrapper of vtkRenderWindow for wxPython. Tested on MSW so far.

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

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
index c8537834bf5ff9b043b9e8ec55e4659b8aac12b0..3dd230e4e35f921c708bb6c1b7b9dd4100767238 100644 (file)
--- a/src/motif/window.cpp
+++ b/src/motif/window.cpp
@@ -40,8 +40,6 @@
 #include "wx/menuitem.h"
 #include "wx/log.h"
 
 #include "wx/menuitem.h"
 #include "wx/log.h"
 

-#include "wx/listimpl.cpp"
-

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


@@ -53,6 +51,7 @@
 #include <Xm/ScrollBar.h>
 #include <Xm/Frame.h>
 #include <Xm/Label.h>
 #include <Xm/ScrollBar.h>
 #include <Xm/Frame.h>
 #include <Xm/Label.h>

+#include <Xm/RowColumn.h>           // for XmMenuPosition

 
 #include "wx/motif/private.h"
 
 
 #include "wx/motif/private.h"
 


@@ -79,7 +78,7 @@ static void wxCanvasInputEvent(Widget drawingArea, XtPointer data, XmDrawingArea
 static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
 static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
 static void wxScrollBarCallback(Widget widget, XtPointer clientData,
 static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
 static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
 static void wxScrollBarCallback(Widget widget, XtPointer clientData,

-                                XmScaleCallbackStruct *cbs);
+                                XmScrollBarCallbackStruct *cbs);

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


@@ -116,9 +115,9 @@ static int str16len(const char *s)
 // ----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY
 // ----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY

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

 
 

-    BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
+    BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)

         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
         EVT_IDLE(wxWindow::OnIdle)
     END_EVENT_TABLE()
         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
         EVT_IDLE(wxWindow::OnIdle)
     END_EVENT_TABLE()


@@ -128,12 +127,6 @@ static int str16len(const char *s)
 // implementation
 // ============================================================================
 
 // implementation
 // ============================================================================
 

-// ----------------------------------------------------------------------------
-// list types
-// ----------------------------------------------------------------------------
-
-WX_DEFINE_LIST(wxRectList);
-

 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------


@@ -182,7 +175,8 @@ void wxWindow::Init()
     m_winCaptured = FALSE;
 
     m_isShown = TRUE;
     m_winCaptured = FALSE;
 
     m_isShown = TRUE;

-
+    m_isBeingDeleted = FALSE;
+    

     m_hScrollBar =
     m_vScrollBar =
     m_borderWidget =
     m_hScrollBar =
     m_vScrollBar =
     m_borderWidget =


@@ -216,7 +210,7 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 {
     wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
 
 {
     wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
 

-    CreateBase(parent, id, pos, size, style, name);
+    CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);

 
     parent->AddChild(this);
 
 
     parent->AddChild(this);
 


@@ -251,7 +245,18 @@ 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 & wxBORDER)
+    
+    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
                                    (
     {
         m_borderWidget = (WXWidget)XtVaCreateManagedWidget
                                    (


@@ -260,6 +265,15 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
                                     XmNshadowType, XmSHADOW_IN,
                                     NULL
                                    );
                                     XmNshadowType, XmSHADOW_IN,
                                     NULL
                                    );

+    } else if (style & wxRAISED_BORDER)
+    {
+        m_borderWidget = (WXWidget)XtVaCreateManagedWidget
+                                   (
+                                    "canvasBorder",
+                                    xmFrameWidgetClass, parentWidget,
+                                    XmNshadowType, XmSHADOW_OUT,
+                                    NULL
+                                   );

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


@@ -359,6 +373,8 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 // Destructor
 wxWindow::~wxWindow()
 {
 // Destructor
 wxWindow::~wxWindow()
 {

+    m_isBeingDeleted = TRUE;
+    

     // Motif-specific actions first
     WXWidget wMain = GetMainWidget();
     if ( wMain )
     // Motif-specific actions first
     WXWidget wMain = GetMainWidget();
     if ( wMain )


@@ -369,6 +385,9 @@ wxWindow::~wxWindow()
 
     ClearUpdateRects();
 
 
     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 )


@@ -395,6 +414,15 @@ wxWindow::~wxWindow()
             wxDeleteWindowFromTable((Widget) m_scrolledWindow);
         }
 
             wxDeleteWindowFromTable((Widget) m_scrolledWindow);
         }
 

+        if (m_hScrollBar)
+        {
+            wxDeleteWindowFromTable((Widget) m_hScrollBar);
+        }
+        if (m_vScrollBar)
+        {
+            wxDeleteWindowFromTable((Widget) m_vScrollBar);
+        }
+

         UnmanageAndDestroy(m_hScrollBar);
         UnmanageAndDestroy(m_vScrollBar);
         UnmanageAndDestroy(m_scrolledWindow);
         UnmanageAndDestroy(m_hScrollBar);
         UnmanageAndDestroy(m_vScrollBar);
         UnmanageAndDestroy(m_scrolledWindow);


@@ -463,6 +491,8 @@ void wxWindow::CreateScrollbar(wxOrientation orientation)
             NULL);
 
         m_hScroll = TRUE;
             NULL);
 
         m_hScroll = TRUE;

+
+        wxAddWindowToTable( hScrollBar, this );

     }
 
     if (orientation == wxVERTICAL)
     }
 
     if (orientation == wxVERTICAL)


@@ -496,6 +526,8 @@ void wxWindow::CreateScrollbar(wxOrientation orientation)
             NULL);
 
         m_vScroll = TRUE;
             NULL);
 
         m_vScroll = TRUE;

+
+        wxAddWindowToTable( vScrollBar, this );

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


@@ -511,6 +543,7 @@ void wxWindow::DestroyScrollbar(wxOrientation orientation)
     {
         if (m_hScrollBar)
         {
     {
         if (m_hScrollBar)
         {

+            wxDeleteWindowFromTable((Widget)m_hScrollBar);

             XtDestroyWidget((Widget) m_hScrollBar);
         }
         m_hScrollBar = (WXWidget) 0;
             XtDestroyWidget((Widget) m_hScrollBar);
         }
         m_hScrollBar = (WXWidget) 0;


@@ -526,6 +559,7 @@ void wxWindow::DestroyScrollbar(wxOrientation orientation)
     {
         if (m_vScrollBar)
         {
     {
         if (m_vScrollBar)
         {

+            wxDeleteWindowFromTable((Widget)m_vScrollBar);

             XtDestroyWidget((Widget) m_vScrollBar);
         }
         m_vScrollBar = (WXWidget) 0;
             XtDestroyWidget((Widget) m_vScrollBar);
         }
         m_vScrollBar = (WXWidget) 0;


@@ -697,7 +731,7 @@ bool wxWindow::SetCursor(const wxCursor& cursor)
     }
 
     wxASSERT_MSG( m_cursor.Ok(),
     }
 
     wxASSERT_MSG( m_cursor.Ok(),

-                  _T("cursor must be valid after call to the base version"));
+                  wxT("cursor must be valid after call to the base version"));

 
     WXDisplay *dpy = GetXDisplay();
     WXCursor x_cursor = m_cursor.GetXCursor(dpy);
 
     WXDisplay *dpy = GetXDisplay();
     WXCursor x_cursor = m_cursor.GetXCursor(dpy);


@@ -866,6 +900,18 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         GetClientSize(& w, & h);
     }
 
         GetClientSize(& w, & h);
     }
 

+    wxNode *cnode = m_children.First();
+    while (cnode)
+    {
+        wxWindow *child = (wxWindow*) cnode->Data();
+       int sx = 0;
+       int sy = 0;
+       child->GetSize( &sx, &sy );
+        wxPoint pos( child->GetPosition() );
+       child->SetSize( pos.x + dx, pos.y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
+       cnode = cnode->Next();
+    }
+

     int x1 = (dx >= 0) ? x : x - dx;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);
     int x1 = (dx >= 0) ? x : x - dx;
     int y1 = (dy >= 0) ? y : y - dy;
     int w1 = w - abs(dx);


@@ -1040,6 +1086,76 @@ void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
 
 #endif // wxUSE_TOOLTIPS
 
 
 #endif // wxUSE_TOOLTIPS
 

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

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


@@ -1307,12 +1423,12 @@ void wxWindow::GetTextExtent(const wxString& string,
         fontToUse = (wxFont *) & m_font;
 
     wxCHECK_RET( fontToUse->Ok(), "valid window font needed" );
         fontToUse = (wxFont *) & m_font;
 
     wxCHECK_RET( fontToUse->Ok(), "valid window font needed" );

-
+    

     WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
 
     int direction, ascent, descent2;
     XCharStruct overall;
     WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
 
     int direction, ascent, descent2;
     XCharStruct overall;

-    int slen;
+    int slen = string.Len();

 
 #if 0
     if (use16)
 
 #if 0
     if (use16)


@@ -1331,6 +1447,7 @@ void wxWindow::GetTextExtent(const wxString& string,
         *descent = descent2;
     if (externalLeading)
         *externalLeading = 0;
         *descent = descent2;
     if (externalLeading)
         *externalLeading = 0;

+

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


@@ -1498,7 +1615,7 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
     }
 }
 

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

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


@@ -1540,7 +1657,7 @@ bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
                 // Try for a menu command
                 if (frame->GetMenuBar())
                 {
                 // Try for a menu command
                 if (frame->GetMenuBar())
                 {

-                    wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
+                    wxMenuItem* item = frame->GetMenuBar()->FindItem(entry->GetCommand());

                     if (item)
                     {
                         wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
                     if (item)
                     {
                         wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());


@@ -1597,6 +1714,9 @@ bool wxAddWindowToTable(Widget w, wxWindow *win)
 
     wxWidgetHashTable->Put((long) w, win);
 
 
     wxWidgetHashTable->Put((long) w, win);
 

+    wxLogDebug("Widget 0x%08x <-> window %p (%s)",
+               w, win, win->GetClassInfo()->GetClassName());
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -1615,7 +1735,7 @@ void wxDeleteWindowFromTable(Widget w)
 // ----------------------------------------------------------------------------
 
 // Add to hash table, add event handler
 // ----------------------------------------------------------------------------
 
 // Add to hash table, add event handler

-bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
+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);


@@ -1729,7 +1849,7 @@ 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 *event, String args[], int *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)


@@ -1759,22 +1879,14 @@ static void wxCanvasRepaintProc(Widget drawingArea,
     {
     case Expose:
         {
     {
     case Expose:
         {

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

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

-#if 0
-                wxPaintEvent event(win->GetId());
-                event.SetEventObject(win);
-                win->GetEventHandler()->ProcessEvent(event);
-#endif // 0
-

                 win->DoPaint();
                 win->ClearUpdateRects();
             }
                 win->DoPaint();
                 win->ClearUpdateRects();
             }

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

             break;
         }
     }
             break;
         }
     }


@@ -1782,7 +1894,7 @@ static void wxCanvasRepaintProc(Widget drawingArea,
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
 static void wxCanvasEnterLeave(Widget drawingArea,
 
 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
 static void wxCanvasEnterLeave(Widget drawingArea,

-                               XtPointer clientData,
+                               XtPointer WXUNUSED(clientData),

                                XCrossingEvent * event)
 {
     XmDrawingAreaCallbackStruct cbs;
                                XCrossingEvent * event)
 {
     XmDrawingAreaCallbackStruct cbs;


@@ -1797,7 +1909,7 @@ static void wxCanvasEnterLeave(Widget drawingArea,
 }
 
 // Fix to make it work under Motif 1.0 (!)
 }
 
 // Fix to make it work under Motif 1.0 (!)

-static void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
+static void wxCanvasMotionEvent (Widget WXUNUSED(drawingArea), XButtonEvent * WXUNUSED(event))

 {
 #if XmVersion <= 1000
     XmDrawingAreaCallbackStruct cbs;
 {
 #if XmVersion <= 1000
     XmDrawingAreaCallbackStruct cbs;


@@ -1812,7 +1924,7 @@ static void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
 }
 
 static void wxCanvasInputEvent(Widget drawingArea,
 }
 
 static void wxCanvasInputEvent(Widget drawingArea,

-                               XtPointer data,
+                               XtPointer WXUNUSED(data),

                                XmDrawingAreaCallbackStruct * cbs)
 {
     wxWindow *canvas = wxGetWindowFromTable(drawingArea);
                                XmDrawingAreaCallbackStruct * cbs)
 {
     wxWindow *canvas = wxGetWindowFromTable(drawingArea);


@@ -1834,6 +1946,9 @@ 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)
             wxEventType eventType = wxEVT_NULL;
 
             if (local_event.xany.type == EnterNotify)


@@ -1845,7 +1960,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
             }
             else if (local_event.xany.type == LeaveNotify)
             {
             }
             else if (local_event.xany.type == LeaveNotify)
             {

-                //if (local_event.xcrossing.mode!=NotifyNormal)
+                //if (local_event.xcrossingr.mode!=NotifyNormal)

                 //  return ; // Ignore grab events
                 eventType = wxEVT_LEAVE_WINDOW;
                 //            canvas->GetEventHandler()->OnKillFocus();
                 //  return ; // Ignore grab events
                 eventType = wxEVT_LEAVE_WINDOW;
                 //            canvas->GetEventHandler()->OnKillFocus();


@@ -2095,7 +2210,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
 }
 
 static void wxPanelItemEventHandler(Widget    wid,
 }
 
 static void wxPanelItemEventHandler(Widget    wid,

-                                    XtPointer client_data,
+                                    XtPointer WXUNUSED(client_data),

                                     XEvent*   event,
                                     Boolean  *continueToDispatch)
 {
                                     XEvent*   event,
                                     Boolean  *continueToDispatch)
 {


@@ -2123,7 +2238,7 @@ static void wxPanelItemEventHandler(Widget    wid,
 
 static void wxScrollBarCallback(Widget scrollbar,
                                 XtPointer clientData,
 
 static void wxScrollBarCallback(Widget scrollbar,
                                 XtPointer clientData,

-                                XmScaleCallbackStruct *cbs)
+                                XmScrollBarCallbackStruct *cbs)

 {
     wxWindow *win = wxGetWindowFromTable(scrollbar);
     int orientation = (int) clientData;
 {
     wxWindow *win = wxGetWindowFromTable(scrollbar);
     int orientation = (int) clientData;


@@ -2133,44 +2248,44 @@ static void wxScrollBarCallback(Widget scrollbar,
     {
     case XmCR_INCREMENT:
         {
     {
     case XmCR_INCREMENT:
         {

-            eventType = wxEVT_SCROLL_LINEDOWN;
+            eventType = wxEVT_SCROLLWIN_LINEDOWN;

             break;
         }
     case XmCR_DECREMENT:
         {
             break;
         }
     case XmCR_DECREMENT:
         {

-            eventType = wxEVT_SCROLL_LINEUP;
+            eventType = wxEVT_SCROLLWIN_LINEUP;

             break;
         }
     case XmCR_DRAG:
         {
             break;
         }
     case XmCR_DRAG:
         {

-            eventType = wxEVT_SCROLL_THUMBTRACK;
+            eventType = wxEVT_SCROLLWIN_THUMBTRACK;

             break;
         }
     case XmCR_VALUE_CHANGED:
         {
             // TODO: Should this be intercepted too, or will it cause
             // duplicate events?
             break;
         }
     case XmCR_VALUE_CHANGED:
         {
             // TODO: Should this be intercepted too, or will it cause
             // duplicate events?

-            eventType = wxEVT_SCROLL_THUMBTRACK;
+            eventType = wxEVT_SCROLLWIN_THUMBTRACK;

             break;
         }
     case XmCR_PAGE_INCREMENT:
         {
             break;
         }
     case XmCR_PAGE_INCREMENT:
         {

-            eventType = wxEVT_SCROLL_PAGEDOWN;
+            eventType = wxEVT_SCROLLWIN_PAGEDOWN;

             break;
         }
     case XmCR_PAGE_DECREMENT:
         {
             break;
         }
     case XmCR_PAGE_DECREMENT:
         {

-            eventType = wxEVT_SCROLL_PAGEUP;
+            eventType = wxEVT_SCROLLWIN_PAGEUP;

             break;
         }
     case XmCR_TO_TOP:
         {
             break;
         }
     case XmCR_TO_TOP:
         {

-            eventType = wxEVT_SCROLL_TOP;
+            eventType = wxEVT_SCROLLWIN_TOP;

             break;
         }
     case XmCR_TO_BOTTOM:
         {
             break;
         }
     case XmCR_TO_BOTTOM:
         {

-            eventType = wxEVT_SCROLL_BOTTOM;
+            eventType = wxEVT_SCROLLWIN_BOTTOM;

             break;
         }
     default:
             break;
         }
     default:


@@ -2181,11 +2296,11 @@ static void wxScrollBarCallback(Widget scrollbar,
         }
     }
 
         }
     }
 

-    wxScrollEvent event(eventType, win->GetId());
-    event.SetEventObject(win);
-    event.SetPosition(cbs->value);
-    event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
-
+    wxScrollWinEvent event(eventType,
+                           cbs->value,
+                           ((orientation == XmHORIZONTAL) ?
+                            wxHORIZONTAL : wxVERTICAL));
+    event.SetEventObject( win );

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


@@ -2454,14 +2569,16 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
 {
     switch (xevent->xany.type)
     {
 {
     switch (xevent->xany.type)
     {

-    case EnterNotify:
-    case LeaveNotify:
-    case ButtonPress:
-    case ButtonRelease:
-    case MotionNotify:
+        case EnterNotify:  // never received here - yes ? MB
+        case LeaveNotify:  // never received here - yes ? MB
+        case ButtonPress:
+        case ButtonRelease:
+        case MotionNotify:

         {
             wxEventType eventType = wxEVT_NULL;
 
         {
             wxEventType eventType = wxEVT_NULL;
 

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

             if (xevent->xany.type == LeaveNotify)
             {
                 win->SetButton1(FALSE);
             if (xevent->xany.type == LeaveNotify)
             {
                 win->SetButton1(FALSE);


@@ -2475,20 +2592,59 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
             }
             else if (xevent->xany.type == ButtonPress)
             {
             }
             else if (xevent->xany.type == ButtonPress)
             {

+                wxevent.SetTimestamp(xevent->xbutton.time);
+                int button = 0;

                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_DOWN;
                     win->SetButton1(TRUE);
                 if (xevent->xbutton.button == Button1)
                 {
                     eventType = wxEVT_LEFT_DOWN;
                     win->SetButton1(TRUE);

+                    button = 1;

                 }
                 else if (xevent->xbutton.button == Button2)
                 {
                     eventType = wxEVT_MIDDLE_DOWN;
                     win->SetButton2(TRUE);
                 }
                 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;
                     win->SetButton3(TRUE);
                 }
                 else if (xevent->xbutton.button == Button3)
                 {
                     eventType = wxEVT_RIGHT_DOWN;
                     win->SetButton3(TRUE);

+                    button = 3;
+                }
+
+                // check for a double click
+                //
+                long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
+                long ts = wxevent.GetTimestamp();
+
+                int buttonLast = win->GetLastClickedButton();
+                long lastTS = win->GetLastClickTime();
+                if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
+                {
+                    // I have a dclick
+                    win->SetLastClick(0, ts);
+                    switch ( eventType )
+                    {
+                        case wxEVT_LEFT_DOWN:
+                            eventType = wxEVT_LEFT_DCLICK;
+                            break;
+                        case wxEVT_MIDDLE_DOWN:
+                            eventType = wxEVT_MIDDLE_DCLICK;
+                            break;
+                        case wxEVT_RIGHT_DOWN:
+                            eventType = wxEVT_RIGHT_DCLICK;
+                            break;
+
+                        default :
+                            break;
+                    }
+                    
+                }
+                else
+                {
+                    // not fast enough or different button
+                    win->SetLastClick(button, ts);

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


@@ -2549,17 +2705,24 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
 
             wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
             wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
 
             wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
             wxevent.m_controlDown = xevent->xbutton.state & ControlMask;

+            wxevent.m_altDown = xevent->xbutton.state & Mod3Mask;
+            wxevent.m_metaDown = xevent->xbutton.state & Mod1Mask;
+
+            wxevent.SetId(win->GetId());
+            wxevent.SetEventObject(win);
+

             return TRUE;
         }
     }
     return FALSE;
 }
 
             return TRUE;
         }
     }
     return FALSE;
 }
 

-bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
+bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget WXUNUSED(widget), XEvent *xevent)

 {
     switch (xevent->xany.type)
     {
     case KeyPress:
 {
     switch (xevent->xany.type)
     {
     case KeyPress:

+    case KeyRelease:

         {
             char buf[20];
 
         {
             char buf[20];
 


@@ -2797,3 +2960,7 @@ wxWindow *wxGetActiveWindow()
 // ----------------------------------------------------------------------------
 
 int wxNoOptimize::ms_count = 0;
 // ----------------------------------------------------------------------------
 
 int wxNoOptimize::ms_count = 0;

+
+
+
+