#pragma implementation "window.h"
#endif
+#ifdef __VMS
+#define XtDisplay XTDISPLAY
+#define XtWindow XTWINDOW
+#define XtScreen XTSCREEN
+#endif
+
#include "wx/setup.h"
#include "wx/menu.h"
#include "wx/dc.h"
#include "wx/menuitem.h"
#include "wx/log.h"
-#include "wx/listimpl.cpp"
-
#if wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
#endif
+// DoSetSizeIntr and CanvasSetSizeIntr
+// PROBLEM:
+// under Motif composite controls (such as wxCalendarCtrl or generic wxSpinCtrl
+// don't work and/or segfault because
+// 1) wxWindow::Create calls SetSize,
+// which results in a call to DoSetSize much earlier than in the other ports
+// 2) if wxWindow::Create is called (wxControl::Create calls it)
+// then DoSetSize is never called, causing layout problems in composite
+// controls
+//
+// SOLUTION:
+// 1) don't call SetSize, DoSetSize, DoMoveWindow, DoGetPosition,
+// DoSetPosition directly or indirectly from wxWindow::Create
+// 2) call DoMoveWindow from DoSetSize, allowing controls to override it,
+// but make wxWindow::DoMoveWindow a no-op if it is called from
+// an overridden DoMoveWindow (i.e. wxFoo::DoMoveWindow calls
+// wxWindow::DoMoveWindow; this is to preserve the behaviour
+// before this change
+
+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif
#include <Xm/Xm.h>
#include <Xm/DrawingA.h>
#include <Xm/Frame.h>
#include <Xm/Label.h>
#include <Xm/RowColumn.h> // for XmMenuPosition
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
#include "wx/motif/private.h"
// ----------------------------------------------------------------------------
extern wxHashTable *wxWidgetHashTable;
+static wxWindow* g_captureWindow = NULL;
+
// ----------------------------------------------------------------------------
// private functions
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,
// event tables
// ----------------------------------------------------------------------------
-#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
-#endif // USE_SHARED_LIBRARY
// ============================================================================
// implementation
// ============================================================================
-// ----------------------------------------------------------------------------
-// list types
-// ----------------------------------------------------------------------------
-
-WX_DEFINE_LIST(wxRectList);
-
// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------
}
}
-bool wxWindow::MapOrUnmap(WXWidget widget, bool map)
+bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
{
Widget w = (Widget)widget;
if ( !w )
return FALSE;
- if ( map )
+ 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.
+ // 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;
}
parent->AddChild(this);
- m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+ m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
m_foregroundColour = *wxBLACK;
//// TODO: we should probably optimize by only creating a
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
+ (
+ "canvasBorder",
+ xmFrameWidgetClass, parentWidget,
+ XmNshadowType, XmSHADOW_IN,
+ NULL
+ );
+ } else if (style & wxRAISED_BORDER)
+ {
+ m_borderWidget = (WXWidget)XtVaCreateManagedWidget
+ (
+ "canvasBorder",
+ xmFrameWidgetClass, parentWidget,
+ XmNshadowType, XmSHADOW_OUT,
NULL
);
}
// Scrolled widget needs to have its colour changed or we get a little blue
// square where the scrollbars abutt
- wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+ wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
// Without this, the cursor may not be restored properly (e.g. in splitter
// sample).
SetCursor(*wxSTANDARD_CURSOR);
- SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
- SetSize(pos.x, pos.y, size.x, size.y);
-
+ SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
+ DoSetSizeIntr(pos.x, pos.y, size.x,size.y, wxSIZE_AUTO, TRUE);
return TRUE;
}
// Destructor
wxWindow::~wxWindow()
{
+ if (g_captureWindow == this)
+ g_captureWindow = NULL;
+
m_isBeingDeleted = TRUE;
// Motif-specific actions first
if (w)
{
XtDestroyWidget(w);
+ m_drawingArea = (WXWidget) 0;
}
- m_mainWidget = (WXWidget) 0;
-
// Only if we're _really_ a canvas (not a dialog box/panel)
if (m_scrolledWindow)
{
wxDeleteWindowFromTable((Widget) m_scrolledWindow);
}
- UnmanageAndDestroy(m_hScrollBar);
- UnmanageAndDestroy(m_vScrollBar);
+ if (m_hScrollBar)
+ {
+ wxDeleteWindowFromTable((Widget) m_hScrollBar);
+ XtUnmanageChild((Widget) m_hScrollBar);
+ }
+ if (m_vScrollBar)
+ {
+ wxDeleteWindowFromTable((Widget) m_vScrollBar);
+ XtUnmanageChild((Widget) m_vScrollBar);
+ }
+
+ if (m_hScrollBar)
+ XtDestroyWidget((Widget) m_hScrollBar);
+ if (m_vScrollBar)
+ XtDestroyWidget((Widget) m_vScrollBar);
+
UnmanageAndDestroy(m_scrolledWindow);
if (m_borderWidget)
m_borderWidget = (WXWidget) 0;
}
}
+ else // Why wasn't this here before? JACS 8/3/2000
+ DestroyChildren();
+
// Destroy the window
if (GetMainWidget())
// or dialog is destroyed, but before that you may get some memory
// leaks and potential layout problems if you delete and then add
// child windows.
+
+ // GRG, Feb/2000: commented this out when adding support for
+ // wxSCROLL[WIN]_THUMBRELEASE events. Also it was reported
+ // that this call crashed wxMotif under OS/2, so it seems
+ // that leaving it out is the right thing to do.
+ // SN, Feb/2000: newgrid/griddemo shows why it is needed :-(
XtDestroyWidget((Widget) GetMainWidget());
SetMainWidget((WXWidget) NULL);
}
xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
XmNorientation, XmHORIZONTAL,
NULL);
- // XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
+ 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);
m_hScrollBar = (WXWidget) hScrollBar;
- wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+ wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
XtRealizeWidget(hScrollBar);
NULL);
m_hScroll = TRUE;
+
+ wxAddWindowToTable( hScrollBar, this );
}
if (orientation == wxVERTICAL)
xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
XmNorientation, XmVERTICAL,
NULL);
- // XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
+ 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);
NULL);
m_vScrollBar = (WXWidget) vScrollBar;
- wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+ wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
XtRealizeWidget(vScrollBar);
NULL);
m_vScroll = TRUE;
+
+ wxAddWindowToTable( vScrollBar, this );
}
XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
{
if (m_hScrollBar)
{
+ wxDeleteWindowFromTable((Widget)m_hScrollBar);
XtDestroyWidget((Widget) m_hScrollBar);
}
m_hScrollBar = (WXWidget) 0;
{
if (m_vScrollBar)
{
+ wxDeleteWindowFromTable((Widget)m_vScrollBar);
XtDestroyWidget((Widget) m_vScrollBar);
}
m_vScrollBar = (WXWidget) 0;
- m_vScroll = TRUE;
+ m_vScroll = FALSE;
XtVaSetValues((Widget) m_scrolledWindow,
XmNverticalScrollBar, (Widget) 0,
return wxString(title);
}
-void wxWindow::CaptureMouse()
+void wxWindow::DoCaptureMouse()
{
+ g_captureWindow = this;
if ( m_winCaptured )
return;
m_winCaptured = TRUE;
}
-void wxWindow::ReleaseMouse()
+void wxWindow::DoReleaseMouse()
{
+ g_captureWindow = NULL;
if ( !m_winCaptured )
return;
return FALSE;
}
- wxASSERT_MSG( m_cursor.Ok(),
- _T("cursor must be valid after call to the base version"));
+ // wxASSERT_MSG( m_cursor.Ok(),
+ // wxT("cursor must be valid after call to the base version"));
+ wxCursor* cursor2 = NULL;
+ if (m_cursor.Ok())
+ cursor2 = & m_cursor;
+ else
+ cursor2 = wxSTANDARD_CURSOR;
WXDisplay *dpy = GetXDisplay();
- WXCursor x_cursor = m_cursor.GetXCursor(dpy);
+ WXCursor x_cursor = cursor2->GetXCursor(dpy);
Widget w = (Widget) GetMainWidget();
Window win = XtWindow(w);
Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
- int range;
- XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
+ int range = 0;
+ if (scrollBar)
+ XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
return range;
}
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);
XmMenuPosition (menuWidget, &event);
XtManageChild (menuWidget);
+ XEvent x_event;
+ // The ID of a pop-up menu is 1 when active, and is set to 0 by the
+ // idle-time destroy routine.
+ // Waiting until this ID changes causes this function to block until
+ // the menu has been dismissed and the widgets cleaned up.
+ // In other words, once this routine returns, it is safe to delete
+ // the menu object.
+ // Ian Brown <ian.brown@printsoft.de>
+ while (menu->GetId() == 1)
+ {
+ XtAppNextEvent( (XtAppContext) wxTheApp->GetAppContext(), &x_event);
+
+ wxTheApp->ProcessXEvent((WXEvent*) & x_event);
+
+ if (XtAppPending( (XtAppContext) wxTheApp->GetAppContext() ) == 0)
+ {
+ if (!wxTheApp->ProcessIdle())
+ {
+#if wxUSE_THREADS
+ // leave the main loop to give other threads a chance to
+ // perform their GUI work
+ wxMutexGuiLeave();
+ wxUsleep(20);
+ wxMutexGuiEnter();
+#endif
+ }
+ }
+ }
return TRUE;
}
Widget widget = (Widget) GetTopWidget();
Dimension xx, yy;
XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
- *x = xx; *y = yy;
+ if(x) *x = xx; if(y) *y = yy;
}
void wxWindow::DoGetPosition(int *x, int *y) const
yy -= pt.y;
}
- *x = xx; *y = yy;
+ if(x) *x = xx; if(y) *y = yy;
}
void wxWindow::DoScreenToClient(int *x, int *y) const
Widget widget = (Widget) GetClientWidget();
Dimension xx, yy;
XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
- *x = xx; *y = yy;
+ if(x) *x = xx; if(y) *y = yy;
}
void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ DoSetSizeIntr(x, y, width, height, sizeFlags, FALSE);
+}
+
+void wxWindow::DoSetSizeIntr(int x, int y, int width, int height,
+ int sizeFlags, bool fromCtor)
{
// A bit of optimization to help sort out the flickers.
- int oldX, oldY, oldW, oldH;
- GetSize(& oldW, & oldH);
- GetPosition(& oldX, & oldY);
+ int oldX = -1, oldY = -1, oldW = -1, oldH = -1;
+ if( !fromCtor )
+ {
+ GetSize(& oldW, & oldH);
+ GetPosition(& oldX, & oldY);
+ }
- bool useOldPos = FALSE;
- bool useOldSize = FALSE;
+ if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+ {
+ if ( x == -1 )
+ x = oldX;
+ if ( y == -1 )
+ y = oldY;
+ }
- if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
- useOldPos = TRUE;
- else if (x == oldX && y == oldY)
- useOldPos = TRUE;
+ if ( width == -1 )
+ width = oldW;
+ if ( height == -1 )
+ height = oldH;
- if ((width == -1) && (height == -1))
- useOldSize = TRUE;
- else if (width == oldW && height == oldH)
- useOldSize = TRUE;
+ bool nothingChanged = (x == oldX) && (y == oldY) &&
+ (width == oldW) && (height == oldH);
if (!wxNoOptimize::CanOptimize())
{
- useOldSize = FALSE; useOldPos = FALSE;
+ nothingChanged = FALSE;
}
- if (useOldPos && useOldSize)
- return;
-
- if (m_drawingArea)
+ if ( !nothingChanged )
{
- CanvasSetSize(x, y, width, height, sizeFlags);
- return;
- }
- Widget widget = (Widget) GetTopWidget();
- if (!widget)
- return;
+ if (m_drawingArea)
+ {
+ CanvasSetSizeIntr(x, y, width, height, sizeFlags, fromCtor);
+ if( !fromCtor ) DoMoveWindow(x, y, width, height);
+ return;
+ }
- bool managed = XtIsManaged( widget );
- if (managed)
- XtUnmanageChild(widget);
+ Widget widget = (Widget) GetTopWidget();
+ if (!widget)
+ return;
- int xx = x; int yy = y;
- AdjustForParentClientOrigin(xx, yy, sizeFlags);
+ bool managed = XtIsManaged( widget );
+ if (managed)
+ XtUnmanageChild(widget);
- if (!useOldPos)
- {
- if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
- XtVaSetValues(widget, XmNx, xx, NULL);
- if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
- XtVaSetValues(widget, XmNy, yy, NULL);
- }
- if (!useOldSize)
- {
- if (width > -1)
- XtVaSetValues(widget, XmNwidth, width, NULL);
- if (height > -1)
- XtVaSetValues(widget, XmNheight, height, NULL);
- }
+ int xx = x;
+ int yy = y;
+ AdjustForParentClientOrigin(xx, yy, sizeFlags);
- if (managed)
- XtManageChild(widget);
+ DoMoveWindow(xx, yy, width, height);
+
+ if (managed)
+ XtManageChild(widget);
- // How about this bit. Maybe we don't need to generate size events
- // all the time -- they'll be generated when the window is sized anyway.
+ // How about this bit. Maybe we don't need to generate size events
+ // all the time -- they'll be generated when the window is sized anyway.
#if 0
- wxSizeEvent sizeEvent(wxSize(width, height), GetId());
- sizeEvent.SetEventObject(this);
+ wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+ sizeEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(sizeEvent);
+ GetEventHandler()->ProcessEvent(sizeEvent);
#endif // 0
+ }
}
void wxWindow::DoSetClientSize(int width, int height)
return wxPoint(0, 0);
}
-// Makes an adjustment to the window position (for example, a frame that has
-// a toolbar that it manages itself).
-void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
-{
- if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
- {
- wxPoint pt(GetParent()->GetClientAreaOrigin());
- x += pt.x; y += pt.y;
- }
-}
-
void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
{
m_minWidth = minW;
XtVaSetValues(widget, XmNheightInc, incH, NULL);
}
+void wxWindow::DoMoveWindow(int x, int y, int width, int height)
+{
+ // see the top of the file, near DoSetSizeIntr
+ if (m_drawingArea)
+ return;
+
+ if (width == 0)
+ width = 1;
+ if (height == 0)
+ height = 1;
+
+ XtVaSetValues((Widget)GetTopWidget(),
+ XmNx, x,
+ XmNy, y,
+ XmNwidth, width,
+ XmNheight, height,
+ NULL);
+}
+
// ---------------------------------------------------------------------------
// text metrics
// ---------------------------------------------------------------------------
wxCHECK_RET( fontToUse->Ok(), "valid window font needed" );
- WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
+ WXFontStructPtr pFontStruct = fontToUse->GetFontStruct(1.0, GetXDisplay());
int direction, ascent, descent2;
XCharStruct overall;
}
}
-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)
wxAcceleratorEntry* entry = & (entries[i]);
if (entry->MatchesEvent(event))
{
- // Bingo, we have a match. Now find a control that matches the entry
- // command id.
+ // Bingo, we have a match. Now find a control that matches the
+ // entry command id.
// Need to go up to the top of the window hierarchy, since it might
// be e.g. a menu item
// 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());
wxWidgetHashTable->Put((long) w, win);
- wxLogDebug("Widget 0x%08x <-> window %p (%s)",
+ wxLogTrace("widget", "Widget 0x%08x <-> window %p (%s)",
w, win, win->GetClassInfo()->GetClassName());
return TRUE;
// ----------------------------------------------------------------------------
// 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);
// 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)
{
case Expose:
{
+ win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
+ event->xexpose.width, event->xexpose.height);
+
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,
+ XtPointer WXUNUSED(clientData),
XCrossingEvent * event)
{
XmDrawingAreaCallbackStruct cbs;
}
// 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;
}
static void wxCanvasInputEvent(Widget drawingArea,
- XtPointer data,
+ XtPointer WXUNUSED(data),
XmDrawingAreaCallbackStruct * cbs)
{
wxWindow *canvas = wxGetWindowFromTable(drawingArea);
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)
}
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();
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)
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)
{
{
// I have a dclick
canvas->SetLastClick(0, ts);
- switch ( eventType )
+
+ 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 )
{
- 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;
+ wxevent.SetEventType(typeDouble);
}
-
}
else
{
}
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)
+ wxKeyEvent event (wxEVT_CHAR);
+ if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
{
// Implement wxFrame::OnCharHook by checking ancestor.
wxWindow *parent = canvas->GetParent();
}
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)
+ if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
{
canvas->GetEventHandler()->ProcessEvent (event);
}
}
static void wxPanelItemEventHandler(Widget wid,
- XtPointer client_data,
+ XtPointer WXUNUSED(client_data),
XEvent* event,
Boolean *continueToDispatch)
{
static void wxScrollBarCallback(Widget scrollbar,
XtPointer clientData,
- XmScaleCallbackStruct *cbs)
+ XmScrollBarCallbackStruct *cbs)
{
wxWindow *win = wxGetWindowFromTable(scrollbar);
int orientation = (int) clientData;
{
case XmCR_INCREMENT:
{
- eventType = wxEVT_SCROLL_LINEDOWN;
+ eventType = wxEVT_SCROLLWIN_LINEDOWN;
break;
}
case XmCR_DECREMENT:
{
- eventType = wxEVT_SCROLL_LINEUP;
+ eventType = wxEVT_SCROLLWIN_LINEUP;
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?
- eventType = wxEVT_SCROLL_THUMBTRACK;
+ eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
break;
}
case XmCR_PAGE_INCREMENT:
{
- eventType = wxEVT_SCROLL_PAGEDOWN;
+ eventType = wxEVT_SCROLLWIN_PAGEDOWN;
break;
}
case XmCR_PAGE_DECREMENT:
{
- eventType = wxEVT_SCROLL_PAGEUP;
+ eventType = wxEVT_SCROLLWIN_PAGEUP;
break;
}
case XmCR_TO_TOP:
{
- eventType = wxEVT_SCROLL_TOP;
+ eventType = wxEVT_SCROLLWIN_TOP;
break;
}
case XmCR_TO_BOTTOM:
{
- eventType = wxEVT_SCROLL_BOTTOM;
+ eventType = wxEVT_SCROLLWIN_BOTTOM;
break;
}
default:
}
}
- 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);
}
// CanvaseXXXSize() functions
// ----------------------------------------------------------------------------
+void wxWindow::CanvasSetSize(int x, int y, int w, int h, int sizeFlags)
+{
+ CanvasSetSizeIntr(x, y, w, h, sizeFlags, FALSE);
+}
+
// SetSize, but as per old wxCanvas (with drawing widget etc.)
-void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
+void wxWindow::CanvasSetSizeIntr(int x, int y, int w, int h, int sizeFlags,
+ bool fromCtor)
{
// A bit of optimization to help sort out the flickers.
- int oldX, oldY, oldW, oldH;
- GetSize(& oldW, & oldH);
- GetPosition(& oldX, & oldY);
+ int oldX = -1, oldY = -1, oldW = -1, oldH = -1;
+ // see the top of the file, near DoSetSizeIntr
+ if( !fromCtor )
+ {
+ GetSize(& oldW, & oldH);
+ GetPosition(& oldX, & oldY);
+ }
bool useOldPos = FALSE;
bool useOldSize = FALSE;
{
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;
+ // FIXME: this is never true I think - MB
+ //
if (xevent->xany.type == LeaveNotify)
{
win->SetButton1(FALSE);
}
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);
+ 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;
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);
+ if ( eventType == wxEVT_LEFT_DOWN )
+ eventType = wxEVT_LEFT_DCLICK;
+ else if ( eventType == wxEVT_MIDDLE_DOWN )
+ eventType = wxEVT_MIDDLE_DCLICK;
+ else if ( eventType == wxEVT_RIGHT_DOWN )
+ eventType = wxEVT_RIGHT_DCLICK;
+ }
+ else
+ {
+ // not fast enough or different button
+ win->SetLastClick(button, ts);
}
}
else if (xevent->xany.type == ButtonRelease)
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;
}
-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)
{
#endif // 0
(void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
int id = wxCharCodeXToWX (keySym);
+ // id may be WXK_xxx code - these are outside ASCII range, so we
+ // can't just use toupper() on id
+ if (id >= 'a' && id <= 'z')
+ id = toupper(id);
if (xevent->xkey.state & ShiftMask)
wxevent.m_shiftDown = TRUE;
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);
+ wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
if (m_hScrollBar)
DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
int width, height, width1, height1;
GetSize(& width, & height);
- // lesstif 0.87 hangs here
-#ifndef LESSTIF_VERSION
+ // lesstif 0.87 hangs here, but 0.93 does not
+#if !defined(LESSTIF_VERSION) \
+ || (defined(LesstifVersion) && LesstifVersion >= 93)
XtVaSetValues (w,
XmNfontList, (XmFontList) m_font.GetFontList(1.0, XtDisplay(w)),
NULL);
wxWindow *wxGetActiveWindow()
{
// TODO
+ wxFAIL_MSG("Not implemented");
return NULL;
}
+/* static */
+wxWindow *wxWindowBase::GetCapture()
+{
+ return (wxWindow *)g_captureWindow;
+}
+
+
+// Find the wxWindow at the current mouse position, returning the mouse
+// position.
+wxWindow* wxFindWindowAtPointer(wxPoint& pt)
+{
+ return wxFindWindowAtPoint(wxGetMousePosition());
+}
+
+// Get the current mouse position.
+wxPoint wxGetMousePosition()
+{
+ Display *display = (Display*) wxGetDisplay();
+ Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
+ Window rootReturn, childReturn;
+ int rootX, rootY, winX, winY;
+ unsigned int maskReturn;
+
+ XQueryPointer (display,
+ rootWindow,
+ &rootReturn,
+ &childReturn,
+ &rootX, &rootY, &winX, &winY, &maskReturn);
+ return wxPoint(rootX, rootY);
+}
+
+
// ----------------------------------------------------------------------------
// wxNoOptimize: switch off size optimization
// ----------------------------------------------------------------------------
int wxNoOptimize::ms_count = 0;
+
projects / wxWidgets.git / blobdiff