+
+WXWidget wxWindow::GetTopWidget() const
+{
+ return GetMainWidget();
+}
+
+WXWidget wxWindow::GetLabelWidget() const
+{
+ return GetMainWidget();
+}
+
+// ----------------------------------------------------------------------------
+// Motif callbacks
+// ----------------------------------------------------------------------------
+
+// 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)
+{
+ wxWindow *win = wxGetWindowFromTable(w);
+ if (!win)
+ return;
+
+ if (win->PreResize())
+ {
+ int width, height;
+ win->GetSize(&width, &height);
+ wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
+ sizeEvent.SetEventObject(win);
+ win->GetEventHandler()->ProcessEvent(sizeEvent);
+ }
+}
+
+static void wxCanvasRepaintProc(Widget drawingArea,
+ XtPointer clientData,
+ XmDrawingAreaCallbackStruct * cbs)
+{
+ if (!wxGetWindowFromTable(drawingArea))
+ return;
+
+ XEvent * event = cbs->event;
+ wxWindow * win = (wxWindow *) clientData;
+
+ switch (event->type)
+ {
+ case Expose:
+ {
+ if (event -> xexpose.count == 0)
+ {
+#if 0
+ wxPaintEvent event(win->GetId());
+ event.SetEventObject(win);
+ win->GetEventHandler()->ProcessEvent(event);
+#endif // 0
+
+ win->DoPaint();
+ win->ClearUpdateRects();
+ }
+ else
+ {
+ win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
+ event->xexpose.width, event->xexpose.height);
+ }
+ break;
+ }
+ }
+}
+
+// Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
+static void wxCanvasEnterLeave(Widget drawingArea,
+ XtPointer clientData,
+ XCrossingEvent * event)
+{
+ XmDrawingAreaCallbackStruct cbs;
+ XEvent ev;
+
+ ((XCrossingEvent &) ev) = *event;
+
+ cbs.reason = XmCR_INPUT;
+ cbs.event = &ev;
+
+ wxCanvasInputEvent(drawingArea, (XtPointer) NULL, &cbs);
+}
+
+// Fix to make it work under Motif 1.0 (!)
+static void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
+{
+#if XmVersion <= 1000
+ XmDrawingAreaCallbackStruct cbs;
+ XEvent ev;
+
+ ev = *((XEvent *) event);
+ cbs.reason = XmCR_INPUT;
+ cbs.event = &ev;
+
+ wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
+#endif // XmVersion <= 1000
+}
+
+static void wxCanvasInputEvent(Widget drawingArea,
+ XtPointer data,
+ XmDrawingAreaCallbackStruct * cbs)
+{
+ wxWindow *canvas = wxGetWindowFromTable(drawingArea);
+ XEvent local_event;
+
+ if (canvas==NULL)
+ return;
+
+ if (cbs->reason != XmCR_INPUT)
+ return;
+
+ local_event = *(cbs->event); // We must keep a copy!
+
+ switch (local_event.xany.type)
+ {
+ case EnterNotify:
+ case LeaveNotify:
+ case ButtonPress:
+ case ButtonRelease:
+ case MotionNotify:
+ {
+ 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.xcrossing.mode!=NotifyNormal)
+ // return ; // Ignore grab events
+ eventType = wxEVT_LEAVE_WINDOW;
+ // canvas->GetEventHandler()->OnKillFocus();
+ }
+ else if (local_event.xany.type == MotionNotify)
+ {
+ 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
+ {
+ }
+ }
+
+ 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);
+
+ // 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);
+ switch ( eventType )
+ {
+ case wxEVT_LEFT_DOWN:
+ wxevent.SetEventType(wxEVT_LEFT_DCLICK);
+ break;
+ case wxEVT_MIDDLE_DOWN:
+ wxevent.SetEventType(wxEVT_MIDDLE_DCLICK);
+ break;
+ case wxEVT_RIGHT_DOWN:
+ wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
+ break;
+
+ default :
+ break;
+ }
+
+ }
+ 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;
+ }
+ case KeyPress:
+ {
+ KeySym keySym;
+#if 0
+ XComposeStatus compose;
+ (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
+#endif // 0
+
+ (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
+ int id = wxCharCodeXToWX (keySym);
+
+ wxEventType eventType = wxEVT_CHAR;
+
+ wxKeyEvent event (eventType);
+
+ if (local_event.xkey.state & ShiftMask)
+ event.m_shiftDown = TRUE;
+ if (local_event.xkey.state & ControlMask)
+ event.m_controlDown = TRUE;
+ if (local_event.xkey.state & Mod3Mask)
+ event.m_altDown = TRUE;
+ if (local_event.xkey.state & Mod1Mask)
+ event.m_metaDown = TRUE;
+ event.SetEventObject(canvas);
+ event.m_keyCode = id;
+ event.SetTimestamp(local_event.xkey.time);
+
+ if (id > -1)
+ {
+ // Implement wxFrame::OnCharHook by checking ancestor.
+ wxWindow *parent = canvas->GetParent();
+ while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
+ parent = parent->GetParent();
+
+ if (parent)
+ {
+ event.SetEventType(wxEVT_CHAR_HOOK);
+ if (parent->GetEventHandler()->ProcessEvent(event))
+ return;
+ }
+
+ // For simplicity, OnKeyDown is the same as OnChar
+ // TODO: filter modifier key presses from OnChar
+ event.SetEventType(wxEVT_KEY_DOWN);
+
+ // Only process OnChar if OnKeyDown didn't swallow it
+ if (!canvas->GetEventHandler()->ProcessEvent (event))
+ {
+ event.SetEventType(wxEVT_CHAR);
+ canvas->GetEventHandler()->ProcessEvent (event);
+ }
+ }
+ break;
+ }
+ case KeyRelease:
+ {
+ KeySym keySym;
+ (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
+ int id = wxCharCodeXToWX (keySym);
+
+ wxKeyEvent event (wxEVT_KEY_UP);
+
+ if (local_event.xkey.state & ShiftMask)
+ event.m_shiftDown = TRUE;
+ if (local_event.xkey.state & ControlMask)
+ event.m_controlDown = TRUE;
+ if (local_event.xkey.state & Mod3Mask)
+ event.m_altDown = TRUE;
+ if (local_event.xkey.state & Mod1Mask)
+ event.m_metaDown = TRUE;
+ event.SetEventObject(canvas);
+ event.m_keyCode = id;
+ event.SetTimestamp(local_event.xkey.time);
+
+ if (id > -1)
+ {
+ canvas->GetEventHandler()->ProcessEvent (event);
+ }
+ break;
+ }
+ case FocusIn:
+ {
+ if (local_event.xfocus.detail != NotifyPointer)
+ {
+ wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
+ event.SetEventObject(canvas);
+ canvas->GetEventHandler()->ProcessEvent(event);
+ }
+ break;
+ }
+ case FocusOut:
+ {
+ if (local_event.xfocus.detail != NotifyPointer)
+ {
+ wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
+ event.SetEventObject(canvas);
+ canvas->GetEventHandler()->ProcessEvent(event);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+static void wxPanelItemEventHandler(Widget wid,
+ XtPointer client_data,
+ XEvent* event,
+ Boolean *continueToDispatch)
+{
+ // Widget can be a label or the actual widget.
+
+ wxWindow *window = wxGetWindowFromTable(wid);
+ if (window)
+ {
+ wxMouseEvent wxevent(0);
+ if (wxTranslateMouseEvent(wxevent, window, wid, event))
+ {
+ window->GetEventHandler()->ProcessEvent(wxevent);
+ }
+ }
+
+ // TODO: probably the key to allowing default behaviour to happen. Say we
+ // set a m_doDefault flag to FALSE at the start of this function. Then in
+ // e.g. wxWindow::OnMouseEvent we can call Default() which sets this flag to
+ // TRUE, indicating that default processing can happen. Thus, behaviour can
+ // appear to be overridden just by adding an event handler and not calling
+ // wxWindow::OnWhatever. ALSO, maybe we can use this instead of the current
+ // way of handling drawing area events, to simplify things.
+ *continueToDispatch = True;
+}
+
+static void wxScrollBarCallback(Widget scrollbar,
+ XtPointer clientData,
+ XmScaleCallbackStruct *cbs)
+{
+ wxWindow *win = wxGetWindowFromTable(scrollbar);
+ 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);
+}
+
+// For repainting arbitrary windows
+void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *)
+{
+ Window window;
+ Display *display;
+
+ wxWindow* win = wxGetWindowFromTable(w);
+ if (!win)
+ return;
+
+ switch(event -> type)
+ {
+ case Expose:
+ {
+ window = (Window) win -> GetXWindow();
+ display = (Display *) win -> GetXDisplay();
+
+ 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;
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+// CanvaseXXXSize() functions
+// ----------------------------------------------------------------------------
+
+// SetSize, but as per old wxCanvas (with drawing widget etc.)
+void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
+{
+ // 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 (!wxNoOptimize::CanOptimize())
+ {
+ useOldSize = FALSE; useOldPos = FALSE;
+ }
+
+ if (useOldPos && useOldSize)
+ return;
+
+ Widget drawingArea = (Widget) m_drawingArea;
+ bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
+
+ if (managed)
+ XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
+ XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
+
+ 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,
+ XmNx, xx, NULL);
+ }
+
+ if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+ {
+ XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
+ XmNy, yy, NULL);
+ }
+ }
+
+ if (!useOldSize)
+ {
+
+ if (w > -1)
+ {
+ if (m_borderWidget)
+ {
+ XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
+ short thick, margin;
+ XtVaGetValues ((Widget) m_borderWidget,
+ XmNshadowThickness, &thick,
+ XmNmarginWidth, &margin,
+ NULL);
+ w -= 2 * (thick + margin);
+ }
+
+ XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
+
+ Dimension spacing;
+ Widget sbar;
+ XtVaGetValues ((Widget) m_scrolledWindow,
+ XmNspacing, &spacing,
+ XmNverticalScrollBar, &sbar,
+ NULL);
+ Dimension wsbar;
+ if (sbar)
+ XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
+ else
+ wsbar = 0;
+
+ w -= (spacing + wsbar);
+
+#if 0
+ XtVaSetValues(drawingArea, XmNwidth, w, NULL);
+#endif // 0
+ }
+ if (h > -1)
+ {
+ if (m_borderWidget)
+ {
+ XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
+ short thick, margin;
+ XtVaGetValues ((Widget) m_borderWidget,
+ XmNshadowThickness, &thick,
+ XmNmarginHeight, &margin,
+ NULL);
+ h -= 2 * (thick + margin);
+ }
+
+ XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
+
+ Dimension spacing;
+ Widget sbar;
+ XtVaGetValues ((Widget) m_scrolledWindow,
+ XmNspacing, &spacing,
+ XmNhorizontalScrollBar, &sbar,
+ NULL);
+ Dimension wsbar;
+ if (sbar)
+ XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
+ else
+ wsbar = 0;
+
+ h -= (spacing + wsbar);
+
+#if 0
+ XtVaSetValues(drawingArea, XmNheight, h, NULL);
+#endif // 0
+ }
+ }
+
+ if (managed)
+ XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
+ XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
+
+#if 0
+ int ww, hh;
+ GetClientSize (&ww, &hh);
+ wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
+ sizeEvent.SetEventObject(this);
+
+ GetEventHandler()->ProcessEvent(sizeEvent);
+#endif // 0
+}
+
+void wxWindow::CanvasSetClientSize (int w, int h)
+{
+ Widget drawingArea = (Widget) m_drawingArea;
+
+ XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
+
+ if (w > -1)
+ XtVaSetValues(drawingArea, XmNwidth, w, NULL);
+ if (h > -1)
+ XtVaSetValues(drawingArea, XmNheight, h, NULL);
+
+#if 0
+ // TODO: is this necessary?
+ allowRepainting = FALSE;
+
+ XSync (XtDisplay (drawingArea), FALSE);
+ XEvent event;
+ while (XtAppPending (wxTheApp->appContext))
+ {
+ XFlush (XtDisplay (drawingArea));
+ XtAppNextEvent (wxTheApp->appContext, &event);
+ XtDispatchEvent (&event);
+ }
+#endif // 0
+
+ XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
+
+#if 0
+ allowRepainting = TRUE;
+ DoRefresh ();
+
+ wxSizeEvent sizeEvent(wxSize(w, h), GetId());
+ sizeEvent.SetEventObject(this);
+
+ GetEventHandler()->ProcessEvent(sizeEvent);
+#endif // 0
+}
+
+void wxWindow::CanvasGetClientSize (int *w, int *h) const
+{
+ // Must return the same thing that was set via SetClientSize
+ Dimension xx, yy;
+ XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
+ *w = xx;
+ *h = yy;
+}
+
+void wxWindow::CanvasGetSize (int *w, int *h) const
+{
+ Dimension xx, yy;
+ if ((Widget) m_borderWidget)
+ XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
+ else if ((Widget) m_scrolledWindow)
+ XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
+ else
+ XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
+
+ *w = xx;
+ *h = yy;
+}
+
+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);
+
+ // 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;
+}
+
+// ----------------------------------------------------------------------------
+// TranslateXXXEvent() functions
+// ----------------------------------------------------------------------------
+
+bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
+{
+ switch (xevent->xany.type)
+ {
+ case EnterNotify:
+ case LeaveNotify:
+ case ButtonPress:
+ case ButtonRelease:
+ case MotionNotify:
+ {
+ wxEventType eventType = wxEVT_NULL;
+
+ if (xevent->xany.type == LeaveNotify)
+ {
+ win->SetButton1(FALSE);
+ win->SetButton2(FALSE);
+ win->SetButton3(FALSE);
+ return FALSE;
+ }
+ else if (xevent->xany.type == MotionNotify)
+ {
+ eventType = wxEVT_MOTION;
+ }
+ else if (xevent->xany.type == ButtonPress)
+ {
+ if (xevent->xbutton.button == Button1)
+ {
+ eventType = wxEVT_LEFT_DOWN;
+ win->SetButton1(TRUE);
+ }
+ else if (xevent->xbutton.button == Button2)
+ {
+ eventType = wxEVT_MIDDLE_DOWN;
+ win->SetButton2(TRUE);
+ }
+ else if (xevent->xbutton.button == Button3)
+ {
+ eventType = wxEVT_RIGHT_DOWN;
+ win->SetButton3(TRUE);
+ }
+ }
+ else if (xevent->xany.type == ButtonRelease)
+ {
+ if (xevent->xbutton.button == Button1)
+ {
+ eventType = wxEVT_LEFT_UP;
+ win->SetButton1(FALSE);
+ }
+ else if (xevent->xbutton.button == Button2)
+ {
+ eventType = wxEVT_MIDDLE_UP;
+ win->SetButton2(FALSE);
+ }
+ else if (xevent->xbutton.button == Button3)
+ {
+ eventType = wxEVT_RIGHT_UP;
+ win->SetButton3(FALSE);
+ }
+ else return FALSE;
+ }
+ else
+ {
+ return FALSE;
+ }
+
+ wxevent.SetEventType(eventType);
+
+ Position x1, y1;
+ XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
+
+ int x2, y2;
+ win->GetPosition(&x2, &y2);
+
+ // The button x/y must be translated to wxWindows
+ // window space - the widget might be a label or button,
+ // within a form.
+ int dx = 0;
+ int dy = 0;
+ if (widget != (Widget)win->GetMainWidget())
+ {
+ dx = x1;
+ dy = y1;
+ }
+
+ wxevent.m_x = xevent->xbutton.x + dx;
+ wxevent.m_y = xevent->xbutton.y + dy;
+
+ wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
+ || (event_left_is_down (xevent)
+ && (eventType != wxEVT_LEFT_UP)));
+ wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
+ || (event_middle_is_down (xevent)
+ && (eventType != wxEVT_MIDDLE_UP)));
+ wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
+ || (event_right_is_down (xevent)
+ && (eventType != wxEVT_RIGHT_UP)));
+
+ wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
+ wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
+{
+ switch (xevent->xany.type)
+ {
+ case KeyPress:
+ case KeyRelease:
+ {
+ char buf[20];
+
+ KeySym keySym;
+#if 0
+ XComposeStatus compose;
+ (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
+#endif // 0
+ (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
+ int id = wxCharCodeXToWX (keySym);
+
+ if (xevent->xkey.state & ShiftMask)
+ wxevent.m_shiftDown = TRUE;
+ if (xevent->xkey.state & ControlMask)
+ wxevent.m_controlDown = TRUE;
+ if (xevent->xkey.state & Mod3Mask)
+ wxevent.m_altDown = TRUE;
+ if (xevent->xkey.state & Mod1Mask)
+ wxevent.m_metaDown = TRUE;
+ wxevent.SetEventObject(win);
+ wxevent.m_keyCode = id;
+ wxevent.SetTimestamp(xevent->xkey.time);
+
+ wxevent.m_x = xevent->xbutton.x;
+ wxevent.m_y = xevent->xbutton.y;
+
+ if (id > -1)
+ return TRUE;
+ else
+ return FALSE;
+ break;
+ }
+ default:
+ break;
+ }
+ return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// Colour stuff
+// ----------------------------------------------------------------------------
+
+#define YAllocColor XAllocColor
+XColor g_itemColors[5];
+int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
+{
+ int result;
+ static XmColorProc colorProc;
+
+ result = wxNO_COLORS;
+
+ if (back)
+ {
+ 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
+ colorProc = XmSetColorCalculation ((XmColorProc) NULL);
+ // And set it back to motif.
+ XmSetColorCalculation (colorProc);
+ }
+ (*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)
+ {
+ 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;
+ }
+
+ Display *dpy = display;
+ Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
+
+ if (back)
+ {
+ /* 5 Colours to allocate */
+ for (int i = 0; i < 5; i++)
+ if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
+ result = wxNO_COLORS;
+ }
+ else if (fore)
+ {
+ /* Only 1 colour to allocate */
+ if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
+ result = wxNO_COLORS;
+ }
+
+ return (result);
+
+}
+
+// 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()
+{
+ WXWidget mainWidget = GetMainWidget();
+ if ( mainWidget )
+ DoChangeBackgroundColour(mainWidget, m_backgroundColour);
+
+ // This not necessary
+#if 0
+
+ if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
+ {
+ DoChangeBackgroundColour(m_scrolledWindow, m_backgroundColour);
+ // Have to set the scrollbar colours back since
+ // the scrolled window seemed to change them
+ wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+
+ if (m_hScrollBar)
+ DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
+ if (m_vScrollBar)
+ DoChangeBackgroundColour(m_vScrollBar, backgroundColour);
+ }
+#endif
+}
+
+void wxWindow::ChangeForegroundColour()
+{
+ WXWidget mainWidget = GetMainWidget();
+ if ( mainWidget )
+ DoChangeForegroundColour(mainWidget, m_foregroundColour);
+ 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)
+{
+ // 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.
+
+ Widget w = (Widget)widget;
+ XtVaSetValues(
+ w,
+ XmNforeground, foregroundColour.AllocColour(XtDisplay(w)),
+ NULL
+ );
+}
+
+void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
+{
+ wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
+ (wxColour*) NULL);
+
+ XtVaSetValues ((Widget) widget,
+ XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
+ XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
+ XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
+ XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
+ NULL);
+
+ if (changeArmColour)
+ XtVaSetValues ((Widget) widget,
+ XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
+ NULL);
+}
+
+bool wxWindow::SetBackgroundColour(const wxColour& col)
+{
+ if ( !wxWindowBase::SetBackgroundColour(col) )
+ return FALSE;
+
+ ChangeBackgroundColour();
+
+ return TRUE;
+}
+
+bool wxWindow::SetForegroundColour(const wxColour& col)
+{
+ if ( !wxWindowBase::SetForegroundColour(col) )
+ return FALSE;
+
+ ChangeForegroundColour();
+
+ return TRUE;
+}
+
+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_font.Ok())
+ {
+ int width, height, width1, height1;
+ GetSize(& width, & height);
+
+ // lesstif 0.87 hangs here
+#ifndef LESSTIF_VERSION
+ XtVaSetValues (w,
+ XmNfontList, (XmFontList) m_font.GetFontList(1.0, XtDisplay(w)),
+ NULL);
+#endif
+
+ GetSize(& width1, & height1);
+ if (keepOriginalSize && (width != width1 || height != height1))
+ {
+ SetSize(-1, -1, width, height);
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+// global functions
+// ----------------------------------------------------------------------------
+
+wxWindow *wxGetActiveWindow()
+{
+ // TODO
+ return NULL;
+}
+
+// ----------------------------------------------------------------------------
+// wxNoOptimize: switch off size optimization
+// ----------------------------------------------------------------------------
+
+int wxNoOptimize::ms_count = 0;
projects / wxWidgets.git / blobdiff