/ExtLibs/wxWidgets/src/motif/window.cpp
C++ | 1717 lines | 1187 code | 310 blank | 220 comment | 185 complexity | b8e72136e050b1b4ac8aff2464e9fdc0 MD5 | raw file
- /////////////////////////////////////////////////////////////////////////////
- // Name: src/motif/window.cpp
- // Purpose: wxWindow
- // Author: Julian Smart
- // Modified by:
- // Created: 17/09/98
- // RCS-ID: $Id$
- // Copyright: (c) Julian Smart
- // Licence: wxWindows licence
- /////////////////////////////////////////////////////////////////////////////
- // ============================================================================
- // declarations
- // ============================================================================
- // ----------------------------------------------------------------------------
- // headers
- // ----------------------------------------------------------------------------
- // For compilers that support precompilation, includes "wx.h".
- #include "wx/wxprec.h"
- #ifndef WX_PRECOMP
- #include "wx/hash.h"
- #include "wx/log.h"
- #include "wx/app.h"
- #include "wx/utils.h"
- #include "wx/frame.h"
- #include "wx/dc.h"
- #include "wx/dcclient.h"
- #include "wx/button.h"
- #include "wx/menu.h"
- #include "wx/settings.h"
- #include "wx/scrolwin.h"
- #include "wx/layout.h"
- #include "wx/menuitem.h"
- #include "wx/module.h"
- #endif
- #include "wx/evtloop.h"
- #include "wx/unix/utilsx11.h"
- #if wxUSE_DRAG_AND_DROP
- #include "wx/dnd.h"
- #endif
- // DoSetSizeIntr and DoMoveWindowIntr
- // PROBLEM:
- // under Motif composite controls (such as wxCalendarCtrl or generic wxSpinCtrl
- // did not work and/or segfaulted 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
- #ifdef __VMS__
- #pragma message disable nosimpint
- #endif
- #include <Xm/Xm.h>
- #include <Xm/DrawingA.h>
- #include <Xm/ScrolledW.h>
- #include <Xm/ScrollBar.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"
- #include "wx/motif/dcclient.h"
- #include <string.h>
- // ----------------------------------------------------------------------------
- // global variables for this module
- // ----------------------------------------------------------------------------
- extern wxHashTable *wxWidgetHashTable;
- static wxWindow* g_captureWindow = NULL;
- // ----------------------------------------------------------------------------
- // private functions
- // ----------------------------------------------------------------------------
- static void wxCanvasRepaintProc(Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
- static void wxCanvasInputEvent(Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
- static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
- static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
- static void wxScrollBarCallback(Widget widget, XtPointer clientData,
- XmScrollBarCallbackStruct *cbs);
- static void wxPanelItemEventHandler(Widget wid,
- XtPointer client_data,
- XEvent* event,
- Boolean *continueToDispatch);
- // unused for now
- #if 0
- // Helper function for 16-bit fonts
- static int str16len(const char *s)
- {
- int count = 0;
- while (s[0] && s[1]) {
- count++;
- s += 2;
- }
- return count;
- }
- #endif // 0
- // ----------------------------------------------------------------------------
- // macros
- // ----------------------------------------------------------------------------
- #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
- #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
- #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
- // ----------------------------------------------------------------------------
- // event tables
- // ----------------------------------------------------------------------------
- BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
- EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
- END_EVENT_TABLE()
- // ============================================================================
- // implementation
- // ============================================================================
- // ----------------------------------------------------------------------------
- // helper functions
- // ----------------------------------------------------------------------------
- void wxWindow::UnmanageAndDestroy(WXWidget widget)
- {
- Widget w = (Widget)widget;
- if ( w )
- {
- XtUnmanageChild(w);
- XtDestroyWidget(w);
- }
- }
- bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
- {
- Widget w = (Widget)widget;
- 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);
- }
- else
- {
- XtUnmanageChild(w);
- // XtUnmapWidget(w);
- }
- return true;
- }
- // ----------------------------------------------------------------------------
- // constructors
- // ----------------------------------------------------------------------------
- void wxWindow::Init()
- {
- // Motif-specific
- m_needsRefresh = true;
- m_mainWidget = (WXWidget) 0;
- m_winCaptured = false;
- m_isShown = true;
- m_hScrollBar =
- m_vScrollBar =
- m_borderWidget =
- m_scrolledWindow =
- m_drawingArea = (WXWidget) 0;
- m_scrollPosX =
- m_scrollPosY = 0;
- m_backingPixmap = (WXPixmap) 0;
- m_pixmapWidth =
- m_pixmapHeight = 0;
- m_pixmapOffsetX =
- m_pixmapOffsetY = 0;
- m_lastTS = 0;
- m_lastButton = 0;
- }
- // real construction (Init() must have been called before!)
- bool wxWindow::Create(wxWindow *parent, wxWindowID id,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
- {
- // Get default border
- wxBorder border = GetBorder(style);
- style &= ~wxBORDER_MASK;
- style |= border;
- wxCHECK_MSG( parent, false, "can't create wxWindow without parent" );
- CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
- parent->AddChild(this);
- PreCreation();
- //// TODO: we should probably optimize by only creating a
- //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
- //// But for now, let's simplify things by always creating the
- //// drawing area, since otherwise the translations are different.
- // New translations for getting mouse motion feedback
- static const String translations = wxMOTIF_STR(
- "<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
- <Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
- <Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
- <BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
- <Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
- <Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
- <Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
- <Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
- <Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
- <Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
- <Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
- <EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
- <LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
- <Key>: DrawingAreaInput()");
- XtActionsRec actions[1];
- actions[0].string = wxMOTIF_STR("wxCanvasMotionEvent");
- actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
- XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
- Widget parentWidget = (Widget) parent->GetClientWidget();
- m_borderWidget = wxCreateBorderWidget( (WXWidget)parentWidget, style );
- m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
- (
- "scrolledWindow",
- xmScrolledWindowWidgetClass,
- m_borderWidget ? (Widget) m_borderWidget
- : parentWidget,
- XmNresizePolicy, XmRESIZE_NONE,
- XmNspacing, 0,
- XmNscrollingPolicy, XmAPPLICATION_DEFINED,
- //XmNscrollBarDisplayPolicy, XmAS_NEEDED,
- NULL
- );
- XtTranslations ptr = XtParseTranslationTable(translations);
- m_drawingArea = (WXWidget)XtVaCreateWidget
- (
- name,
- xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
- XmNunitType, XmPIXELS,
- // XmNresizePolicy, XmRESIZE_ANY,
- XmNresizePolicy, XmRESIZE_NONE,
- XmNmarginHeight, 0,
- XmNmarginWidth, 0,
- XmNtranslations, ptr,
- NULL
- );
- XtFree((char *) ptr);
- #if 0
- if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
- {
- ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
- XtOverrideTranslations ((Widget) m_drawingArea, ptr);
- XtFree ((char *) ptr);
- }
- #endif // 0
- wxAddWindowToTable((Widget) m_drawingArea, this);
- wxAddWindowToTable((Widget) m_scrolledWindow, this);
- // This order is very important in Motif 1.2.1
- XtRealizeWidget ((Widget) m_scrolledWindow);
- XtRealizeWidget ((Widget) m_drawingArea);
- XtManageChild ((Widget) m_drawingArea);
- ptr = XtParseTranslationTable("<Configure>: resize()");
- XtOverrideTranslations((Widget) m_drawingArea, ptr);
- XtFree ((char *) ptr);
- XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
- XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
- XtAddEventHandler(
- (Widget)m_drawingArea,
- PointerMotionHintMask | EnterWindowMask |
- LeaveWindowMask | FocusChangeMask,
- False,
- (XtEventHandler) wxCanvasEnterLeave,
- (XtPointer) this
- );
- XmScrolledWindowSetAreas(
- (Widget)m_scrolledWindow,
- (Widget) 0, (Widget) 0,
- (Widget) m_drawingArea);
- PostCreation();
- // Without this, the cursor may not be restored properly (e.g. in splitter
- // sample).
- SetCursor(*wxSTANDARD_CURSOR);
- DoSetSizeIntr(pos.x, pos.y, size.x,size.y, wxSIZE_AUTO, true);
- return true;
- }
- // Destructor
- wxWindow::~wxWindow()
- {
- SendDestroyEvent();
- if (g_captureWindow == this)
- g_captureWindow = NULL;
- // Motif-specific actions first
- WXWidget wMain = GetMainWidget();
- if ( wMain )
- {
- // Removes event handlers
- DetachWidget(wMain);
- }
- // If m_drawingArea, we're a fully-fledged window with drawing area,
- // scrollbars etc. (what wxCanvas used to be)
- if ( m_drawingArea )
- {
- // Destroy children before destroying self
- DestroyChildren();
- if (m_backingPixmap)
- XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
- Widget w = (Widget) m_drawingArea;
- wxDeleteWindowFromTable(w);
- if (w)
- {
- XtDestroyWidget(w);
- m_drawingArea = (WXWidget) 0;
- }
- // Only if we're _really_ a canvas (not a dialog box/panel)
- if (m_scrolledWindow)
- {
- wxDeleteWindowFromTable((Widget) m_scrolledWindow);
- }
- 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)
- {
- XtDestroyWidget ((Widget) m_borderWidget);
- m_borderWidget = (WXWidget) 0;
- }
- }
- else // Why wasn't this here before? JACS 8/3/2000
- DestroyChildren();
- // Destroy the window
- if (GetMainWidget())
- {
- // If this line (XtDestroyWidget) causes a crash, you may comment it out.
- // Child widgets will get destroyed automatically when a frame
- // 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);
- }
- }
- // ----------------------------------------------------------------------------
- // 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 );
- wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
- // Add scrollbars if required
- if (orientation == wxHORIZONTAL)
- {
- m_hScrollBar = DoCreateScrollBar( m_scrolledWindow, wxHORIZONTAL,
- (void (*)())wxScrollBarCallback );
- wxDoChangeBackgroundColour(m_hScrollBar, backgroundColour, true);
- XtRealizeWidget( (Widget)m_hScrollBar );
- XtVaSetValues((Widget) m_scrolledWindow,
- XmNhorizontalScrollBar, (Widget) m_hScrollBar,
- NULL);
- wxAddWindowToTable( (Widget)m_hScrollBar, this );
- }
- else if (orientation == wxVERTICAL)
- {
- m_vScrollBar = DoCreateScrollBar( m_scrolledWindow, wxVERTICAL,
- (void (*)())wxScrollBarCallback );
- wxDoChangeBackgroundColour(m_vScrollBar, backgroundColour, true);
- XtRealizeWidget((Widget)m_vScrollBar);
- XtVaSetValues((Widget) m_scrolledWindow,
- XmNverticalScrollBar, (Widget) m_vScrollBar,
- NULL);
- wxAddWindowToTable( (Widget)m_vScrollBar, this );
- }
- 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);
- String stringSB = orientation == wxHORIZONTAL ?
- XmNhorizontalScrollBar : XmNverticalScrollBar;
- WXWidget* widgetSB = orientation == wxHORIZONTAL ?
- &m_hScrollBar : &m_vScrollBar;
- if( *widgetSB )
- {
- wxDeleteWindowFromTable( (Widget)*widgetSB );
- XtDestroyWidget( (Widget)*widgetSB );
- *widgetSB = (WXWidget)NULL;
- }
- XtVaSetValues( (Widget)m_scrolledWindow,
- stringSB, (Widget) 0,
- NULL );
- XtVaSetValues((Widget) m_scrolledWindow,
- XmNresizePolicy, XmRESIZE_ANY,
- NULL);
- }
- // ---------------------------------------------------------------------------
- // basic operations
- // ---------------------------------------------------------------------------
- void wxWindow::SetFocus()
- {
- Widget wMain = (Widget) GetMainWidget();
- XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
- XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
- }
- // Get the window with the focus
- wxWindow *wxWindowBase::DoFindFocus()
- {
- // TODO Problems:
- // (1) Can there be multiple focussed widgets in an application?
- // In which case we need to find the top-level window that's
- // currently active.
- // (2) The widget with the focus may not be in the widget table
- // depending on which widgets I put in the table
- wxWindow *winFocus = NULL;
- for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
- node;
- node = node->GetNext() )
- {
- wxWindow *win = node->GetData();
- Widget w = XmGetFocusWidget ((Widget) win->GetTopWidget());
- if (w != (Widget) NULL)
- {
- winFocus = wxGetWindowFromTable(w);
- if ( winFocus )
- break;
- }
- }
- return winFocus;
- }
- bool wxWindow::Enable(bool enable)
- {
- if ( !wxWindowBase::Enable(enable) )
- return false;
- Widget wMain = (Widget)GetMainWidget();
- if ( wMain )
- {
- XtSetSensitive(wMain, enable);
- XmUpdateDisplay(wMain);
- }
- return true;
- }
- bool wxWindow::Show(bool show)
- {
- if ( !wxWindowBase::Show(show) )
- return false;
- if (m_borderWidget || m_scrolledWindow)
- {
- MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
- // MapOrUnmap(m_drawingArea, show);
- }
- else
- {
- if ( !MapOrUnmap(GetTopWidget(), show) )
- MapOrUnmap(GetMainWidget(), show);
- }
- return true;
- }
- // Raise the window to the top of the Z order
- void wxWindow::Raise()
- {
- Widget wTop = (Widget) GetTopWidget();
- Window window = XtWindow(wTop);
- XRaiseWindow(XtDisplay(wTop), window);
- }
- // Lower the window to the bottom of the Z order
- void wxWindow::Lower()
- {
- Widget wTop = (Widget) GetTopWidget();
- Window window = XtWindow(wTop);
- XLowerWindow(XtDisplay(wTop), window);
- }
- void wxWindow::SetLabel(const wxString& label)
- {
- XtVaSetValues((Widget)GetMainWidget(), XmNtitle,
- (const char*)label.mb_str(), NULL);
- }
- wxString wxWindow::GetLabel() const
- {
- char *label = NULL;
- XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &label, NULL);
- return wxString(label);
- }
- void wxWindow::DoCaptureMouse()
- {
- g_captureWindow = this;
- if ( m_winCaptured )
- return;
- Widget wMain = (Widget)GetMainWidget();
- if ( wMain )
- XtAddGrab(wMain, True, False);
- m_winCaptured = true;
- }
- void wxWindow::DoReleaseMouse()
- {
- g_captureWindow = NULL;
- if ( !m_winCaptured )
- return;
- Widget wMain = (Widget)GetMainWidget();
- if ( wMain )
- XtRemoveGrab(wMain);
- m_winCaptured = false;
- }
- bool wxWindow::SetFont(const wxFont& font)
- {
- if ( !wxWindowBase::SetFont(font) )
- {
- // nothing to do
- return false;
- }
- ChangeFont();
- return true;
- }
- bool wxWindow::SetCursor(const wxCursor& cursor)
- {
- if ( !wxWindowBase::SetCursor(cursor) )
- {
- // no change
- return false;
- }
- // wxASSERT_MSG( m_cursor.IsOk(),
- // wxT("cursor must be valid after call to the base version"));
- const wxCursor* cursor2 = NULL;
- if (m_cursor.IsOk())
- cursor2 = & m_cursor;
- else
- cursor2 = wxSTANDARD_CURSOR;
- WXDisplay *dpy = GetXDisplay();
- WXCursor x_cursor = cursor2->GetXCursor(dpy);
- Widget w = (Widget) GetMainWidget();
- Window win = XtWindow(w);
- XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
- return true;
- }
- // Coordinates relative to the window
- void wxWindow::WarpPointer (int x, int y)
- {
- Widget wClient = (Widget)GetClientWidget();
- XWarpPointer(XtDisplay(wClient), None, XtWindow(wClient), 0, 0, 0, 0, x, y);
- }
- // ---------------------------------------------------------------------------
- // scrolling stuff
- // ---------------------------------------------------------------------------
- int wxWindow::GetScrollPos(int orient) const
- {
- if (orient == wxHORIZONTAL)
- return m_scrollPosX;
- else
- return m_scrollPosY;
- #if 0
- Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
- if (scrollBar)
- {
- int pos;
- XtVaGetValues(scrollBar, XmNvalue, &pos, NULL);
- return pos;
- }
- else
- return 0;
- #endif // 0
- }
- // This now returns the whole range, not just the number of positions that we
- // can scroll.
- int wxWindow::GetScrollRange(int orient) const
- {
- Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
- // 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)
- XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
- return range;
- }
- int wxWindow::GetScrollThumb(int orient) const
- {
- Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
- //wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
- int thumb = 0;
- if (scrollBar)
- XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
- return thumb;
- }
- void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
- {
- Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
- if ( scrollBar )
- {
- XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
- }
- SetInternalScrollPos((wxOrientation)orient, pos);
- }
- // New function that will replace some of the above.
- void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
- int range, bool WXUNUSED(refresh))
- {
- int oldW, oldH;
- GetSize(& oldW, & oldH);
- if (range == 0)
- range = 1;
- if (thumbVisible == 0)
- thumbVisible = 1;
- if (thumbVisible > range)
- thumbVisible = range;
- // Save the old state to see if it changed
- WXWidget oldScrollBar = GetScrollbar((wxOrientation)orient);
- if (orient == wxHORIZONTAL)
- {
- if (thumbVisible == range)
- {
- if (m_hScrollBar)
- DestroyScrollbar(wxHORIZONTAL);
- }
- else
- {
- if (!m_hScrollBar)
- CreateScrollbar(wxHORIZONTAL);
- }
- }
- if (orient == wxVERTICAL)
- {
- if (thumbVisible == range)
- {
- if (m_vScrollBar)
- DestroyScrollbar(wxVERTICAL);
- }
- else
- {
- if (!m_vScrollBar)
- CreateScrollbar(wxVERTICAL);
- }
- }
- WXWidget newScrollBar = GetScrollbar((wxOrientation)orient);
- if (oldScrollBar != newScrollBar)
- {
- // This is important! Without it, scrollbars misbehave badly.
- XtUnrealizeWidget((Widget) m_scrolledWindow);
- XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
- XtRealizeWidget((Widget) m_scrolledWindow);
- XtManageChild((Widget) m_scrolledWindow);
- }
- if (newScrollBar)
- {
- XtVaSetValues((Widget) newScrollBar,
- XmNvalue, pos,
- XmNminimum, 0,
- XmNmaximum, range,
- XmNsliderSize, thumbVisible,
- NULL);
- }
- SetInternalScrollPos((wxOrientation)orient, pos);
- int newW, newH;
- GetSize(& newW, & newH);
- // Adjusting scrollbars can resize the canvas accidentally
- if (newW != oldW || newH != oldH)
- SetSize(wxDefaultCoord, wxDefaultCoord, oldW, oldH);
- }
- // Does a physical scroll
- void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
- {
- int x, y, w, h;
- if (rect)
- {
- // Use specified rectangle
- x = rect->x; y = rect->y; w = rect->width; h = rect->height;
- }
- else
- {
- // Use whole client area
- x = 0; y = 0;
- GetClientSize(& w, & h);
- }
- int x1 = (dx >= 0) ? x : x - dx;
- int y1 = (dy >= 0) ? y : y - dy;
- int w1 = w - abs(dx);
- int h1 = h - abs(dy);
- int x2 = (dx >= 0) ? x + dx : x;
- int y2 = (dy >= 0) ? y + dy : y;
- wxClientDC dc(this);
- wxClientDCImpl * const
- dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
- GC const gc = (GC) dcimpl->GetGC();
- dc.SetLogicalFunction (wxCOPY);
- Widget widget = (Widget) GetMainWidget();
- Window window = XtWindow(widget);
- Display* display = XtDisplay(widget);
- XCopyArea(display, window, window, gc, x1, y1, w1, h1, x2, y2);
- dcimpl->SetAutoSetting(true);
- wxBrush brush(GetBackgroundColour(), wxSOLID);
- dc.SetBrush(brush); // FIXME: needed?
- wxWindowList::compatibility_iterator cnode = m_children.GetFirst();
- while (cnode)
- {
- wxWindow *child = cnode->GetData();
- 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->GetNext();
- }
- // We'll add rectangles to the list of update rectangles according to which
- // bits we've exposed.
- wxList updateRects;
- if (dx > 0)
- {
- wxRect *rect = new wxRect;
- rect->x = x;
- rect->y = y;
- rect->width = dx;
- rect->height = h;
- XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
- rect->x = rect->x;
- rect->y = rect->y;
- rect->width = rect->width;
- rect->height = rect->height;
- updateRects.Append((wxObject*) rect);
- }
- else if (dx < 0)
- {
- wxRect *rect = new wxRect;
- rect->x = x + w + dx;
- rect->y = y;
- rect->width = -dx;
- rect->height = h;
- XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
- rect->x = rect->x;
- rect->y = rect->y;
- rect->width = rect->width;
- rect->height = rect->height;
- updateRects.Append((wxObject*) rect);
- }
- if (dy > 0)
- {
- wxRect *rect = new wxRect;
- rect->x = x;
- rect->y = y;
- rect->width = w;
- rect->height = dy;
- XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
- rect->x = rect->x;
- rect->y = rect->y;
- rect->width = rect->width;
- rect->height = rect->height;
- updateRects.Append((wxObject*) rect);
- }
- else if (dy < 0)
- {
- wxRect *rect = new wxRect;
- rect->x = x;
- rect->y = y + h + dy;
- rect->width = w;
- rect->height = -dy;
- XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
- rect->x = rect->x;
- rect->y = rect->y;
- rect->width = rect->width;
- rect->height = rect->height;
- updateRects.Append((wxObject*) rect);
- }
- dc.SetBrush(wxNullBrush);
- // Now send expose events
- wxList::compatibility_iterator node = updateRects.GetFirst();
- while (node)
- {
- wxRect* rect = (wxRect*) node->GetData();
- XExposeEvent event;
- event.type = Expose;
- event.display = display;
- event.send_event = True;
- event.window = window;
- event.x = rect->x;
- event.y = rect->y;
- event.width = rect->width;
- event.height = rect->height;
- event.count = 0;
- XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
- node = node->GetNext();
- }
- // Delete the update rects
- node = updateRects.GetFirst();
- while (node)
- {
- wxRect* rect = (wxRect*) node->GetData();
- delete rect;
- node = node->GetNext();
- }
- XmUpdateDisplay((Widget) GetMainWidget());
- }
- // ---------------------------------------------------------------------------
- // drag and drop
- // ---------------------------------------------------------------------------
- #if wxUSE_DRAG_AND_DROP
- void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
- {
- // TODO
- }
- #endif
- // Old style file-manager drag&drop
- void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
- {
- // TODO
- }
- // ----------------------------------------------------------------------------
- // tooltips
- // ----------------------------------------------------------------------------
- #if wxUSE_TOOLTIPS
- void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
- {
- // TODO
- }
- #endif // wxUSE_TOOLTIPS
- // ----------------------------------------------------------------------------
- // popup menus
- // ----------------------------------------------------------------------------
- #if wxUSE_MENUS
- bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
- {
- if ( x == wxDefaultCoord && y == wxDefaultCoord )
- {
- 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
- 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, 0);
- 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);
- // 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>
- wxEventLoop evtLoop;
- while (menu->GetId() == 1)
- {
- wxDoEventLoopIteration( evtLoop );
- }
- return true;
- }
- #endif
- // ---------------------------------------------------------------------------
- // moving and resizing
- // ---------------------------------------------------------------------------
- bool wxWindow::PreResize()
- {
- return true;
- }
- // Get total size
- void wxWindow::DoGetSize(int *x, int *y) const
- {
- Widget widget = (Widget)( !m_drawingArea ? GetTopWidget() :
- ( m_borderWidget ? m_borderWidget :
- m_scrolledWindow ? m_scrolledWindow :
- m_drawingArea ) );
- Dimension xx, yy;
- if (widget)
- XtVaGetValues( widget,
- XmNwidth, &xx,
- XmNheight, &yy,
- NULL );
- if(x) *x = widget ? xx : -1;
- if(y) *y = widget ? yy : -1;
- }
- void wxWindow::DoGetPosition(int *x, int *y) const
- {
- Widget widget = (Widget)
- ( m_drawingArea ?
- ( m_borderWidget ? m_borderWidget : m_scrolledWindow ) :
- GetTopWidget() );
- Position xx, yy;
- XtVaGetValues(widget, 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 = (Position)(xx - pt.x);
- yy = (Position)(yy - pt.y);
- }
- if(x) *x = xx;
- if(y) *y = yy;
- }
- void wxWindow::DoScreenToClient(int *x, int *y) const
- {
- Widget widget = (Widget) GetClientWidget();
- Display *display = XtDisplay((Widget) GetMainWidget());
- Window rootWindow = RootWindowOfScreen(XtScreen(widget));
- Window thisWindow = XtWindow(widget);
- Window childWindow;
- int xx = x ? *x : 0;
- int yy = y ? *y : 0;
- XTranslateCoordinates(display, rootWindow, thisWindow,
- xx, yy, x ? x : &xx, y ? y : &yy,
- &childWindow);
- }
- void wxWindow::DoClientToScreen(int *x, int *y) const
- {
- Widget widget = (Widget) GetClientWidget();
- Display *display = XtDisplay(widget);
- Window rootWindow = RootWindowOfScreen(XtScreen(widget));
- Window thisWindow = XtWindow(widget);
- Window childWindow;
- int xx = x ? *x : 0;
- int yy = y ? *y : 0;
- XTranslateCoordinates(display, thisWindow, rootWindow,
- xx, yy, x ? x : &xx, y ? y : &yy,
- &childWindow);
- }
- // Get size *available for subwindows* i.e. excluding menu bar etc.
- void wxWindow::DoGetClientSize(int *x, int *y) const
- {
- Widget widget = (Widget) GetClientWidget();
- Dimension xx, yy;
- XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
- 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 = -1, oldY = -1, oldW = -1, oldH = -1;
- if( !fromCtor )
- {
- GetSize(& oldW, & oldH);
- GetPosition(& oldX, & oldY);
- }
- if (x == -1)
- x = oldX;
- if (x == -1)
- x = oldY;
- if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
- {
- if ( width == -1 )
- width = oldW;
- if ( height == -1 )
- height = oldH;
- }
- wxSize size(wxDefaultSize);
- if ( width <= 0 )
- {
- if ( ( sizeFlags & wxSIZE_AUTO_WIDTH ) && !fromCtor )
- {
- size = DoGetBestSize();
- width = size.x;
- }
- else
- {
- width = oldW;
- }
- }
- if ( height == -1 )
- {
- if( ( sizeFlags & wxSIZE_AUTO_HEIGHT ) && !fromCtor )
- {
- if( size.x == -1 ) size = DoGetBestSize();
- height = size.y;
- }
- else
- {
- height = oldH;
- }
- }
- if ( x != oldX || y != oldY || width != oldW || height != oldH
- || !wxNoOptimize::CanOptimize() )
- {
- if (m_drawingArea)
- {
- int flags = 0;
- if (x != oldX)
- flags |= wxMOVE_X;
- if (y != oldY)
- flags |= wxMOVE_Y;
- if (width > 0)
- flags |= wxMOVE_WIDTH;
- if (height > 0)
- flags |= wxMOVE_HEIGHT;
- int xx = x; int yy = y;
- AdjustForParentClientOrigin(xx, yy, sizeFlags);
- if( !fromCtor )
- DoMoveWindow( xx, yy, width, height );
- else
- DoMoveWindowIntr( xx, yy, width, height, flags );
- return;
- }
- Widget widget = (Widget) GetTopWidget();
- if (!widget)
- return;
- bool managed = XtIsManaged( widget );
- if (managed)
- XtUnmanageChild(widget);
- int xx = x;
- int yy = y;
- AdjustForParentClientOrigin(xx, yy, sizeFlags);
- DoMoveWindow(xx, yy, width, height);
- if (managed)
- XtManageChild(widget);
- }
- }
- void wxWindow::DoSetClientSize(int width, int height)
- {
- if (m_drawingArea)
- {
- Widget drawingArea = (Widget) m_drawingArea;
- XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
- if (width > -1)
- XtVaSetValues(drawingArea, XmNwidth, width, NULL);
- if (height > -1)
- XtVaSetValues(drawingArea, XmNheight, height, NULL);
- XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
- return;
- }
- Widget widget = (Widget) GetTopWidget();
- if (width > -1)
- XtVaSetValues(widget, XmNwidth, width, NULL);
- if (height > -1)
- XtVaSetValues(widget, XmNheight, height, NULL);
- }
- void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
- int flags)
- {
- if (m_drawingArea)
- {
- Widget drawingArea = (Widget) m_drawingArea;
- Widget borderOrScrolled = m_borderWidget ?
- (Widget) m_borderWidget :
- (Widget) m_scrolledWindow;
- bool managed = XtIsManaged(borderOrScrolled);
- if (managed)
- XtUnmanageChild (borderOrScrolled);
- XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
- if (flags & wxMOVE_X)
- XtVaSetValues (borderOrScrolled,
- XmNx, xx,
- NULL);
- if (flags & wxMOVE_Y)
- XtVaSetValues (borderOrScrolled,
- XmNy, yy,
- NULL);
- if (flags & wxMOVE_WIDTH)
- {
- 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);
- }
- if( w < 1 ) w = 1;
- XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
- }
- if (flags & wxMOVE_HEIGHT)
- {
- 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);
- }
- if( h < 1 ) h = 1;
- XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
- }
- if (managed)
- XtManageChild (borderOrScrolled);
- XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
- }
- else
- {
- if( w < 1 ) w = 1;
- if( h < 1 ) h = 1;
- XtVaSetValues((Widget)GetTopWidget(),
- XmNx, xx,
- XmNy, yy,
- XmNwidth, w,
- XmNheight, h,
- NULL);
- }
- }
- void wxWindow::DoMoveWindow(int x, int y, int width, int height)
- {
- DoMoveWindowIntr (x, y, width, height,
- wxMOVE_X|wxMOVE_Y|wxMOVE_WIDTH|wxMOVE_HEIGHT);
- }
- // ---------------------------------------------------------------------------
- // text metrics
- // ---------------------------------------------------------------------------
- int wxWindow::GetCharHeight() const
- {
- int height;
- if (m_font.IsOk())
- wxGetTextExtent (GetXDisplay(), m_font, 1.0,
- "x", NULL, &height, NULL, NULL);
- else
- wxGetTextExtent (this, "x", NULL, &height, NULL, NULL);
- return height;
- }
- int wxWindow::GetCharWidth() const
- {
- int width;
- if (m_font.IsOk())
- wxGetTextExtent (GetXDisplay(), m_font, 1.0,
- "x", &width, NULL, NULL, NULL);
- else
- wxGetTextExtent (this, "x", &width, NULL, NULL, NULL);
- return width;
- }
- void wxWindow::DoGetTextExtent(const wxString& string,
- int *x, int *y,
- int *descent,
- int *externalLeading,
- const wxFont *theFont) const
- {
- const wxFont *fontToUse = theFont ? theFont : &m_font;
- if (externalLeading)
- *externalLeading = 0;
- if (fontToUse->IsOk())
- wxGetTextExtent (GetXDisplay(), *fontToUse, 1.0,
- string, x, y, NULL, descent);
- else
- wxGetTextExtent (this, string, x, y, NULL, descent);
- }
- // ----------------------------------------------------------------------------
- // 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)
- {
- Widget widget = (Widget) GetMainWidget();
- if (!widget)
- return;
- m_needsRefresh = true;
- Display *display = XtDisplay(widget);
- Window thisWindow = XtWindow(widget);
- XExposeEvent dummyEvent;
- int width, height;
- GetSize(&width, &height);
- dummyEvent.type = Expose;
- dummyEvent.display = display;
- dummyEvent.send_event = True;
- dummyEvent.window = thisWindow;
- if (rect)
- {
- dummyEvent.x = rect->x;
- dummyEvent.y = rect->y;
- dummyEvent.width = rect->width;
- dummyEvent.height = rect->height;
- }
- else
- {
- dummyEvent.x = 0;
- dummyEvent.y = 0;
- dummyEvent.width = width;
- dummyEvent.height = height;
- }
- dummyEvent.count = 0;
- if (eraseBack)
- {
- wxClientDC dc(this);
- wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
- dc.SetBackground(backgroundBrush);
- wxClientDCImpl * const
- dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
- if (rect)
- dcimpl->Clear(*rect);
- else
- dcimpl->Clear();
- }
- XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
- }
- void wxWindow::DoPaint()
- {
- //TODO : make a temporary gc so we can do the XCopyArea below
- if (m_backingPixmap && !m_needsRefresh)
- {
- wxPaintDC dc(this);
- wxPaintDCImpl * const
- dcimpl = static_cast<wxPaintDCImpl *>(dc.GetImpl());
- GC tempGC = (GC) dcimpl->GetBackingGC();
- Widget widget = (Widget) GetMainWidget();
- int scrollPosX = 0;
- int scrollPosY = 0;
- // We have to test whether it's a wxScrolledWindow (hack!) because
- // 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 wxWidgets code.
- wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
- if ( scrolledWindow )
- {
- int x, y;
- scrolledWindow->CalcScrolledPosition(0, 0, &x, &y);
- scrollPosX = - x;
- scrollPosY = - y;
- }
- // TODO: This could be optimized further by only copying the areas in the
- // current update region.
- // Only blit the part visible in the client area. The backing pixmap
- // always starts at 0, 0 but we may be looking at only a portion of it.
- wxSize clientArea = GetClientSize();
- int toBlitX = m_pixmapWidth - scrollPosX;
- int toBlitY = m_pixmapHeight - scrollPosY;
- // Copy whichever is samller, the amount of pixmap we have to copy,
- // or the size of the client area.
- toBlitX = wxMin(toBlitX, clientArea.x);
- toBlitY = wxMin(toBlitY, clientArea.y);
- // Make sure we're not negative
- toBlitX = wxMax(0, toBlitX);
- toBlitY = wxMax(0, toBlitY);
- XCopyArea
- (
- XtDisplay(widget),
- (Pixmap) m_backingPixmap,
- XtWindow (widget),
- tempGC,
- scrollPosX, scrollPosY, // Start at the scroll position
- toBlitX, toBlitY, // How much of the pixmap to copy
- 0, 0 // Destination
- );
- }
- else
- {
- wxWindowDC dc(this);
- // Set an erase event first
- wxEraseEvent eraseEvent(GetId(), &dc);
- eraseEvent.SetEventObject(this);
- HandleWindowEvent(eraseEvent);
- wxPaintEvent event(GetId());
- event.SetEventObject(this);
- HandleWindowEvent(event);
- m_needsRefresh = false;
- }
- }
- // ----------------------------------------------------------------------------
- // event handlers
- // ----------------------------------------------------------------------------
- // Responds to colour changes: passes event on to children.
- void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
- {
- wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
- while ( node )
- {
- // Only propagate to non-top-level windows
- wxWindow *win = node->GetData();
- if ( win->GetParent() )
- {
- wxSysColourChangedEvent event2;
- event.SetEventObject(win);
- win->HandleWindowEvent(event2);
- }
- node = node->GetNext();
- }
- }
- // ----------------------------------------------------------------------------
- // accelerators
- // ----------------------------------------------------------------------------
- bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
- {
- #if wxUSE_ACCEL
- if (!m_acceleratorTable.IsOk())
- return false;
- int count = m_acceleratorTable.GetCount();
- wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
- int i;
- for (i = 0; i < count; i++)
- {
- wxAcceleratorEntry* entry = & (entries[i]);
- if (entry->MatchesEvent(event))
- {
- // 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
- wxWindow* parent = this;
- while ( parent && !parent->IsTopLevel() )
- parent = parent->GetParent();
- if (!parent)
- return false;
- wxFrame* frame = wxDynamicCast(parent, wxFrame);
- if ( frame )
- {
- #if wxUSE_MENUS
- // Try for a menu command
- if (frame->GetMenuBar())
- {
- wxMenuItem* item = frame->GetMenuBar()->FindItem(entry->GetCommand());
- if (item)
- {
- wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
- commandEvent.SetEventObject(frame);
- // If ProcessEvent returns true (it was handled), then
- // the calling code will skip the event handling.
- return frame->HandleWindowEvent(commandEvent);
- }
- }
- #endif
- }
- // Find a child matching the command id
- wxWindow* child = parent->FindWindow(entry->GetCommand());
- // No such child
- if (!child)
- return false;
- // Now we process those kinds of windows that we can.
- // For now, only buttons.
- if ( wxDynamicCast(child, wxButton) )
- {
- wxCommandEvent commandEvent (wxEVT_C