// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#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
BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
- EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
// ============================================================================
if ( !w )
return FALSE;
+ // 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.
+ // This means that, for example adding an item to a listbox will show it,
+ // 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);
+ // XtMapWidget(w);
}
else
{
- XtUnmapWidget(w);
XtUnmanageChild(w);
+ // 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.
- // This means that, for example adding an item to a listbox will show it,
- // or that most controls are shown every time they are moved or resized!
- XtSetMappedWhenManaged( w, domap );
-
return TRUE;
}
void wxWindow::Init()
{
- // generic initializations first
- InitBase();
-
// Motif-specific
m_needsRefresh = TRUE;
m_mainWidget = (WXWidget) 0;
m_winCaptured = FALSE;
m_isShown = TRUE;
- m_isBeingDeleted = FALSE;
m_hScrollBar =
m_vScrollBar =
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
(
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 |
(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);
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 )
// 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" );
- 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)
{
- 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);
wxDoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
- XtRealizeWidget(hScrollBar);
+ XtRealizeWidget( (Widget)m_hScrollBar );
XtVaSetValues((Widget) m_scrolledWindow,
XmNhorizontalScrollBar, (Widget) m_hScrollBar,
NULL);
- 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);
wxDoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
- XtRealizeWidget(vScrollBar);
+ XtRealizeWidget((Widget)m_vScrollBar);
XtVaSetValues((Widget) m_scrolledWindow,
XmNverticalScrollBar, (Widget) m_vScrollBar,
NULL);
- 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" );
- 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;
+ XtVaSetValues((Widget) m_scrolledWindow,
+ XmNresizePolicy, XmRESIZE_NONE,
+ NULL);
+ String stringSB = orientation == wxHORIZONTAL ?
+ XmNhorizontalScrollBar : XmNverticalScrollBar;
+ WXWidget* widgetSB = orientation == wxHORIZONTAL ?
+ &m_hScrollBar : &m_vScrollBar;
- XtVaSetValues((Widget) m_scrolledWindow,
- XmNhorizontalScrollBar, (Widget) 0,
- NULL);
-
- }
-
- if (orientation == wxVERTICAL)
+ if( *widgetSB )
{
- if (m_vScrollBar)
- {
- wxDeleteWindowFromTable((Widget)m_vScrollBar);
- XtDestroyWidget((Widget) m_vScrollBar);
- }
- m_vScrollBar = (WXWidget) 0;
+ 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);
}
// ---------------------------------------------------------------------------
// (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() )
{
if (m_borderWidget || m_scrolledWindow)
{
- MapOrUnmap(m_drawingArea, show);
MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
+ // MapOrUnmap(m_drawingArea, show);
}
else
{
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 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;
}
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();
// Now send expose events
- wxList::Node* node = updateRects.GetFirst();
+ wxList::compatibility_iterator node = updateRects.GetFirst();
while (node)
{
wxRect* rect = (wxRect*) node->GetData();
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
w -= 2 * (thick + margin);
}
+ if( w < 1 ) w = 1;
XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
}
h -= 2 * (thick + margin);
}
+ if( h < 1 ) h = 1;
XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
}
// 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;
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
// 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 )
{
// 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
}
}
-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindow::OnInternalIdle()
{
// This calls the UI-update mechanism (querying windows for
// menu/toolbar/control state information)
- UpdateWindowUI();
+ if (wxUpdateUIEvent::CanUpdate(this))
+ UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
}
// ----------------------------------------------------------------------------
// ============================================================================
// ----------------------------------------------------------------------------
-// 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)
// 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
{
{
win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
-
+
if (event -> xexpose.count == 0)
{
win->DoPaint();
- win->ClearUpdateRects();
}
break;
}
XmDrawingAreaCallbackStruct * cbs)
{
wxWindow *canvas = wxGetWindowFromTable(drawingArea);
- XEvent local_event;
+ XEvent* xevent = cbs->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)
+ switch (xevent->xany.type)
{
case EnterNotify:
case LeaveNotify:
case ButtonPress:
case ButtonRelease:
case MotionNotify:
- {
- wxMouseEvent wxevent;
- if(wxTranslateMouseEvent(wxevent, canvas, drawingArea, &local_event))
{
- canvas->GetEventHandler()->ProcessEvent(wxevent);
+ wxMouseEvent wxevent(0);
+ if (wxTranslateMouseEvent(wxevent, canvas, drawingArea, xevent))
+ {
+ canvas->GetEventHandler()->ProcessEvent(wxevent);
+ }
+ break;
}
- break;
- }
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.
wxWindow *parent = canvas;
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);
}
}
case FocusIn:
{
- if (local_event.xfocus.detail != NotifyPointer)
+ if (xevent->xfocus.detail != NotifyPointer)
{
wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
event.SetEventObject(canvas);
}
case FocusOut:
{
- if (local_event.xfocus.detail != NotifyPointer)
+ if (xevent->xfocus.detail != NotifyPointer)
{
wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
event.SetEventObject(canvas);
XmScrollBarCallbackStruct *cbs)
{
wxWindow *win = wxGetWindowFromTable(scrollbar);
- int orientation = (int) clientData;
+ wxOrientation orientation = (wxOrientation)(int)clientData;
wxEventType eventType = wxEVT_NULL;
switch (cbs->reason)
wxScrollWinEvent event(eventType,
cbs->value,
- ((orientation == XmHORIZONTAL) ?
- wxHORIZONTAL : wxVERTICAL));
+ orientation);
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent(event);
}
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();
-
- win->ClearUpdateRects();
- }
- else
- {
- win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
- event->xexpose.width, event->xexpose.height);
}
break;
// ----------------------------------------------------------------------------
bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win,
- Widget widget, XEvent *xevent)
+ Widget widget, const XEvent *xevent)
{
switch (xevent->xany.type)
{
case ButtonRelease:
case MotionNotify:
{
+ int eventx = xevent->xbutton.x, eventy = xevent->xbutton.y;
+
wxEventType eventType = wxEVT_NULL;
if (xevent->xany.type == LeaveNotify)
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)
{
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;
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)
}
bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,
- Widget WXUNUSED(widget), XEvent *xevent)
+ Widget WXUNUSED(widget), const XEvent *xevent)
{
switch (xevent->xany.type)
{
projects / wxWidgets.git / blobdiff