]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/motif/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Various small fixes
[wxWidgets.git] / src / motif / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: windows.cpp
3// Purpose: wxWindow
4// Author: Julian Smart
5// Modified by:
6// Created: 17/09/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#ifdef __GNUG__
13#pragma implementation "window.h"
14#endif
15
16#include "wx/setup.h"
17#include "wx/menu.h"
18#include "wx/dc.h"
19#include "wx/dcclient.h"
20#include "wx/utils.h"
21#include "wx/app.h"
22#include "wx/panel.h"
23#include "wx/layout.h"
24#include "wx/dialog.h"
25#include "wx/listbox.h"
26#include "wx/button.h"
27#include "wx/settings.h"
28#include "wx/msgdlg.h"
29#include "wx/frame.h"
30
31#include "wx/menuitem.h"
32#include "wx/log.h"
33
34#if wxUSE_DRAG_AND_DROP
35#include "wx/dnd.h"
36#endif
37
38#include <Xm/Xm.h>
39
40#include <Xm/DrawingA.h>
41#include <Xm/ScrolledW.h>
42#include <Xm/ScrollBar.h>
43#include <Xm/Frame.h>
44#include <Xm/Label.h>
45
46#include "wx/motif/private.h"
47
48#include <string.h>
49
50#define SCROLL_MARGIN 4
51void wxCanvasRepaintProc (Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
52void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
53void wxCanvasMotionEvent (Widget, XButtonEvent * event);
54void wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
55static void wxScrollBarCallback(Widget widget, XtPointer clientData,
56 XmScaleCallbackStruct *cbs);
57void wxPanelItemEventHandler (Widget wid,
58 XtPointer client_data,
59 XEvent* event,
60 Boolean *continueToDispatch);
61
62#define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
63#define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
64#define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
65
66extern wxList wxPendingDelete;
67
68#if !USE_SHARED_LIBRARY
69IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
70
71BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
72EVT_CHAR(wxWindow::OnChar)
73EVT_KEY_DOWN(wxWindow::OnKeyDown)
74EVT_KEY_UP(wxWindow::OnKeyUp)
75EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
76EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
77EVT_INIT_DIALOG(wxWindow::OnInitDialog)
78EVT_IDLE(wxWindow::OnIdle)
79END_EVENT_TABLE()
80
81#endif
82
83
84// Constructor
85wxWindow::wxWindow()
86{
87 // Generic
88 m_windowId = 0;
89 m_windowStyle = 0;
90 m_windowParent = NULL;
91 m_windowEventHandler = this;
92 m_windowName = "";
93 m_windowCursor = *wxSTANDARD_CURSOR;
94 m_children = new wxList;
95 m_constraints = NULL;
96 m_constraintsInvolvedIn = NULL;
97 m_windowSizer = NULL;
98 m_sizerParent = NULL;
99 m_autoLayout = FALSE;
100 m_windowValidator = NULL;
101 m_defaultItem = NULL;
102 m_returnCode = 0;
103 m_caretWidth = 0; m_caretHeight = 0;
104 m_caretEnabled = FALSE;
105 m_caretShown = FALSE;
106 // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
107 m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
108 m_foregroundColour = *wxBLACK;
109
110#if wxUSE_DRAG_AND_DROP
111 m_pDropTarget = NULL;
112#endif
113 m_clientObject = (wxClientData*) NULL;
114 m_clientData = NULL;
115
116 /// Motif-specific
117 m_mainWidget = (WXWidget) 0;
118 m_button1Pressed = FALSE;
119 m_button2Pressed = FALSE;
120 m_button3Pressed = FALSE;
121 m_winCaptured = FALSE;
122 m_isShown = TRUE;
123 m_hScrollBar = (WXWidget) 0;
124 m_vScrollBar = (WXWidget) 0;
125 m_borderWidget = (WXWidget) 0;
126 m_scrolledWindow = (WXWidget) 0;
127 m_drawingArea = (WXWidget) 0;
128 m_hScroll = FALSE;
129 m_vScroll = FALSE;
130 m_backingPixmap = (WXPixmap) 0;
131 m_pixmapWidth = 0;
132 m_pixmapHeight = 0;
133 m_pixmapOffsetX = 0;
134 m_pixmapOffsetY = 0;
135 m_lastTS = 0;
136 m_lastButton = 0;
137 m_canAddEventHandler = FALSE;
138 m_scrollPosX = 0;
139 m_scrollPosY = 0;
140}
141
142// Destructor
143wxWindow::~wxWindow()
144{
145 //// Motif-specific
146
147 if (GetMainWidget())
148 DetachWidget(GetMainWidget()); // Removes event handlers
149
150 // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
151 if (m_drawingArea)
152 {
153 // Destroy children before destroying self
154 DestroyChildren();
155
156 if (m_backingPixmap)
157 XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
158
159 Widget w = (Widget) m_drawingArea;
160 wxDeleteWindowFromTable(w);
161
162 if (w)
163 XtDestroyWidget(w);
164 m_mainWidget = (WXWidget) 0;
165
166 // Only if we're _really_ a canvas (not a dialog box/panel)
167 if (m_scrolledWindow)
168 {
169 wxDeleteWindowFromTable((Widget) m_scrolledWindow);
170 }
171
172 if (m_hScrollBar)
173 {
174 XtUnmanageChild ((Widget) m_hScrollBar);
175 XtDestroyWidget ((Widget) m_hScrollBar);
176 }
177 if (m_vScrollBar)
178 {
179 XtUnmanageChild ((Widget) m_vScrollBar);
180 XtDestroyWidget ((Widget) m_vScrollBar);
181 }
182 if (m_scrolledWindow)
183 {
184 XtUnmanageChild ((Widget) m_scrolledWindow);
185 XtDestroyWidget ((Widget) m_scrolledWindow);
186 }
187
188 if (m_borderWidget)
189 {
190 XtDestroyWidget ((Widget) m_borderWidget);
191 m_borderWidget = (WXWidget) 0;
192 }
193 }
194
195 //// Generic stuff
196
197 // Have to delete constraints/sizer FIRST otherwise
198 // sizers may try to look at deleted windows as they
199 // delete themselves.
200#if wxUSE_CONSTRAINTS
201 DeleteRelatedConstraints();
202 if (m_constraints)
203 {
204 // This removes any dangling pointers to this window
205 // in other windows' constraintsInvolvedIn lists.
206 UnsetConstraints(m_constraints);
207 delete m_constraints;
208 m_constraints = NULL;
209 }
210 if (m_windowSizer)
211 {
212 delete m_windowSizer;
213 m_windowSizer = NULL;
214 }
215 // If this is a child of a sizer, remove self from parent
216 if (m_sizerParent)
217 m_sizerParent->RemoveChild((wxWindow *)this);
218#endif
219
220 if (m_windowParent)
221 m_windowParent->RemoveChild(this);
222
223 DestroyChildren();
224
225 // Destroy the window
226 if (GetMainWidget())
227 {
228 wxDeleteWindowFromTable((Widget) GetMainWidget());
229 XtDestroyWidget((Widget) GetMainWidget());
230 SetMainWidget((WXWidget) NULL);
231 }
232
233 delete m_children;
234 m_children = NULL;
235
236 // Just in case the window has been Closed, but
237 // we're then deleting immediately: don't leave
238 // dangling pointers.
239 wxPendingDelete.DeleteObject(this);
240
241 if ( m_windowValidator ) delete m_windowValidator;
242 if (m_clientObject) delete m_clientObject;
243
244 ClearUpdateRects();
245}
246
247// Destroy the window (delayed, if a managed window)
248bool wxWindow::Destroy()
249{
250 delete this;
251 return TRUE;
252}
253
254// Constructor
255bool wxWindow::Create(wxWindow *parent, wxWindowID id,
256 const wxPoint& pos,
257 const wxSize& size,
258 long style,
259 const wxString& name)
260{
261 // Generic
262 m_windowId = 0;
263 m_windowStyle = 0;
264 m_windowParent = NULL;
265 m_windowEventHandler = this;
266 m_windowName = "";
267 m_windowCursor = *wxSTANDARD_CURSOR;
268 m_constraints = NULL;
269 m_constraintsInvolvedIn = NULL;
270 m_windowSizer = NULL;
271 m_sizerParent = NULL;
272 m_autoLayout = FALSE;
273 m_windowValidator = NULL;
274#if wxUSE_DRAG_AND_DROP
275 m_pDropTarget = NULL;
276#endif
277 m_caretWidth = 0; m_caretHeight = 0;
278 m_caretEnabled = FALSE;
279 m_caretShown = FALSE;
280 m_minSizeX = -1;
281 m_minSizeY = -1;
282 m_maxSizeX = -1;
283 m_maxSizeY = -1;
284 m_defaultItem = NULL;
285 m_windowParent = NULL;
286 m_clientObject = (wxClientData*) NULL;
287 m_clientData = NULL;
288
289 // Motif-specific
290 m_canAddEventHandler = FALSE;
291 m_mainWidget = (WXWidget) 0;
292 m_button1Pressed = FALSE;
293 m_button2Pressed = FALSE;
294 m_button3Pressed = FALSE;
295 m_winCaptured = FALSE;
296 m_isShown = TRUE;
297 m_hScrollBar = (WXWidget) 0;
298 m_vScrollBar = (WXWidget) 0;
299 m_borderWidget = (WXWidget) 0;
300 m_scrolledWindow = (WXWidget) 0;
301 m_drawingArea = (WXWidget) 0;
302 m_hScroll = FALSE;
303 m_vScroll = FALSE;
304 m_backingPixmap = (WXPixmap) 0;
305 m_pixmapWidth = 0;
306 m_pixmapHeight = 0;
307 m_pixmapOffsetX = 0;
308 m_pixmapOffsetY = 0;
309 m_scrollPosX = 0;
310 m_scrollPosY = 0;
311
312 if (!parent)
313 return FALSE;
314
315 if (parent) parent->AddChild(this);
316
317 m_returnCode = 0;
318
319 SetName(name);
320
321 if ( id == -1 )
322 m_windowId = (int)NewControlId();
323 else
324 m_windowId = id;
325
326 // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
327 m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
328 m_foregroundColour = *wxBLACK;
329
330 m_windowStyle = style;
331
332 if ( id == -1 )
333 m_windowId = (int)NewControlId();
334 else
335 m_windowId = id;
336
337 //// TODO: we should probably optimize by only creating a
338 //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
339 //// But for now, let's simplify things by always creating the
340 //// drawing area, since otherwise the translations are different.
341
342 // New translations for getting mouse motion feedback
343 String translations =
344 "<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
345<Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
346<Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
347<BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
348<Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
349<Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
350<Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
351<Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
352<Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
353<Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
354<Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
355<EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
356<LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
357<Key>: DrawingAreaInput()";
358
359 XtActionsRec actions[1];
360 actions[0].string = "wxCanvasMotionEvent";
361 actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
362 XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
363
364 Widget parentWidget = (Widget) parent->GetClientWidget();
365 if (style & wxBORDER)
366 m_borderWidget = (WXWidget) XtVaCreateManagedWidget ("canvasBorder",
367 xmFrameWidgetClass, parentWidget,
368 XmNshadowType, XmSHADOW_IN,
369 NULL);
370
371 m_scrolledWindow = (WXWidget) XtVaCreateManagedWidget ("scrolledWindow",
372 xmScrolledWindowWidgetClass, m_borderWidget ? (Widget) m_borderWidget : parentWidget,
373 XmNresizePolicy, XmRESIZE_NONE,
374 XmNspacing, 0,
375 XmNscrollingPolicy, XmAPPLICATION_DEFINED,
376 // XmNscrollBarDisplayPolicy, XmAS_NEEDED,
377 NULL);
378
379 XtTranslations ptr;
380 m_drawingArea = (WXWidget) XtVaCreateWidget ((char*) (const char*) name,
381 xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
382 XmNunitType, XmPIXELS,
383 // XmNresizePolicy, XmRESIZE_ANY,
384 XmNresizePolicy, XmRESIZE_NONE,
385 XmNmarginHeight, 0,
386 XmNmarginWidth, 0,
387 XmNtranslations, ptr = XtParseTranslationTable (translations),
388 NULL);
389 /*
390 if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
391 {
392 XtFree ((char *) ptr);
393 ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
394 XtOverrideTranslations ((Widget) m_drawingArea, ptr);
395 XtFree ((char *) ptr);
396 }
397 */
398
399 wxAddWindowToTable((Widget) m_drawingArea, this);
400 wxAddWindowToTable((Widget) m_scrolledWindow, this);
401
402 /*
403 * This order is very important in Motif 1.2.1
404 *
405 */
406
407 XtRealizeWidget ((Widget) m_scrolledWindow);
408 XtRealizeWidget ((Widget) m_drawingArea);
409 XtManageChild ((Widget) m_drawingArea);
410
411 XtOverrideTranslations ((Widget) m_drawingArea,
412 ptr = XtParseTranslationTable ("<Configure>: resize()"));
413 XtFree ((char *) ptr);
414
415 XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
416 XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
417
418 /* TODO?
419 display = XtDisplay (scrolledWindow);
420 xwindow = XtWindow (drawingArea);
421 */
422
423 XtAddEventHandler ((Widget) m_drawingArea, PointerMotionHintMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask,
424 False, (XtEventHandler) wxCanvasEnterLeave, (XtPointer) this);
425
426 // Scrolled widget needs to have its colour changed or we get
427 // a little blue square where the scrollbars abutt
428 wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
429 DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
430 DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
431
432 XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) 0, (Widget) 0, (Widget) m_drawingArea);
433
434 /*
435 if (m_hScrollBar)
436 XtRealizeWidget ((Widget) m_hScrollBar);
437 if (m_vScrollBar)
438 XtRealizeWidget ((Widget) m_vScrollBar);
439 */
440
441 // Without this, the cursor may not be restored properly
442 // (e.g. in splitter sample).
443 SetCursor(*wxSTANDARD_CURSOR);
444 SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
445 SetSize(pos.x, pos.y, size.x, size.y);
446
447 return TRUE;
448}
449
450// Helper function
451void wxWindow::CreateScrollbar(int orientation)
452{
453 if (!m_drawingArea)
454 return;
455
456 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
457
458 // Add scrollbars if required
459 if (orientation == wxHORIZONTAL)
460 {
461 Widget hScrollBar = XtVaCreateManagedWidget ("hsb",
462 xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
463 XmNorientation, XmHORIZONTAL,
464 NULL);
465 // XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
466 XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
467 XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
468 XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
469 XtAddCallback (hScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
470 XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
471 XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
472 XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
473
474 XtVaSetValues (hScrollBar,
475 XmNincrement, 1,
476 XmNvalue, 0,
477 NULL);
478
479 m_hScrollBar = (WXWidget) hScrollBar;
480
481 wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
482 DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
483
484 XtRealizeWidget(hScrollBar);
485
486 XtVaSetValues((Widget) m_scrolledWindow,
487 XmNhorizontalScrollBar, (Widget) m_hScrollBar,
488 NULL);
489
490 m_hScroll = TRUE;
491 }
492
493 if (orientation == wxVERTICAL)
494 {
495 Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
496 xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
497 XmNorientation, XmVERTICAL,
498 NULL);
499 // XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
500 XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
501 XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
502 XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
503 XtAddCallback (vScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
504 XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
505 XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
506 XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
507
508 XtVaSetValues (vScrollBar,
509 XmNincrement, 1,
510 XmNvalue, 0,
511 NULL);
512
513 m_vScrollBar = (WXWidget) vScrollBar;
514 wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
515 DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
516
517 XtRealizeWidget(vScrollBar);
518
519 XtVaSetValues((Widget) m_scrolledWindow,
520 XmNverticalScrollBar, (Widget) m_vScrollBar,
521 NULL);
522
523 m_vScroll = TRUE;
524 }
525
526 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
527}
528void wxWindow::DestroyScrollbar(int orientation)
529{
530 if (!m_drawingArea)
531 return;
532
533 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
534 // Add scrollbars if required
535 if (orientation == wxHORIZONTAL)
536 {
537 if (m_hScrollBar)
538 {
539 XtDestroyWidget((Widget) m_hScrollBar);
540 }
541 m_hScrollBar = (WXWidget) 0;
542 m_hScroll = FALSE;
543
544 XtVaSetValues((Widget) m_scrolledWindow,
545 XmNhorizontalScrollBar, (Widget) 0,
546 NULL);
547
548 }
549
550 if (orientation == wxVERTICAL)
551 {
552 if (m_vScrollBar)
553 {
554 XtDestroyWidget((Widget) m_vScrollBar);
555 }
556 m_vScrollBar = (WXWidget) 0;
557 m_vScroll = TRUE;
558
559 XtVaSetValues((Widget) m_scrolledWindow,
560 XmNverticalScrollBar, (Widget) 0,
561 NULL);
562
563 }
564 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
565}
566
567void wxWindow::SetFocus()
568{
569 XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
570 XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
571}
572
573void wxWindow::Enable(bool enable)
574{
575 if (GetMainWidget())
576 {
577 XtSetSensitive((Widget) GetMainWidget(), enable);
578 XmUpdateDisplay((Widget) GetMainWidget());
579 }
580}
581
582void wxWindow::CaptureMouse()
583{
584 if (m_winCaptured)
585 return;
586
587 if (GetMainWidget())
588 XtAddGrab((Widget) GetMainWidget(), TRUE, FALSE);
589
590 m_winCaptured = TRUE;
591}
592
593void wxWindow::ReleaseMouse()
594{
595 if (!m_winCaptured)
596 return;
597
598 if (GetMainWidget())
599 XtRemoveGrab((Widget) GetMainWidget());
600 m_winCaptured = FALSE;
601}
602
603// Push/pop event handler (i.e. allow a chain of event handlers
604// be searched)
605void wxWindow::PushEventHandler(wxEvtHandler *handler)
606{
607 handler->SetNextHandler(GetEventHandler());
608 SetEventHandler(handler);
609}
610
611wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
612{
613 if ( GetEventHandler() )
614 {
615 wxEvtHandler *handlerA = GetEventHandler();
616 wxEvtHandler *handlerB = handlerA->GetNextHandler();
617 handlerA->SetNextHandler(NULL);
618 SetEventHandler(handlerB);
619 if ( deleteHandler )
620 {
621 delete handlerA;
622 return NULL;
623 }
624 else
625 return handlerA;
626 }
627 else
628 return NULL;
629}
630
631#if wxUSE_DRAG_AND_DROP
632
633void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
634{
635 if ( m_pDropTarget != 0 ) {
636 delete m_pDropTarget;
637 }
638
639 m_pDropTarget = pDropTarget;
640 if ( m_pDropTarget != 0 )
641 {
642 // TODO
643 }
644}
645
646#endif
647
648// Old style file-manager drag&drop
649void wxWindow::DragAcceptFiles(bool accept)
650{
651 // TODO
652}
653
654// Get total size
655void wxWindow::GetSize(int *x, int *y) const
656{
657 if (m_drawingArea)
658 {
659 CanvasGetSize(x, y);
660 return;
661 }
662
663 Widget widget = (Widget) GetTopWidget();
664 Dimension xx, yy;
665 XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
666 *x = xx; *y = yy;
667}
668
669void wxWindow::GetPosition(int *x, int *y) const
670{
671 if (m_drawingArea)
672 {
673 CanvasGetPosition(x, y);
674 return;
675 }
676 Widget widget = (Widget) GetTopWidget();
677 Position xx, yy;
678 XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
679
680 // We may be faking the client origin.
681 // So a window that's really at (0, 30) may appear
682 // (to wxWin apps) to be at (0, 0).
683 if (GetParent())
684 {
685 wxPoint pt(GetParent()->GetClientAreaOrigin());
686 xx -= pt.x;
687 yy -= pt.y;
688 }
689
690 *x = xx; *y = yy;
691}
692
693void wxWindow::ScreenToClient(int *x, int *y) const
694{
695 Widget widget = (Widget) GetClientWidget();
696 Display *display = XtDisplay((Widget) GetMainWidget());
697 Window rootWindow = RootWindowOfScreen(XtScreen(widget));
698 Window thisWindow = XtWindow(widget);
699
700 Window childWindow;
701 int xx = *x;
702 int yy = *y;
703 XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
704}
705
706void wxWindow::ClientToScreen(int *x, int *y) const
707{
708 Widget widget = (Widget) GetClientWidget();
709 Display *display = XtDisplay(widget);
710 Window rootWindow = RootWindowOfScreen(XtScreen(widget));
711 Window thisWindow = XtWindow(widget);
712
713 Window childWindow;
714 int xx = *x;
715 int yy = *y;
716 XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
717}
718
719void wxWindow::SetCursor(const wxCursor& cursor)
720{
721 m_windowCursor = cursor;
722 if (m_windowCursor.Ok())
723 {
724 WXDisplay *dpy = GetXDisplay();
725 WXCursor x_cursor = ((wxCursor&)cursor).GetXCursor(dpy);
726
727 Widget w = (Widget) GetMainWidget();
728 Window win = XtWindow(w);
729 XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
730 }
731}
732
733
734// Get size *available for subwindows* i.e. excluding menu bar etc.
735void wxWindow::GetClientSize(int *x, int *y) const
736{
737 Widget widget = (Widget) GetClientWidget();
738 Dimension xx, yy;
739 XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
740 *x = xx; *y = yy;
741}
742
743void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
744{
745 // A bit of optimization to help sort out the flickers.
746 int oldX, oldY, oldW, oldH;
747 GetSize(& oldW, & oldH);
748 GetPosition(& oldX, & oldY);
749
750 bool useOldPos = FALSE;
751 bool useOldSize = FALSE;
752
753 if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
754 useOldPos = TRUE;
755 else if (x == oldX && y == oldY)
756 useOldPos = TRUE;
757
758 if ((width == -1) && (height == -1))
759 useOldSize = TRUE;
760 else if (width == oldW && height == oldH)
761 useOldSize = TRUE;
762
763 if (!wxNoOptimize::CanOptimize())
764 {
765 useOldSize = FALSE; useOldPos = FALSE;
766 }
767
768 if (useOldPos && useOldSize)
769 return;
770
771 if (m_drawingArea)
772 {
773 CanvasSetSize(x, y, width, height, sizeFlags);
774 return;
775 }
776 Widget widget = (Widget) GetTopWidget();
777 if (!widget)
778 return;
779
780 bool managed = XtIsManaged( widget );
781 if (managed)
782 XtUnmanageChild(widget);
783
784 int xx = x; int yy = y;
785 AdjustForParentClientOrigin(xx, yy, sizeFlags);
786
787 if (!useOldPos)
788 {
789 if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
790 XtVaSetValues(widget, XmNx, xx, NULL);
791 if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
792 XtVaSetValues(widget, XmNy, yy, NULL);
793 }
794 if (!useOldSize)
795 {
796 if (width > -1)
797 XtVaSetValues(widget, XmNwidth, width, NULL);
798 if (height > -1)
799 XtVaSetValues(widget, XmNheight, height, NULL);
800 }
801
802 if (managed)
803 XtManageChild(widget);
804
805 // How about this bit. Maybe we don't need to generate size events
806 // all the time -- they'll be generated when the window is sized anyway.
807 /*
808 wxSizeEvent sizeEvent(wxSize(width, height), GetId());
809 sizeEvent.SetEventObject(this);
810
811 GetEventHandler()->ProcessEvent(sizeEvent);
812 */
813}
814
815void wxWindow::SetClientSize(int width, int height)
816{
817 if (m_drawingArea)
818 {
819 CanvasSetClientSize(width, height);
820 return;
821 }
822
823 Widget widget = (Widget) GetTopWidget();
824
825 if (width > -1)
826 XtVaSetValues(widget, XmNwidth, width, NULL);
827 if (height > -1)
828 XtVaSetValues(widget, XmNheight, height, NULL);
829
830 wxSizeEvent sizeEvent(wxSize(width, height), GetId());
831 sizeEvent.SetEventObject(this);
832
833 GetEventHandler()->ProcessEvent(sizeEvent);
834}
835
836// For implementation purposes - sometimes decorations make the client area
837// smaller
838wxPoint wxWindow::GetClientAreaOrigin() const
839{
840 return wxPoint(0, 0);
841}
842
843// Makes an adjustment to the window position (for example, a frame that has
844// a toolbar that it manages itself).
845void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
846{
847 if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
848 {
849 wxPoint pt(GetParent()->GetClientAreaOrigin());
850 x += pt.x; y += pt.y;
851 }
852}
853
854bool wxWindow::Show(bool show)
855{
856 if (show)
857 {
858 if (m_borderWidget || m_scrolledWindow)
859 {
860 if (m_drawingArea)
861 XtMapWidget((Widget) m_drawingArea);
862 XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
863 }
864 else
865 {
866 WXWidget topWidget = GetTopWidget();
867 if (GetTopWidget())
868 XtMapWidget((Widget) GetTopWidget());
869 else if (GetMainWidget())
870 XtMapWidget((Widget) GetMainWidget());
871 }
872 }
873 else
874 {
875 if (m_borderWidget || m_scrolledWindow)
876 {
877 if (m_drawingArea)
878 XtUnmapWidget((Widget) m_drawingArea);
879 XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
880 }
881 else
882 {
883 if (GetTopWidget())
884 XtUnmapWidget((Widget) GetTopWidget());
885 else if (GetMainWidget())
886 XtUnmapWidget((Widget) GetMainWidget());
887 }
888 }
889
890 /*
891 Window xwin = (Window) GetXWindow();
892 Display *xdisp = (Display*) GetXDisplay();
893 if (show)
894 XMapWindow(xdisp, xwin);
895 else
896 XUnmapWindow(xdisp, xwin);
897 */
898
899 m_isShown = show;
900
901 return TRUE;
902}
903
904bool wxWindow::IsShown() const
905{
906 return m_isShown;
907}
908
909int wxWindow::GetCharHeight() const
910{
911 if (!m_windowFont.Ok())
912 return 0;
913
914 WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
915
916 int direction, ascent, descent;
917 XCharStruct overall;
918 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
919 &descent, &overall);
920 // return (overall.ascent + overall.descent);
921 return (ascent + descent);
922}
923
924int wxWindow::GetCharWidth() const
925{
926 if (!m_windowFont.Ok())
927 return 0;
928
929 WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
930
931 int direction, ascent, descent;
932 XCharStruct overall;
933 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
934 &descent, &overall);
935 return overall.width;
936}
937
938/* Helper function for 16-bit fonts */
939static int str16len(const char *s)
940{
941 int count = 0;
942
943 while (s[0] && s[1]) {
944 count++;
945 s += 2;
946 }
947
948 return count;
949}
950
951void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
952 int *descent, int *externalLeading, const wxFont *theFont, bool use16) const
953{
954 wxFont *fontToUse = (wxFont *)theFont;
955 if (!fontToUse)
956 fontToUse = (wxFont *) & m_windowFont;
957
958 if (!fontToUse->Ok())
959 return;
960
961 WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
962
963 int direction, ascent, descent2;
964 XCharStruct overall;
965 int slen;
966
967 if (use16) slen = str16len(string); else slen = strlen(string);
968
969 if (use16)
970 XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
971 &ascent, &descent2, &overall);
972 else
973 XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
974 &ascent, &descent2, &overall);
975
976 *x = (overall.width);
977 *y = (ascent + descent2);
978 if (descent)
979 *descent = descent2;
980 if (externalLeading)
981 *externalLeading = 0;
982}
983
984void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
985{
986 Display *display = XtDisplay((Widget) GetMainWidget());
987 Window thisWindow = XtWindow((Widget) GetMainWidget());
988
989 XExposeEvent dummyEvent;
990 int width, height;
991 GetSize(&width, &height);
992
993 dummyEvent.type = Expose;
994 dummyEvent.display = display;
995 dummyEvent.send_event = True;
996 dummyEvent.window = thisWindow;
997 if (rect)
998 {
999 dummyEvent.x = rect->x;
1000 dummyEvent.y = rect->y;
1001 dummyEvent.width = rect->width;
1002 dummyEvent.height = rect->height;
1003 }
1004 else
1005 {
1006 dummyEvent.x = 0;
1007 dummyEvent.y = 0;
1008 dummyEvent.width = width;
1009 dummyEvent.height = height;
1010 }
1011 dummyEvent.count = 0;
1012
1013 if (eraseBack)
1014 {
1015 wxClientDC dc(this);
1016 wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
1017 dc.SetBackground(backgroundBrush);
1018 if (rect)
1019 dc.Clear(*rect);
1020 else
1021 dc.Clear();
1022 }
1023
1024 XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
1025}
1026
1027// Responds to colour changes: passes event on to children.
1028void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
1029{
1030 wxNode *node = GetChildren().First();
1031 while ( node )
1032 {
1033 // Only propagate to non-top-level windows
1034 wxWindow *win = (wxWindow *)node->Data();
1035 if ( win->GetParent() )
1036 {
1037 wxSysColourChangedEvent event2;
1038 event.m_eventObject = win;
1039 win->GetEventHandler()->ProcessEvent(event2);
1040 }
1041
1042 node = node->Next();
1043 }
1044}
1045
1046// This can be called by the app (or wxWindows) to do default processing for the current
1047// event. Save message/event info in wxWindow so they can be used in this function.
1048long wxWindow::Default()
1049{
1050 // TODO
1051 return 0;
1052}
1053
1054void wxWindow::InitDialog()
1055{
1056 wxInitDialogEvent event(GetId());
1057 event.SetEventObject( this );
1058 GetEventHandler()->ProcessEvent(event);
1059}
1060
1061// Default init dialog behaviour is to transfer data to window
1062void wxWindow::OnInitDialog(wxInitDialogEvent& event)
1063{
1064 TransferDataToWindow();
1065}
1066
1067// Caret manipulation
1068void wxWindow::CreateCaret(int w, int h)
1069{
1070 m_caretWidth = w;
1071 m_caretHeight = h;
1072 m_caretEnabled = TRUE;
1073}
1074
1075void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
1076{
1077 // TODO
1078}
1079
1080void wxWindow::ShowCaret(bool show)
1081{
1082 // TODO
1083}
1084
1085void wxWindow::DestroyCaret()
1086{
1087 // TODO
1088 m_caretEnabled = FALSE;
1089}
1090
1091void wxWindow::SetCaretPos(int x, int y)
1092{
1093 // TODO
1094}
1095
1096void wxWindow::GetCaretPos(int *x, int *y) const
1097{
1098 // TODO
1099}
1100
1101wxWindow *wxGetActiveWindow()
1102{
1103 // TODO
1104 return NULL;
1105}
1106
1107void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
1108{
1109 m_minSizeX = minW;
1110 m_minSizeY = minH;
1111 m_maxSizeX = maxW;
1112 m_maxSizeY = maxH;
1113
1114 if (!this->IsKindOf(CLASSINFO(wxFrame)))
1115 return;
1116
1117 wxFrame *frame = (wxFrame *)this;
1118 Widget widget = (Widget) frame->GetShellWidget();
1119
1120 if (minW > -1)
1121 XtVaSetValues(widget, XmNminWidth, minW, NULL);
1122 if (minH > -1)
1123 XtVaSetValues(widget, XmNminHeight, minH, NULL);
1124 if (maxW > -1)
1125 XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
1126 if (maxH > -1)
1127 XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
1128 if (incW > -1)
1129 XtVaSetValues(widget, XmNwidthInc, incW, NULL);
1130 if (incH > -1)
1131 XtVaSetValues(widget, XmNheightInc, incH, NULL);
1132}
1133
1134void wxWindow::Centre(int direction)
1135{
1136 int x, y, width, height, panel_width, panel_height, new_x, new_y;
1137
1138 wxWindow *father = (wxWindow *)GetParent();
1139 if (!father)
1140 return;
1141
1142 father->GetClientSize(&panel_width, &panel_height);
1143 GetSize(&width, &height);
1144 GetPosition(&x, &y);
1145
1146 new_x = -1;
1147 new_y = -1;
1148
1149 if (direction & wxHORIZONTAL)
1150 new_x = (int)((panel_width - width)/2);
1151
1152 if (direction & wxVERTICAL)
1153 new_y = (int)((panel_height - height)/2);
1154
1155 SetSize(new_x, new_y, -1, -1);
1156
1157}
1158
1159// Coordinates relative to the window
1160void wxWindow::WarpPointer (int x, int y)
1161{
1162 XWarpPointer (XtDisplay((Widget) GetClientWidget()), None, XtWindow((Widget) GetClientWidget()), 0, 0, 0, 0, x, y);
1163}
1164
1165void wxWindow::OnEraseBackground(wxEraseEvent& event)
1166{
1167 // TODO
1168 Default();
1169}
1170
1171int wxWindow::GetScrollPos(int orient) const
1172{
1173 if (orient == wxHORIZONTAL)
1174 return m_scrollPosX;
1175 else
1176 return m_scrollPosY;
1177 /*
1178 Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1179 if (scrollBar)
1180 {
1181 int pos;
1182 XtVaGetValues(scrollBar,
1183 XmNvalue, &pos, NULL);
1184 return pos;
1185 }
1186 else
1187 return 0;
1188 */
1189}
1190
1191// This now returns the whole range, not just the number
1192// of positions that we can scroll.
1193int wxWindow::GetScrollRange(int orient) const
1194{
1195 Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1196 if (scrollBar)
1197 {
1198 int range;
1199 XtVaGetValues(scrollBar,
1200 XmNmaximum, &range, NULL);
1201 return range;
1202 }
1203 else
1204 return 0;
1205}
1206
1207int wxWindow::GetScrollThumb(int orient) const
1208{
1209 Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1210 if (scrollBar)
1211 {
1212 int thumb;
1213 XtVaGetValues(scrollBar,
1214 XmNsliderSize, &thumb, NULL);
1215 return thumb;
1216 }
1217 else
1218 return 0;
1219}
1220
1221void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
1222{
1223 Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1224 if (scrollBar)
1225 {
1226 XtVaSetValues (scrollBar,
1227 XmNvalue, pos,
1228 NULL);
1229 }
1230 if (orient == wxHORIZONTAL)
1231 m_scrollPosX = pos;
1232 else
1233 m_scrollPosY = pos;
1234
1235}
1236
1237// New function that will replace some of the above.
1238void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
1239 int range, bool WXUNUSED(refresh))
1240{
1241 int oldW, oldH;
1242 GetSize(& oldW, & oldH);
1243
1244 if (range == 0)
1245 range = 1;
1246 if (thumbVisible == 0)
1247 thumbVisible = 1;
1248
1249 if (thumbVisible > range)
1250 thumbVisible = range;
1251
1252 // Save the old state to see if it changed
1253 WXWidget oldScrollBar = ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
1254
1255 if (orient == wxHORIZONTAL)
1256 {
1257 if (thumbVisible == range)
1258 {
1259 if (m_hScrollBar)
1260 DestroyScrollbar(wxHORIZONTAL);
1261 }
1262 else
1263 {
1264 if (!m_hScrollBar)
1265 CreateScrollbar(wxHORIZONTAL);
1266 }
1267 }
1268 if (orient == wxVERTICAL)
1269 {
1270 if (thumbVisible == range)
1271 {
1272 if (m_vScrollBar)
1273 DestroyScrollbar(wxVERTICAL);
1274 }
1275 else
1276 {
1277 if (!m_vScrollBar)
1278 CreateScrollbar(wxVERTICAL);
1279 }
1280 }
1281 WXWidget newScrollBar = ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
1282
1283 if (oldScrollBar != newScrollBar)
1284 {
1285 // This is important! Without it, scrollbars misbehave
1286 // badly.
1287 XtUnrealizeWidget((Widget) m_scrolledWindow);
1288 XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
1289 XtRealizeWidget((Widget) m_scrolledWindow);
1290 XtManageChild((Widget) m_scrolledWindow);
1291 }
1292
1293 if (newScrollBar)
1294 XtVaSetValues((Widget) newScrollBar,
1295 XmNvalue, pos,
1296 XmNminimum, 0,
1297 XmNmaximum, range,
1298 XmNsliderSize, thumbVisible,
1299 NULL);
1300
1301 if (orient == wxHORIZONTAL)
1302 m_scrollPosX = pos;
1303 else
1304 m_scrollPosY = pos;
1305
1306 int newW, newH;
1307 GetSize(& newW, & newH);
1308
1309 // Adjusting scrollbars can resize the canvas accidentally
1310 if (newW != oldW || newH != oldH)
1311 SetSize(-1, -1, oldW, oldH);
1312}
1313
1314// Does a physical scroll
1315void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
1316{
1317 // cerr << "Scrolling. delta = " << dx << ", " << dy << endl;
1318 int x, y, w, h;
1319 if (rect)
1320 {
1321 // Use specified rectangle
1322 x = rect->x; y = rect->y; w = rect->width; h = rect->height;
1323 }
1324 else
1325 {
1326 // Use whole client area
1327 x = 0; y = 0;
1328 GetClientSize(& w, & h);
1329 }
1330
1331 int x1 = (dx >= 0) ? x : x - dx ;
1332 int y1 = (dy >= 0) ? y : y - dy;
1333 int w1 = w - abs(dx);
1334 int h1 = h - abs(dy);
1335 int x2 = (dx >= 0) ? x + dx : x;
1336 int y2 = (dy >= 0) ? y + dy : y;
1337
1338 wxClientDC dc(this);
1339
1340 dc.SetLogicalFunction (wxCOPY);
1341
1342 Widget widget = (Widget) GetMainWidget();
1343 Window window = XtWindow(widget);
1344 Display* display = XtDisplay(widget);
1345
1346 XCopyArea(display, window,
1347 window, (GC) dc.GetGC(),
1348 x1, y1,
1349 w1, h1,
1350 x2, y2);
1351
1352 dc.SetAutoSetting(TRUE);
1353 wxBrush brush(GetBackgroundColour(), wxSOLID);
1354 dc.SetBrush(brush); // ??
1355
1356 // We'll add rectangles to the list of update rectangles
1357 // according to which bits we've exposed.
1358 wxList updateRects;
1359
1360 if (dx > 0)
1361 {
1362 wxRect *rect = new wxRect;
1363 rect->x = x;
1364 rect->y = y;
1365 rect->width = dx;
1366 rect->height = h;
1367
1368 XFillRectangle(display, window,
1369 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1370
1371 rect->x = rect->x;
1372 rect->y = rect->y;
1373 rect->width = rect->width;
1374 rect->height = rect->height;
1375
1376 updateRects.Append((wxObject*) rect);
1377 }
1378 else if (dx < 0)
1379 {
1380 wxRect *rect = new wxRect;
1381
1382 rect->x = x + w + dx;
1383 rect->y = y;
1384 rect->width = -dx;
1385 rect->height = h;
1386
1387 XFillRectangle(display, window,
1388 (GC) dc.GetGC(), rect->x, rect->y, rect->width,
1389 rect->height);
1390
1391 rect->x = rect->x;
1392 rect->y = rect->y;
1393 rect->width = rect->width;
1394 rect->height = rect->height;
1395
1396 updateRects.Append((wxObject*) rect);
1397 }
1398 if (dy > 0)
1399 {
1400 wxRect *rect = new wxRect;
1401
1402 rect->x = x;
1403 rect->y = y;
1404 rect->width = w;
1405 rect->height = dy;
1406
1407 XFillRectangle(display, window,
1408 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1409
1410 rect->x = rect->x;
1411 rect->y = rect->y;
1412 rect->width = rect->width;
1413 rect->height = rect->height;
1414
1415 updateRects.Append((wxObject*) rect);
1416 }
1417 else if (dy < 0)
1418 {
1419 wxRect *rect = new wxRect;
1420
1421 rect->x = x;
1422 rect->y = y + h + dy;
1423 rect->width = w;
1424 rect->height = -dy;
1425
1426 XFillRectangle(display, window,
1427 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1428
1429 rect->x = rect->x;
1430 rect->y = rect->y;
1431 rect->width = rect->width;
1432 rect->height = rect->height;
1433
1434 updateRects.Append((wxObject*) rect);
1435 }
1436 dc.SetBrush(wxNullBrush);
1437
1438 // Now send expose events
1439
1440 wxNode* node = updateRects.First();
1441 while (node)
1442 {
1443 wxRect* rect = (wxRect*) node->Data();
1444 XExposeEvent event;
1445
1446 event.type = Expose;
1447 event.display = display;
1448 event.send_event = True;
1449 event.window = window;
1450
1451 event.x = rect->x;
1452 event.y = rect->y;
1453 event.width = rect->width;
1454 event.height = rect->height;
1455
1456 event.count = 0;
1457
1458 XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
1459
1460 node = node->Next();
1461
1462 }
1463
1464 // Delete the update rects
1465 node = updateRects.First();
1466 while (node)
1467 {
1468 wxRect* rect = (wxRect*) node->Data();
1469 delete rect;
1470 node = node->Next();
1471 }
1472
1473}
1474
1475void wxWindow::OnChar(wxKeyEvent& event)
1476{
1477/* ??
1478if ( event.KeyCode() == WXK_TAB ) {
1479// propagate the TABs to the parent - it's up to it to decide what
1480// to do with it
1481if ( GetParent() ) {
1482if ( GetParent()->ProcessEvent(event) )
1483return;
1484}
1485}
1486 */
1487}
1488
1489void wxWindow::OnKeyDown(wxKeyEvent& event)
1490{
1491 Default();
1492}
1493
1494void wxWindow::OnKeyUp(wxKeyEvent& event)
1495{
1496 Default();
1497}
1498
1499void wxWindow::OnPaint(wxPaintEvent& event)
1500{
1501 Default();
1502}
1503
1504bool wxWindow::IsEnabled() const
1505{
1506 // TODO. Is this right?
1507 // return XtGetSensitive((Widget) GetMainWidget());
1508 return FALSE;
1509}
1510
1511// Dialog support: override these and call
1512// base class members to add functionality
1513// that can't be done using validators.
1514// NOTE: these functions assume that controls
1515// are direct children of this window, not grandchildren
1516// or other levels of descendant.
1517
1518// Transfer values to controls. If returns FALSE,
1519// it's an application error (pops up a dialog)
1520bool wxWindow::TransferDataToWindow()
1521{
1522 wxNode *node = GetChildren().First();
1523 while ( node )
1524 {
1525 wxWindow *child = (wxWindow *)node->Data();
1526 if ( child->GetValidator() &&
1527 !child->GetValidator()->TransferToWindow() )
1528 {
1529 wxLogError("Could not transfer data to window.");
1530 return FALSE;
1531 }
1532
1533 node = node->Next();
1534 }
1535 return TRUE;
1536}
1537
1538// Transfer values from controls. If returns FALSE,
1539// validation failed: don't quit
1540bool wxWindow::TransferDataFromWindow()
1541{
1542 wxNode *node = GetChildren().First();
1543 while ( node )
1544 {
1545 wxWindow *child = (wxWindow *)node->Data();
1546 if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
1547 {
1548 return FALSE;
1549 }
1550
1551 node = node->Next();
1552 }
1553 return TRUE;
1554}
1555
1556bool wxWindow::Validate()
1557{
1558 wxNode *node = GetChildren().First();
1559 while ( node )
1560 {
1561 wxWindow *child = (wxWindow *)node->Data();
1562 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
1563 {
1564 return FALSE;
1565 }
1566
1567 node = node->Next();
1568 }
1569 return TRUE;
1570}
1571
1572// Get the window with the focus
1573wxWindow *wxWindow::FindFocus()
1574{
1575 // TODO
1576 return NULL;
1577}
1578
1579void wxWindow::AddChild(wxWindow *child)
1580{
1581 GetChildren().Append(child);
1582 child->m_windowParent = this;
1583}
1584
1585void wxWindow::RemoveChild(wxWindow *child)
1586{
1587 GetChildren().DeleteObject(child);
1588 child->m_windowParent = NULL;
1589}
1590
1591// Reparents this window to have the new parent.
1592bool wxWindow::Reparent(wxWindow* WXUNUSED(parent))
1593{
1594 // For now, we indicate that this isn't implemented.
1595 return FALSE;
1596}
1597
1598void wxWindow::DestroyChildren()
1599{
1600 wxNode *node = GetChildren().First();
1601 while (node)
1602 {
1603 wxNode* next = node->Next();
1604 wxWindow* child = (wxWindow*) node->Data();
1605 delete child;
1606 node = next;
1607 }
1608 GetChildren().Clear();
1609#if 0
1610 wxNode *node;
1611 while ((node = GetChildren().First()) != (wxNode *)NULL) {
1612 wxWindow *child;
1613 if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
1614 delete child;
1615 if ( GetChildren().Member(child) )
1616 delete node;
1617 }
1618 } /* while */
1619#endif
1620}
1621
1622void wxWindow::MakeModal(bool modal)
1623{
1624 // Disable all other windows
1625 if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
1626 {
1627 wxNode *node = wxTopLevelWindows.First();
1628 while (node)
1629 {
1630 wxWindow *win = (wxWindow *)node->Data();
1631 if (win != this)
1632 win->Enable(!modal);
1633
1634 node = node->Next();
1635 }
1636 }
1637}
1638
1639// If nothing defined for this, try the parent.
1640// E.g. we may be a button loaded from a resource, with no callback function
1641// defined.
1642void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
1643{
1644 if (GetEventHandler()->ProcessEvent(event) )
1645 return;
1646 if (m_windowParent)
1647 m_windowParent->GetEventHandler()->OnCommand(win, event);
1648}
1649
1650void wxWindow::SetConstraints(wxLayoutConstraints *c)
1651{
1652 if (m_constraints)
1653 {
1654 UnsetConstraints(m_constraints);
1655 delete m_constraints;
1656 }
1657 m_constraints = c;
1658 if (m_constraints)
1659 {
1660 // Make sure other windows know they're part of a 'meaningful relationship'
1661 if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
1662 m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1663 if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
1664 m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1665 if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
1666 m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1667 if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
1668 m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1669 if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
1670 m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1671 if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
1672 m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1673 if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
1674 m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1675 if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
1676 m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1677 }
1678}
1679
1680// This removes any dangling pointers to this window
1681// in other windows' constraintsInvolvedIn lists.
1682void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
1683{
1684 if (c)
1685 {
1686 if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1687 c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1688 if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1689 c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1690 if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
1691 c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1692 if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
1693 c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1694 if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
1695 c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1696 if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
1697 c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1698 if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
1699 c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1700 if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
1701 c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1702 }
1703}
1704
1705// Back-pointer to other windows we're involved with, so if we delete
1706// this window, we must delete any constraints we're involved with.
1707void wxWindow::AddConstraintReference(wxWindow *otherWin)
1708{
1709 if (!m_constraintsInvolvedIn)
1710 m_constraintsInvolvedIn = new wxList;
1711 if (!m_constraintsInvolvedIn->Member(otherWin))
1712 m_constraintsInvolvedIn->Append(otherWin);
1713}
1714
1715// REMOVE back-pointer to other windows we're involved with.
1716void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
1717{
1718 if (m_constraintsInvolvedIn)
1719 m_constraintsInvolvedIn->DeleteObject(otherWin);
1720}
1721
1722// Reset any constraints that mention this window
1723void wxWindow::DeleteRelatedConstraints()
1724{
1725 if (m_constraintsInvolvedIn)
1726 {
1727 wxNode *node = m_constraintsInvolvedIn->First();
1728 while (node)
1729 {
1730 wxWindow *win = (wxWindow *)node->Data();
1731 wxNode *next = node->Next();
1732 wxLayoutConstraints *constr = win->GetConstraints();
1733
1734 // Reset any constraints involving this window
1735 if (constr)
1736 {
1737 constr->left.ResetIfWin((wxWindow *)this);
1738 constr->top.ResetIfWin((wxWindow *)this);
1739 constr->right.ResetIfWin((wxWindow *)this);
1740 constr->bottom.ResetIfWin((wxWindow *)this);
1741 constr->width.ResetIfWin((wxWindow *)this);
1742 constr->height.ResetIfWin((wxWindow *)this);
1743 constr->centreX.ResetIfWin((wxWindow *)this);
1744 constr->centreY.ResetIfWin((wxWindow *)this);
1745 }
1746 delete node;
1747 node = next;
1748 }
1749 delete m_constraintsInvolvedIn;
1750 m_constraintsInvolvedIn = NULL;
1751 }
1752}
1753
1754void wxWindow::SetSizer(wxSizer *sizer)
1755{
1756 m_windowSizer = sizer;
1757 if (sizer)
1758 sizer->SetSizerParent((wxWindow *)this);
1759}
1760
1761/*
1762* New version
1763*/
1764
1765bool wxWindow::Layout()
1766{
1767 if (GetConstraints())
1768 {
1769 int w, h;
1770 GetClientSize(&w, &h);
1771 GetConstraints()->width.SetValue(w);
1772 GetConstraints()->height.SetValue(h);
1773 }
1774
1775 // If top level (one sizer), evaluate the sizer's constraints.
1776 if (GetSizer())
1777 {
1778 int noChanges;
1779 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
1780 GetSizer()->LayoutPhase1(&noChanges);
1781 GetSizer()->LayoutPhase2(&noChanges);
1782 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
1783 return TRUE;
1784 }
1785 else
1786 {
1787 // Otherwise, evaluate child constraints
1788 ResetConstraints(); // Mark all constraints as unevaluated
1789 DoPhase(1); // Just one phase need if no sizers involved
1790 DoPhase(2);
1791 SetConstraintSizes(); // Recursively set the real window sizes
1792 }
1793 return TRUE;
1794}
1795
1796
1797// Do a phase of evaluating constraints:
1798// the default behaviour. wxSizers may do a similar
1799// thing, but also impose their own 'constraints'
1800// and order the evaluation differently.
1801bool wxWindow::LayoutPhase1(int *noChanges)
1802{
1803 wxLayoutConstraints *constr = GetConstraints();
1804 if (constr)
1805 {
1806 return constr->SatisfyConstraints((wxWindow *)this, noChanges);
1807 }
1808 else
1809 return TRUE;
1810}
1811
1812bool wxWindow::LayoutPhase2(int *noChanges)
1813{
1814 *noChanges = 0;
1815
1816 // Layout children
1817 DoPhase(1);
1818 DoPhase(2);
1819 return TRUE;
1820}
1821
1822// Do a phase of evaluating child constraints
1823bool wxWindow::DoPhase(int phase)
1824{
1825 int noIterations = 0;
1826 int maxIterations = 500;
1827 int noChanges = 1;
1828 int noFailures = 0;
1829 wxList succeeded;
1830 while ((noChanges > 0) && (noIterations < maxIterations))
1831 {
1832 noChanges = 0;
1833 noFailures = 0;
1834 wxNode *node = GetChildren().First();
1835 while (node)
1836 {
1837 wxWindow *child = (wxWindow *)node->Data();
1838 if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
1839 {
1840 wxLayoutConstraints *constr = child->GetConstraints();
1841 if (constr)
1842 {
1843 if (succeeded.Member(child))
1844 {
1845 }
1846 else
1847 {
1848 int tempNoChanges = 0;
1849 bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1850 noChanges += tempNoChanges;
1851 if (success)
1852 {
1853 succeeded.Append(child);
1854 }
1855 }
1856 }
1857 }
1858 node = node->Next();
1859 }
1860 noIterations ++;
1861 }
1862 return TRUE;
1863}
1864
1865void wxWindow::ResetConstraints()
1866{
1867 wxLayoutConstraints *constr = GetConstraints();
1868 if (constr)
1869 {
1870 constr->left.SetDone(FALSE);
1871 constr->top.SetDone(FALSE);
1872 constr->right.SetDone(FALSE);
1873 constr->bottom.SetDone(FALSE);
1874 constr->width.SetDone(FALSE);
1875 constr->height.SetDone(FALSE);
1876 constr->centreX.SetDone(FALSE);
1877 constr->centreY.SetDone(FALSE);
1878 }
1879 wxNode *node = GetChildren().First();
1880 while (node)
1881 {
1882 wxWindow *win = (wxWindow *)node->Data();
1883 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1884 win->ResetConstraints();
1885 node = node->Next();
1886 }
1887}
1888
1889// Need to distinguish between setting the 'fake' size for
1890// windows and sizers, and setting the real values.
1891void wxWindow::SetConstraintSizes(bool recurse)
1892{
1893 wxLayoutConstraints *constr = GetConstraints();
1894 if (constr && constr->left.GetDone() && constr->right.GetDone() &&
1895 constr->width.GetDone() && constr->height.GetDone())
1896 {
1897 int x = constr->left.GetValue();
1898 int y = constr->top.GetValue();
1899 int w = constr->width.GetValue();
1900 int h = constr->height.GetValue();
1901
1902 // If we don't want to resize this window, just move it...
1903 if ((constr->width.GetRelationship() != wxAsIs) ||
1904 (constr->height.GetRelationship() != wxAsIs))
1905 {
1906 // Calls Layout() recursively. AAAGH. How can we stop that.
1907 // Simply take Layout() out of non-top level OnSizes.
1908 SizerSetSize(x, y, w, h);
1909 }
1910 else
1911 {
1912 SizerMove(x, y);
1913 }
1914 }
1915 else if (constr)
1916 {
1917 char *windowClass = this->GetClassInfo()->GetClassName();
1918
1919 wxString winName;
1920 if (GetName() == "")
1921 winName = "unnamed";
1922 else
1923 winName = GetName();
1924 wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
1925 if (!constr->left.GetDone())
1926 wxDebugMsg(" unsatisfied 'left' constraint.\n");
1927 if (!constr->right.GetDone())
1928 wxDebugMsg(" unsatisfied 'right' constraint.\n");
1929 if (!constr->width.GetDone())
1930 wxDebugMsg(" unsatisfied 'width' constraint.\n");
1931 if (!constr->height.GetDone())
1932 wxDebugMsg(" unsatisfied 'height' constraint.\n");
1933 wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
1934 }
1935
1936 if (recurse)
1937 {
1938 wxNode *node = GetChildren().First();
1939 while (node)
1940 {
1941 wxWindow *win = (wxWindow *)node->Data();
1942 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1943 win->SetConstraintSizes();
1944 node = node->Next();
1945 }
1946 }
1947}
1948
1949// This assumes that all sizers are 'on' the same
1950// window, i.e. the parent of this window.
1951void wxWindow::TransformSizerToActual(int *x, int *y) const
1952{
1953 if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
1954 m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
1955 return;
1956
1957 int xp, yp;
1958 m_sizerParent->GetPosition(&xp, &yp);
1959 m_sizerParent->TransformSizerToActual(&xp, &yp);
1960 *x += xp;
1961 *y += yp;
1962}
1963
1964void wxWindow::SizerSetSize(int x, int y, int w, int h)
1965{
1966 int xx = x;
1967 int yy = y;
1968 TransformSizerToActual(&xx, &yy);
1969 SetSize(xx, yy, w, h);
1970}
1971
1972void wxWindow::SizerMove(int x, int y)
1973{
1974 int xx = x;
1975 int yy = y;
1976 TransformSizerToActual(&xx, &yy);
1977 Move(xx, yy);
1978}
1979
1980// Only set the size/position of the constraint (if any)
1981void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
1982{
1983 wxLayoutConstraints *constr = GetConstraints();
1984 if (constr)
1985 {
1986 if (x != -1)
1987 {
1988 constr->left.SetValue(x);
1989 constr->left.SetDone(TRUE);
1990 }
1991 if (y != -1)
1992 {
1993 constr->top.SetValue(y);
1994 constr->top.SetDone(TRUE);
1995 }
1996 if (w != -1)
1997 {
1998 constr->width.SetValue(w);
1999 constr->width.SetDone(TRUE);
2000 }
2001 if (h != -1)
2002 {
2003 constr->height.SetValue(h);
2004 constr->height.SetDone(TRUE);
2005 }
2006 }
2007}
2008
2009void wxWindow::MoveConstraint(int x, int y)
2010{
2011 wxLayoutConstraints *constr = GetConstraints();
2012 if (constr)
2013 {
2014 if (x != -1)
2015 {
2016 constr->left.SetValue(x);
2017 constr->left.SetDone(TRUE);
2018 }
2019 if (y != -1)
2020 {
2021 constr->top.SetValue(y);
2022 constr->top.SetDone(TRUE);
2023 }
2024 }
2025}
2026
2027void wxWindow::GetSizeConstraint(int *w, int *h) const
2028{
2029 wxLayoutConstraints *constr = GetConstraints();
2030 if (constr)
2031 {
2032 *w = constr->width.GetValue();
2033 *h = constr->height.GetValue();
2034 }
2035 else
2036 GetSize(w, h);
2037}
2038
2039void wxWindow::GetClientSizeConstraint(int *w, int *h) const
2040{
2041 wxLayoutConstraints *constr = GetConstraints();
2042 if (constr)
2043 {
2044 *w = constr->width.GetValue();
2045 *h = constr->height.GetValue();
2046 }
2047 else
2048 GetClientSize(w, h);
2049}
2050
2051void wxWindow::GetPositionConstraint(int *x, int *y) const
2052{
2053 wxLayoutConstraints *constr = GetConstraints();
2054 if (constr)
2055 {
2056 *x = constr->left.GetValue();
2057 *y = constr->top.GetValue();
2058 }
2059 else
2060 GetPosition(x, y);
2061}
2062
2063bool wxWindow::Close(bool force)
2064{
2065 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
2066 event.SetEventObject(this);
2067 event.SetForce(force);
2068
2069 return GetEventHandler()->ProcessEvent(event);
2070}
2071
2072wxObject* wxWindow::GetChild(int number) const
2073{
2074 // Return a pointer to the Nth object in the window
2075 wxNode *node = GetChildren().First();
2076 int n = number;
2077 while (node && n--)
2078 node = node->Next() ;
2079 if (node)
2080 {
2081 wxObject *obj = (wxObject *)node->Data();
2082 return(obj) ;
2083 }
2084 else
2085 return NULL ;
2086}
2087
2088void wxWindow::OnDefaultAction(wxControl *initiatingItem)
2089{
2090 // Obsolete function
2091}
2092
2093void wxWindow::Clear()
2094{
2095 wxClientDC dc(this);
2096 wxBrush brush(GetBackgroundColour(), wxSOLID);
2097 dc.SetBackground(brush);
2098 dc.Clear();
2099}
2100
2101// Fits the panel around the items
2102void wxWindow::Fit()
2103{
2104 int maxX = 0;
2105 int maxY = 0;
2106 wxNode *node = GetChildren().First();
2107 while ( node )
2108 {
2109 wxWindow *win = (wxWindow *)node->Data();
2110 int wx, wy, ww, wh;
2111 win->GetPosition(&wx, &wy);
2112 win->GetSize(&ww, &wh);
2113 if ( wx + ww > maxX )
2114 maxX = wx + ww;
2115 if ( wy + wh > maxY )
2116 maxY = wy + wh;
2117
2118 node = node->Next();
2119 }
2120 SetClientSize(maxX + 5, maxY + 5);
2121}
2122
2123void wxWindow::SetValidator(const wxValidator& validator)
2124{
2125 if ( m_windowValidator )
2126 delete m_windowValidator;
2127 m_windowValidator = validator.Clone();
2128
2129 if ( m_windowValidator )
2130 m_windowValidator->SetWindow(this) ;
2131}
2132
2133void wxWindow::SetClientObject( wxClientData *data )
2134{
2135 if (m_clientObject) delete m_clientObject;
2136 m_clientObject = data;
2137}
2138
2139wxClientData *wxWindow::GetClientObject()
2140{
2141 return m_clientObject;
2142}
2143
2144void wxWindow::SetClientData( void *data )
2145{
2146 m_clientData = data;
2147}
2148
2149void *wxWindow::GetClientData()
2150{
2151 return m_clientData;
2152}
2153
2154// Find a window by id or name
2155wxWindow *wxWindow::FindWindow(long id)
2156{
2157 if ( GetId() == id)
2158 return this;
2159
2160 wxNode *node = GetChildren().First();
2161 while ( node )
2162 {
2163 wxWindow *child = (wxWindow *)node->Data();
2164 wxWindow *found = child->FindWindow(id);
2165 if ( found )
2166 return found;
2167 node = node->Next();
2168 }
2169 return NULL;
2170}
2171
2172wxWindow *wxWindow::FindWindow(const wxString& name)
2173{
2174 if ( GetName() == name)
2175 return this;
2176
2177 wxNode *node = GetChildren().First();
2178 while ( node )
2179 {
2180 wxWindow *child = (wxWindow *)node->Data();
2181 wxWindow *found = child->FindWindow(name);
2182 if ( found )
2183 return found;
2184 node = node->Next();
2185 }
2186 return NULL;
2187}
2188
2189void wxWindow::OnIdle(wxIdleEvent& event)
2190{
2191 // This calls the UI-update mechanism (querying windows for
2192 // menu/toolbar/control state information)
2193 UpdateWindowUI();
2194}
2195
2196// Raise the window to the top of the Z order
2197void wxWindow::Raise()
2198{
2199 Window window = XtWindow((Widget) GetTopWidget());
2200 XRaiseWindow(XtDisplay((Widget) GetTopWidget()), window);
2201}
2202
2203// Lower the window to the bottom of the Z order
2204void wxWindow::Lower()
2205{
2206 Window window = XtWindow((Widget) GetTopWidget());
2207 XLowerWindow(XtDisplay((Widget) GetTopWidget()), window);
2208}
2209
2210bool wxWindow::AcceptsFocus() const
2211{
2212 return IsShown() && IsEnabled();
2213}
2214
2215// Update region access
2216wxRegion& wxWindow::GetUpdateRegion() const
2217{
2218 return (wxRegion&) m_updateRegion;
2219}
2220
2221bool wxWindow::IsExposed(int x, int y, int w, int h) const
2222{
2223 return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
2224}
2225
2226bool wxWindow::IsExposed(const wxPoint& pt) const
2227{
2228 return (m_updateRegion.Contains(pt) != wxOutRegion);
2229}
2230
2231bool wxWindow::IsExposed(const wxRect& rect) const
2232{
2233 return (m_updateRegion.Contains(rect) != wxOutRegion);
2234}
2235
2236/*
2237* Allocates control IDs
2238*/
2239
2240int wxWindow::NewControlId()
2241{
2242 static int s_controlId = 0;
2243 s_controlId ++;
2244 return s_controlId;
2245}
2246
2247void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel)
2248{
2249 m_acceleratorTable = accel;
2250}
2251
2252// All widgets should have this as their resize proc.
2253// OnSize sent to wxWindow via client data.
2254void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
2255{
2256 wxWindow *win = (wxWindow *)wxWidgetHashTable->Get((long)w);
2257 if (!win)
2258 return;
2259
2260 if (win->PreResize())
2261 {
2262 int width, height;
2263 win->GetSize(&width, &height);
2264 wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
2265 sizeEvent.SetEventObject(win);
2266 win->GetEventHandler()->ProcessEvent(sizeEvent);
2267 }
2268}
2269
2270bool wxAddWindowToTable(Widget w, wxWindow *win)
2271{
2272 wxWindow *oldItem = NULL;
2273 // printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
2274 if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
2275 {
2276 wxLogError("Widget table clash: new widget is %ld, %s", (long)w, win->GetClassInfo()->GetClassName());
2277 return FALSE;
2278 }
2279
2280 wxWidgetHashTable->Put ((long) w, win);
2281 return TRUE;
2282}
2283
2284wxWindow *wxGetWindowFromTable(Widget w)
2285{
2286 return (wxWindow *)wxWidgetHashTable->Get ((long) w);
2287}
2288
2289void wxDeleteWindowFromTable(Widget w)
2290{
2291 wxWidgetHashTable->Delete((long)w);
2292}
2293
2294// Get the underlying X window and display
2295WXWindow wxWindow::GetXWindow() const
2296{
2297 return (WXWindow) XtWindow((Widget) GetMainWidget());
2298}
2299
2300WXDisplay *wxWindow::GetXDisplay() const
2301{
2302 return (WXDisplay*) XtDisplay((Widget) GetMainWidget());
2303}
2304
2305WXWidget wxWindow::GetMainWidget() const
2306{
2307 if (m_drawingArea)
2308 return m_drawingArea;
2309 else
2310 return m_mainWidget;
2311}
2312
2313WXWidget wxWindow::GetClientWidget() const
2314{
2315 if (m_drawingArea != (WXWidget) 0)
2316 return m_drawingArea;
2317 else
2318 return GetMainWidget();
2319}
2320
2321WXWidget wxWindow::GetTopWidget() const
2322{
2323 return GetMainWidget();
2324}
2325
2326void wxCanvasRepaintProc (Widget drawingArea, XtPointer clientData,
2327 XmDrawingAreaCallbackStruct * cbs)
2328{
2329 if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))
2330 return;
2331
2332 XEvent * event = cbs->event;
2333 wxWindow * win = (wxWindow *) clientData;
2334 Display * display = (Display *) win->GetXDisplay();
2335
2336 switch (event->type)
2337 {
2338 case Expose:
2339 {
2340 wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
2341 event->xexpose.width, event->xexpose.height);
2342 /*
2343 cout << "Expose proc. wxRect: " << rect->x << ", " << rect->y << ", ";
2344 cout << rect->width << ", " << rect->height << "\n\n";
2345 */
2346
2347 win->m_updateRects.Append((wxObject*) rect);
2348
2349 if (event -> xexpose.count == 0)
2350 {
2351 wxPaintEvent event(win->GetId());
2352 event.SetEventObject(win);
2353 win->GetEventHandler()->ProcessEvent(event);
2354
2355 win->ClearUpdateRects();
2356 }
2357 break;
2358 }
2359 default:
2360 {
2361 cout << "\n\nNew Event ! is = " << event -> type << "\n";
2362 break;
2363 }
2364 }
2365}
2366
2367// Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
2368void
2369wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event)
2370{
2371 XmDrawingAreaCallbackStruct cbs;
2372 XEvent ev;
2373
2374 //if (event->mode!=NotifyNormal)
2375 // return ;
2376
2377 // ev = *((XEvent *) event); // Causes Purify error (copying too many bytes)
2378 ((XCrossingEvent &) ev) = *event;
2379
2380 cbs.reason = XmCR_INPUT;
2381 cbs.event = &ev;
2382
2383 wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2384}
2385
2386// Fix to make it work under Motif 1.0 (!)
2387void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
2388{
2389#if XmVersion<=1000
2390
2391 XmDrawingAreaCallbackStruct cbs;
2392 XEvent ev;
2393
2394 //ev.xbutton = *event;
2395 ev = *((XEvent *) event);
2396 cbs.reason = XmCR_INPUT;
2397 cbs.event = &ev;
2398
2399 wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2400#endif
2401}
2402
2403void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs)
2404{
2405 wxWindow *canvas = (wxWindow *) wxWidgetHashTable->Get ((long) (Widget) drawingArea);
2406 XEvent local_event;
2407
2408 if (canvas==NULL)
2409 return ;
2410
2411 if (cbs->reason != XmCR_INPUT)
2412 return;
2413
2414 local_event = *(cbs->event); // We must keep a copy!
2415
2416 /*
2417 switch (local_event.xany.type)
2418 {
2419 case EnterNotify:
2420 cout << "EnterNotify\n";
2421 break;
2422 case LeaveNotify:
2423 cout << "LeaveNotify\n";
2424 break;
2425 case ButtonPress:
2426 cout << "ButtonPress\n";
2427 break;
2428 case ButtonRelease:
2429 cout << "ButtonRelease\n";
2430 break;
2431 case MotionNotify:
2432 cout << "MotionNotify\n";
2433 break;
2434 default:
2435 cout << "Something else\n";
2436 break;
2437 }
2438 */
2439
2440 switch (local_event.xany.type)
2441 {
2442 case EnterNotify:
2443 case LeaveNotify:
2444 case ButtonPress:
2445 case ButtonRelease:
2446 case MotionNotify:
2447 {
2448 wxEventType eventType = wxEVT_NULL;
2449
2450 if (local_event.xany.type == EnterNotify)
2451 {
2452 //if (local_event.xcrossing.mode!=NotifyNormal)
2453 // return ; // Ignore grab events
2454 eventType = wxEVT_ENTER_WINDOW;
2455 // canvas->GetEventHandler()->OnSetFocus();
2456 }
2457 else if (local_event.xany.type == LeaveNotify)
2458 {
2459 //if (local_event.xcrossing.mode!=NotifyNormal)
2460 // return ; // Ignore grab events
2461 eventType = wxEVT_LEAVE_WINDOW;
2462 // canvas->GetEventHandler()->OnKillFocus();
2463 }
2464 else if (local_event.xany.type == MotionNotify)
2465 {
2466 eventType = wxEVT_MOTION;
2467 if (local_event.xmotion.is_hint == NotifyHint)
2468 {
2469 Window root, child;
2470 Display *dpy = XtDisplay (drawingArea);
2471
2472 XQueryPointer (dpy, XtWindow (drawingArea),
2473 &root, &child,
2474 &local_event.xmotion.x_root,
2475 &local_event.xmotion.y_root,
2476 &local_event.xmotion.x,
2477 &local_event.xmotion.y,
2478 &local_event.xmotion.state);
2479 }
2480 else
2481 {
2482 }
2483 }
2484
2485 else if (local_event.xany.type == ButtonPress)
2486 {
2487 if (local_event.xbutton.button == Button1)
2488 {
2489 eventType = wxEVT_LEFT_DOWN;
2490 canvas->m_button1Pressed = TRUE;
2491 }
2492 else if (local_event.xbutton.button == Button2)
2493 {
2494 eventType = wxEVT_MIDDLE_DOWN;
2495 canvas->m_button2Pressed = TRUE;
2496 }
2497 else if (local_event.xbutton.button == Button3)
2498 {
2499 eventType = wxEVT_RIGHT_DOWN;
2500 canvas->m_button3Pressed = TRUE;
2501 }
2502 }
2503 else if (local_event.xany.type == ButtonRelease)
2504 {
2505 if (local_event.xbutton.button == Button1)
2506 {
2507 eventType = wxEVT_LEFT_UP;
2508 canvas->m_button1Pressed = FALSE;
2509 }
2510 else if (local_event.xbutton.button == Button2)
2511 {
2512 eventType = wxEVT_MIDDLE_UP;
2513 canvas->m_button2Pressed = FALSE;
2514 }
2515 else if (local_event.xbutton.button == Button3)
2516 {
2517 eventType = wxEVT_RIGHT_UP;
2518 canvas->m_button3Pressed = FALSE;
2519 }
2520 }
2521
2522 wxMouseEvent wxevent (eventType);
2523 wxevent.m_eventHandle = (char *) &local_event;
2524
2525 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2526 || (event_left_is_down (&local_event)
2527 && (eventType != wxEVT_LEFT_UP)));
2528 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2529 || (event_middle_is_down (&local_event)
2530 && (eventType != wxEVT_MIDDLE_UP)));
2531 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2532 || (event_right_is_down (&local_event)
2533 && (eventType != wxEVT_RIGHT_UP)));
2534
2535 wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
2536 wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
2537 wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
2538 wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
2539 wxevent.SetTimestamp(local_event.xbutton.time);
2540
2541 // Now check if we need to translate this event into a double click
2542 if (TRUE) // canvas->doubleClickAllowed)
2543 {
2544 if (wxevent.ButtonDown())
2545 {
2546 long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay()) ;
2547
2548 // get button and time-stamp
2549 int button = 0;
2550 if (wxevent.LeftDown()) button = 1;
2551 else if (wxevent.MiddleDown()) button = 2;
2552 else if (wxevent.RightDown()) button = 3;
2553 long ts = wxevent.GetTimestamp();
2554 // check, if single or double click
2555 if (canvas->m_lastButton && canvas->m_lastButton==button && (ts - canvas->m_lastTS) < dclickTime)
2556 {
2557 // I have a dclick
2558 canvas->m_lastButton = 0;
2559 switch ( eventType )
2560 {
2561 case wxEVT_LEFT_DOWN:
2562 wxevent.SetEventType(wxEVT_LEFT_DCLICK);
2563 break;
2564 case wxEVT_MIDDLE_DOWN:
2565 wxevent.SetEventType(wxEVT_MIDDLE_DCLICK);
2566 break;
2567 case wxEVT_RIGHT_DOWN:
2568 wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
2569 break;
2570
2571 default :
2572 break;
2573 }
2574
2575 }
2576 else
2577 {
2578 // not fast enough or different button
2579 canvas->m_lastTS = ts;
2580 canvas->m_lastButton = button;
2581 }
2582 }
2583 }
2584
2585 wxevent.SetId(canvas->GetId());
2586 wxevent.SetEventObject(canvas);
2587 wxevent.m_x = local_event.xbutton.x;
2588 wxevent.m_y = local_event.xbutton.y;
2589 canvas->GetEventHandler()->ProcessEvent (wxevent);
2590 /*
2591 if (eventType == wxEVT_ENTER_WINDOW ||
2592 eventType == wxEVT_LEAVE_WINDOW ||
2593 eventType == wxEVT_MOTION
2594 )
2595 return;
2596 */
2597 break;
2598 }
2599 case KeyPress:
2600 {
2601 KeySym keySym;
2602 // XComposeStatus compose;
2603 // (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
2604 (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
2605 int id = wxCharCodeXToWX (keySym);
2606
2607 wxEventType eventType = wxEVT_CHAR;
2608
2609 // TODO: Is this the correct criterion for wxEVT_KEY_DOWN down versus wxEVT_CHAR?
2610 if (id > WXK_START) // Non-ASCII values
2611 eventType = wxEVT_KEY_DOWN;
2612
2613 wxKeyEvent event (eventType);
2614
2615 if (local_event.xkey.state & ShiftMask)
2616 event.m_shiftDown = TRUE;
2617 if (local_event.xkey.state & ControlMask)
2618 event.m_controlDown = TRUE;
2619 if (local_event.xkey.state & Mod3Mask)
2620 event.m_altDown = TRUE;
2621 if (local_event.xkey.state & Mod1Mask)
2622 event.m_metaDown = TRUE;
2623 event.SetEventObject(canvas);
2624 event.m_keyCode = id;
2625 event.SetTimestamp(local_event.xkey.time);
2626
2627 if (id > -1)
2628 {
2629 // Implement wxFrame::OnCharHook by checking ancestor.
2630 wxWindow *parent = canvas->GetParent();
2631 while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
2632 parent = parent->GetParent();
2633
2634 if (parent)
2635 {
2636 event.SetEventType(wxEVT_CHAR_HOOK);
2637 if (parent->GetEventHandler()->ProcessEvent(event))
2638 return;
2639 event.SetEventType(wxEVT_CHAR);
2640 }
2641
2642 canvas->GetEventHandler()->ProcessEvent (event);
2643 }
2644 break;
2645 }
2646 case KeyRelease:
2647 {
2648 KeySym keySym;
2649 (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
2650 int id = wxCharCodeXToWX (keySym);
2651
2652 wxKeyEvent event (wxEVT_KEY_UP);
2653
2654 if (local_event.xkey.state & ShiftMask)
2655 event.m_shiftDown = TRUE;
2656 if (local_event.xkey.state & ControlMask)
2657 event.m_controlDown = TRUE;
2658 if (local_event.xkey.state & Mod3Mask)
2659 event.m_altDown = TRUE;
2660 if (local_event.xkey.state & Mod1Mask)
2661 event.m_metaDown = TRUE;
2662 event.SetEventObject(canvas);
2663 event.m_keyCode = id;
2664 event.SetTimestamp(local_event.xkey.time);
2665
2666 if (id > -1)
2667 {
2668 canvas->GetEventHandler()->ProcessEvent (event);
2669 }
2670 break;
2671 }
2672 case FocusIn:
2673 {
2674 if (local_event.xfocus.detail != NotifyPointer)
2675 {
2676 wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
2677 event.SetEventObject(canvas);
2678 canvas->GetEventHandler()->ProcessEvent(event);
2679 }
2680 break;
2681 }
2682 case FocusOut:
2683 {
2684 if (local_event.xfocus.detail != NotifyPointer)
2685 {
2686 wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
2687 event.SetEventObject(canvas);
2688 canvas->GetEventHandler()->ProcessEvent(event);
2689 }
2690 break;
2691 }
2692 default:
2693 break;
2694 }
2695}
2696
2697void wxWindow::DoPaint()
2698{
2699 //TODO : make a temporary gc so we can do the XCopyArea below
2700 if (0) // m_backingPixmap)
2701 {
2702 /*
2703 Widget drawingArea = (Widget) m_drawingArea;
2704 // int orig = GetDC()->GetLogicalFunction();
2705 // GetDC()->SetLogicalFunction (wxCOPY);
2706
2707 // TODO: it may not be necessary to store m_pixmapOffsetX/Y; we
2708 // should be able to calculate them.
2709 XCopyArea (XtDisplay (drawingArea), m_backingPixmap, XtWindow (drawingArea), GetDC ()->gc,
2710 m_pixmapOffsetX, m_pixmapOffsetY,
2711 m_pixmapWidth, m_pixmapHeight,
2712 0, 0);
2713
2714 // GetDC()->SetLogicalFunction (orig);
2715 */
2716 }
2717 else
2718 {
2719 wxPaintEvent event(GetId());
2720 event.SetEventObject(this);
2721 GetEventHandler()->ProcessEvent(event);
2722 }
2723}
2724
2725// SetSize, but as per old wxCanvas (with drawing widget etc.)
2726void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
2727{
2728 // A bit of optimization to help sort out the flickers.
2729 int oldX, oldY, oldW, oldH;
2730 GetSize(& oldW, & oldH);
2731 GetPosition(& oldX, & oldY);
2732
2733 bool useOldPos = FALSE;
2734 bool useOldSize = FALSE;
2735
2736 if ((x == -1) && (x == -1) && ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0))
2737 useOldPos = TRUE;
2738 else if (x == oldX && y == oldY)
2739 useOldPos = TRUE;
2740
2741 if ((w == -1) && (h == -1))
2742 useOldSize = TRUE;
2743 else if (w == oldW && h == oldH)
2744 useOldSize = TRUE;
2745
2746 if (!wxNoOptimize::CanOptimize())
2747 {
2748 useOldSize = FALSE; useOldPos = FALSE;
2749 }
2750
2751 if (useOldPos && useOldSize)
2752 return;
2753
2754 Widget drawingArea = (Widget) m_drawingArea;
2755 bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2756
2757 if (managed)
2758 XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2759 XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2760
2761 int xx = x; int yy = y;
2762 AdjustForParentClientOrigin(xx, yy, sizeFlags);
2763
2764 if (!useOldPos)
2765 {
2766 if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2767 {
2768 XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2769 XmNx, xx, NULL);
2770 }
2771
2772 if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2773 {
2774 XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2775 XmNy, yy, NULL);
2776 }
2777 }
2778
2779 if (!useOldSize)
2780 {
2781
2782 if (w > -1)
2783 {
2784 if (m_borderWidget)
2785 {
2786 XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
2787 short thick, margin;
2788 XtVaGetValues ((Widget) m_borderWidget,
2789 XmNshadowThickness, &thick,
2790 XmNmarginWidth, &margin,
2791 NULL);
2792 w -= 2 * (thick + margin);
2793 }
2794
2795 XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
2796
2797 Dimension spacing;
2798 Widget sbar;
2799 XtVaGetValues ((Widget) m_scrolledWindow,
2800 XmNspacing, &spacing,
2801 XmNverticalScrollBar, &sbar,
2802 NULL);
2803 Dimension wsbar;
2804 if (sbar)
2805 XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
2806 else
2807 wsbar = 0;
2808
2809 w -= (spacing + wsbar);
2810
2811 // XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2812 }
2813 if (h > -1)
2814 {
2815 if (m_borderWidget)
2816 {
2817 XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
2818 short thick, margin;
2819 XtVaGetValues ((Widget) m_borderWidget,
2820 XmNshadowThickness, &thick,
2821 XmNmarginHeight, &margin,
2822 NULL);
2823 h -= 2 * (thick + margin);
2824 }
2825
2826 XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
2827
2828 Dimension spacing;
2829 Widget sbar;
2830 XtVaGetValues ((Widget) m_scrolledWindow,
2831 XmNspacing, &spacing,
2832 XmNhorizontalScrollBar, &sbar,
2833 NULL);
2834 Dimension wsbar;
2835 if (sbar)
2836 XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
2837 else
2838 wsbar = 0;
2839
2840 h -= (spacing + wsbar);
2841
2842 // XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2843
2844 }
2845 }
2846
2847 if (managed)
2848 XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2849 XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2850
2851 /*
2852 int ww, hh;
2853 GetClientSize (&ww, &hh);
2854 wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
2855 sizeEvent.SetEventObject(this);
2856
2857 GetEventHandler()->ProcessEvent(sizeEvent);
2858 */
2859
2860}
2861
2862void wxWindow::CanvasSetClientSize (int w, int h)
2863{
2864 Widget drawingArea = (Widget) m_drawingArea;
2865
2866 XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2867
2868 if (w > -1)
2869 XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2870 if (h > -1)
2871 XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2872 /* TODO: is this necessary?
2873 allowRepainting = FALSE;
2874
2875 XSync (XtDisplay (drawingArea), FALSE);
2876 XEvent event;
2877 while (XtAppPending (wxTheApp->appContext))
2878 {
2879 XFlush (XtDisplay (drawingArea));
2880 XtAppNextEvent (wxTheApp->appContext, &event);
2881 XtDispatchEvent (&event);
2882 }
2883 */
2884
2885 XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2886
2887 /* TODO
2888 allowRepainting = TRUE;
2889 DoRefresh ();
2890 */
2891
2892 /*
2893 wxSizeEvent sizeEvent(wxSize(w, h), GetId());
2894 sizeEvent.SetEventObject(this);
2895
2896 GetEventHandler()->ProcessEvent(sizeEvent);
2897 */
2898}
2899
2900void wxWindow::CanvasGetClientSize (int *w, int *h) const
2901{
2902 // Must return the same thing that was set via SetClientSize
2903 Dimension xx, yy;
2904 XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2905 *w = xx;
2906 *h = yy;
2907}
2908
2909void wxWindow::CanvasGetSize (int *w, int *h) const
2910{
2911 Dimension xx, yy;
2912 if ((Widget) m_borderWidget)
2913 XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
2914 else if ((Widget) m_scrolledWindow)
2915 XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
2916 else
2917 XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2918
2919 *w = xx;
2920 *h = yy;
2921}
2922
2923void wxWindow::CanvasGetPosition (int *x, int *y) const
2924{
2925 Position xx, yy;
2926 XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
2927
2928 // We may be faking the client origin.
2929 // So a window that's really at (0, 30) may appear
2930 // (to wxWin apps) to be at (0, 0).
2931 if (GetParent())
2932 {
2933 wxPoint pt(GetParent()->GetClientAreaOrigin());
2934 xx -= pt.x;
2935 yy -= pt.y;
2936 }
2937
2938 *x = xx;
2939 *y = yy;
2940}
2941
2942// Add to hash table, add event handler
2943bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
2944 WXWidget formWidget, int x, int y, int width, int height)
2945{
2946 wxAddWindowToTable((Widget) mainWidget, this);
2947 if (CanAddEventHandler())
2948 {
2949 XtAddEventHandler((Widget) mainWidget,
2950 ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2951 False,
2952 wxPanelItemEventHandler,
2953 (XtPointer) this);
2954 }
2955
2956 if (!formWidget)
2957 {
2958 XtTranslations ptr;
2959 XtOverrideTranslations ((Widget) mainWidget,
2960 ptr = XtParseTranslationTable ("<Configure>: resize()"));
2961 XtFree ((char *) ptr);
2962 }
2963
2964 // Some widgets have a parent form widget, e.g. wxRadioBox
2965 if (formWidget)
2966 {
2967 if (!wxAddWindowToTable((Widget) formWidget, this))
2968 return FALSE;
2969
2970 XtTranslations ptr;
2971 XtOverrideTranslations ((Widget) formWidget,
2972 ptr = XtParseTranslationTable ("<Configure>: resize()"));
2973 XtFree ((char *) ptr);
2974 }
2975
2976 if (x == -1)
2977 x = 0;
2978 if (y == -1)
2979 y = 0;
2980 SetSize (x, y, width, height);
2981
2982 return TRUE;
2983}
2984
2985// Remove event handler, remove from hash table
2986bool wxWindow::DetachWidget(WXWidget widget)
2987{
2988 if (CanAddEventHandler())
2989 {
2990 XtRemoveEventHandler((Widget) widget,
2991 ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2992 False,
2993 wxPanelItemEventHandler,
2994 (XtPointer)this);
2995 }
2996
2997 wxDeleteWindowFromTable((Widget) widget);
2998 return TRUE;
2999}
3000
3001void wxPanelItemEventHandler (Widget wid,
3002 XtPointer client_data,
3003 XEvent* event,
3004 Boolean *continueToDispatch)
3005{
3006 // Widget can be a label or the actual widget.
3007
3008 wxWindow *window = (wxWindow *)wxWidgetHashTable->Get((long)wid);
3009 if (window)
3010 {
3011 wxMouseEvent wxevent(0);
3012 if (wxTranslateMouseEvent(wxevent, window, wid, event))
3013 {
3014 window->GetEventHandler()->ProcessEvent(wxevent);
3015 }
3016 }
3017 // TODO: probably the key to allowing default behaviour
3018 // to happen.
3019 // Say we set a m_doDefault flag to FALSE at the start of this
3020 // function. Then in e.g. wxWindow::OnMouseEvent we can
3021 // call Default() which sets this flag to TRUE, indicating
3022 // that default processing can happen. Thus, behaviour can appear
3023 // to be overridden just by adding an event handler and not calling
3024 // wxWindow::OnWhatever.
3025 // ALSO, maybe we can use this instead of the current way of handling
3026 // drawing area events, to simplify things.
3027 *continueToDispatch = True;
3028}
3029
3030static void wxScrollBarCallback(Widget scrollbar, XtPointer clientData,
3031 XmScaleCallbackStruct *cbs)
3032{
3033 Widget scrolledWindow = XtParent (scrollbar);
3034 wxWindow *win = (wxWindow *) wxWidgetHashTable->Get ((long) scrolledWindow);
3035 int orientation = (int) clientData;
3036
3037 wxEventType eventType = wxEVT_NULL;
3038 switch (cbs->reason)
3039 {
3040 case XmCR_INCREMENT:
3041 {
3042 eventType = wxEVT_SCROLL_LINEDOWN;
3043 break;
3044 }
3045 case XmCR_DECREMENT:
3046 {
3047 eventType = wxEVT_SCROLL_LINEUP;
3048 break;
3049 }
3050 case XmCR_DRAG:
3051 {
3052 eventType = wxEVT_SCROLL_THUMBTRACK;
3053 break;
3054 }
3055 case XmCR_VALUE_CHANGED:
3056 {
3057 // TODO: Should this be intercepted too, or will it cause
3058 // duplicate events?
3059 eventType = wxEVT_SCROLL_THUMBTRACK;
3060 break;
3061 }
3062 case XmCR_PAGE_INCREMENT:
3063 {
3064 eventType = wxEVT_SCROLL_PAGEDOWN;
3065 break;
3066 }
3067 case XmCR_PAGE_DECREMENT:
3068 {
3069 eventType = wxEVT_SCROLL_PAGEUP;
3070 break;
3071 }
3072 case XmCR_TO_TOP:
3073 {
3074 eventType = wxEVT_SCROLL_TOP;
3075 break;
3076 }
3077 case XmCR_TO_BOTTOM:
3078 {
3079 eventType = wxEVT_SCROLL_BOTTOM;
3080 break;
3081 }
3082 default:
3083 {
3084 // Should never get here
3085 wxFAIL_MSG("Unknown scroll event.");
3086 break;
3087 }
3088 }
3089
3090 wxScrollEvent event(eventType, win->GetId());
3091 event.SetEventObject(win);
3092 event.SetPosition(cbs->value);
3093 event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
3094
3095 win->GetEventHandler()->ProcessEvent(event);
3096}
3097
3098bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
3099{
3100 switch (xevent->xany.type)
3101 {
3102 case EnterNotify:
3103 case LeaveNotify:
3104 case ButtonPress:
3105 case ButtonRelease:
3106 case MotionNotify:
3107 {
3108 wxEventType eventType = wxEVT_NULL;
3109
3110 if (xevent->xany.type == LeaveNotify)
3111 {
3112 win->m_button1Pressed = FALSE;
3113 win->m_button2Pressed = FALSE;
3114 win->m_button3Pressed = FALSE;
3115 return FALSE;
3116 }
3117 else if (xevent->xany.type == MotionNotify)
3118 {
3119 eventType = wxEVT_MOTION;
3120 }
3121 else if (xevent->xany.type == ButtonPress)
3122 {
3123 if (xevent->xbutton.button == Button1)
3124 {
3125 eventType = wxEVT_LEFT_DOWN;
3126 win->m_button1Pressed = TRUE;
3127 }
3128 else if (xevent->xbutton.button == Button2)
3129 {
3130 eventType = wxEVT_MIDDLE_DOWN;
3131 win->m_button2Pressed = TRUE;
3132 }
3133 else if (xevent->xbutton.button == Button3)
3134 {
3135 eventType = wxEVT_RIGHT_DOWN;
3136 win->m_button3Pressed = TRUE;
3137 }
3138 }
3139 else if (xevent->xany.type == ButtonRelease)
3140 {
3141 if (xevent->xbutton.button == Button1)
3142 {
3143 eventType = wxEVT_LEFT_UP;
3144 win->m_button1Pressed = FALSE;
3145 }
3146 else if (xevent->xbutton.button == Button2)
3147 {
3148 eventType = wxEVT_MIDDLE_UP;
3149 win->m_button2Pressed = FALSE;
3150 }
3151 else if (xevent->xbutton.button == Button3)
3152 {
3153 eventType = wxEVT_RIGHT_UP;
3154 win->m_button3Pressed = FALSE;
3155 }
3156 else return FALSE;
3157 }
3158 else return FALSE;
3159
3160 wxevent.m_eventHandle = (char *)xevent;
3161 wxevent.SetEventType(eventType);
3162
3163 Position x1, y1;
3164 XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
3165
3166 int x2, y2;
3167 win->GetPosition(&x2, &y2);
3168
3169 // The button x/y must be translated to wxWindows
3170 // window space - the widget might be a label or button,
3171 // within a form.
3172 int dx = 0;
3173 int dy = 0;
3174 if (widget != (Widget)win->GetMainWidget())
3175 {
3176 dx = x1;
3177 dy = y1;
3178 }
3179
3180 wxevent.m_x = xevent->xbutton.x + dx;
3181 wxevent.m_y = xevent->xbutton.y + dy;
3182
3183 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
3184 || (event_left_is_down (xevent)
3185 && (eventType != wxEVT_LEFT_UP)));
3186 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
3187 || (event_middle_is_down (xevent)
3188 && (eventType != wxEVT_MIDDLE_UP)));
3189 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
3190 || (event_right_is_down (xevent)
3191 && (eventType != wxEVT_RIGHT_UP)));
3192
3193 wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
3194 wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
3195 return TRUE;
3196 }
3197 }
3198 return FALSE;
3199}
3200
3201bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
3202{
3203 switch (xevent->xany.type)
3204 {
3205 case KeyPress:
3206 {
3207 char buf[20];
3208
3209 KeySym keySym;
3210 // XComposeStatus compose;
3211 // (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
3212 (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
3213 int id = wxCharCodeXToWX (keySym);
3214
3215 if (xevent->xkey.state & ShiftMask)
3216 wxevent.m_shiftDown = TRUE;
3217 if (xevent->xkey.state & ControlMask)
3218 wxevent.m_controlDown = TRUE;
3219 if (xevent->xkey.state & Mod3Mask)
3220 wxevent.m_altDown = TRUE;
3221 if (xevent->xkey.state & Mod1Mask)
3222 wxevent.m_metaDown = TRUE;
3223 wxevent.SetEventObject(win);
3224 wxevent.m_keyCode = id;
3225 wxevent.SetTimestamp(xevent->xkey.time);
3226
3227 wxevent.m_x = xevent->xbutton.x;
3228 wxevent.m_y = xevent->xbutton.y;
3229
3230 if (id > -1)
3231 return TRUE;
3232 else
3233 return FALSE;
3234 break;
3235 }
3236 default:
3237 break;
3238 }
3239 return FALSE;
3240}
3241
3242#define YAllocColor XAllocColor
3243XColor g_itemColors[5];
3244int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
3245{
3246 int result;
3247 static XmColorProc colorProc;
3248
3249 result = wxNO_COLORS;
3250
3251 if (back)
3252 {
3253 g_itemColors[0].red = (((long) back->Red ()) << 8);
3254 g_itemColors[0].green = (((long) back->Green ()) << 8);
3255 g_itemColors[0].blue = (((long) back->Blue ()) << 8);
3256 g_itemColors[0].flags = DoRed | DoGreen | DoBlue;
3257 if (colorProc == (XmColorProc) NULL)
3258 {
3259 // Get a ptr to the actual function
3260 colorProc = XmSetColorCalculation ((XmColorProc) NULL);
3261 // And set it back to motif.
3262 XmSetColorCalculation (colorProc);
3263 }
3264 (*colorProc) (&g_itemColors[wxBACK_INDEX],
3265 &g_itemColors[wxFORE_INDEX],
3266 &g_itemColors[wxSELE_INDEX],
3267 &g_itemColors[wxTOPS_INDEX],
3268 &g_itemColors[wxBOTS_INDEX]);
3269 result = wxBACK_COLORS;
3270 }
3271 if (fore)
3272 {
3273 g_itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
3274 g_itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
3275 g_itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
3276 g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
3277 if (result == wxNO_COLORS)
3278 result = wxFORE_COLORS;
3279 }
3280
3281 Display *dpy = display;
3282 Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
3283
3284 if (back)
3285 {
3286 /* 5 Colours to allocate */
3287 for (int i = 0; i < 5; i++)
3288 if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
3289 result = wxNO_COLORS;
3290 }
3291 else if (fore)
3292 {
3293 /* Only 1 colour to allocate */
3294 if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
3295 result = wxNO_COLORS;
3296 }
3297
3298 return (result);
3299
3300}
3301
3302// Changes the foreground and background colours to be derived
3303// from the current background colour.
3304// To change the foreground colour, you must call SetForegroundColour
3305// explicitly.
3306void wxWindow::ChangeBackgroundColour()
3307{
3308 if (GetMainWidget())
3309 DoChangeBackgroundColour(GetMainWidget(), m_backgroundColour);
3310
3311 // This not necessary
3312#if 0
3313
3314 if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
3315 {
3316 DoChangeBackgroundColour(m_scrolledWindow, m_backgroundColour);
3317 // Have to set the scrollbar colours back since
3318 // the scrolled window seemed to change them
3319 wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
3320
3321 if (m_hScrollBar)
3322 DoChangeBackgroundColour(m_hScrollBar, backgroundColour);
3323 if (m_vScrollBar)
3324 DoChangeBackgroundColour(m_vScrollBar, backgroundColour);
3325 }
3326#endif
3327}
3328
3329void wxWindow::ChangeForegroundColour()
3330{
3331 if (GetMainWidget())
3332 DoChangeForegroundColour(GetMainWidget(), m_foregroundColour);
3333 if (m_scrolledWindow && (GetMainWidget() != m_scrolledWindow))
3334 DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
3335}
3336
3337// Change a widget's foreground and background colours.
3338
3339void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
3340{
3341 // When should we specify the foreground, if it's calculated
3342 // by wxComputeColours?
3343 // Solution: say we start with the default (computed) foreground colour.
3344 // If we call SetForegroundColour explicitly for a control or window,
3345 // then the foreground is changed.
3346 // Therefore SetBackgroundColour computes the foreground colour, and
3347 // SetForegroundColour changes the foreground colour. The ordering is
3348 // important.
3349
3350 XtVaSetValues ((Widget) widget,
3351 XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
3352 NULL);
3353}
3354
3355void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
3356{
3357 wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
3358 (wxColour*) NULL);
3359
3360 XtVaSetValues ((Widget) widget,
3361 XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
3362 XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
3363 XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
3364 XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
3365 NULL);
3366
3367 if (changeArmColour)
3368 XtVaSetValues ((Widget) widget,
3369 XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
3370 NULL);
3371}
3372
3373void wxWindow::SetBackgroundColour(const wxColour& col)
3374{
3375 m_backgroundColour = col;
3376 ChangeBackgroundColour();
3377}
3378
3379void wxWindow::SetForegroundColour(const wxColour& col)
3380{
3381 m_foregroundColour = col;
3382 ChangeForegroundColour();
3383}
3384
3385void wxWindow::ChangeFont(bool keepOriginalSize)
3386{
3387 // Note that this causes the widget to be resized back
3388 // to its original size! We therefore have to set the size
3389 // back again. TODO: a better way in Motif?
3390 Widget w = (Widget) GetLabelWidget(); // Usually the main widget
3391 if (w && m_windowFont.Ok())
3392 {
3393 int width, height, width1, height1;
3394 GetSize(& width, & height);
3395
3396 // lesstif 0.87 hangs here
3397#ifndef LESSTIF_VERSION
3398 XtVaSetValues (w,
3399 XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
3400 NULL);
3401#endif
3402
3403 GetSize(& width1, & height1);
3404 if (keepOriginalSize && (width != width1 || height != height1))
3405 {
3406 SetSize(-1, -1, width, height);
3407 }
3408 }
3409}
3410
3411void wxWindow::SetFont(const wxFont& font)
3412{
3413 m_windowFont = font;
3414 ChangeFont();
3415}
3416
3417void wxWindow::ClearUpdateRects()
3418{
3419 wxNode* node = m_updateRects.First();
3420 while (node)
3421 {
3422 wxRect* rect = (wxRect*) node->Data();
3423 delete rect;
3424 node = node->Next();
3425 }
3426 m_updateRects.Clear();
3427}
3428
3429bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
3430{
3431 if (!m_acceleratorTable.Ok())
3432 return FALSE;
3433
3434 int count = m_acceleratorTable.GetCount();
3435 wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
3436 int i;
3437 for (i = 0; i < count; i++)
3438 {
3439 wxAcceleratorEntry* entry = & (entries[i]);
3440 if (entry->MatchesEvent(event))
3441 {
3442 // Bingo, we have a match. Now find a control
3443 // that matches the entry command id.
3444
3445 // Need to go up to the top of the window hierarchy,
3446 // since it might be e.g. a menu item
3447 wxWindow* parent = this;
3448 while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)) && !parent->IsKindOf(CLASSINFO(wxDialog)))
3449 parent = parent->GetParent();
3450
3451 if (!parent)
3452 return FALSE;
3453
3454 if (parent->IsKindOf(CLASSINFO(wxFrame)))
3455 {
3456 // Try for a menu command
3457 wxFrame* frame = (wxFrame*) parent;
3458 if (frame->GetMenuBar())
3459 {
3460 wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
3461 if (item)
3462 {
3463 wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
3464 commandEvent.SetEventObject(frame);
3465
3466 // If ProcessEvent returns TRUE (it was handled), then
3467 // the calling code will skip the event handling.
3468 return frame->GetEventHandler()->ProcessEvent(commandEvent);
3469 }
3470 }
3471 }
3472
3473 // Find a child matching the command id
3474 wxWindow* child = parent->FindWindow(entry->GetCommand());
3475
3476 // No such child
3477 if (!child)
3478 return FALSE;
3479
3480 // Now we process those kinds of windows that we can.
3481 // For now, only buttons.
3482 if (child->IsKindOf(CLASSINFO(wxButton)))
3483 {
3484 wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
3485 commandEvent.SetEventObject(child);
3486 return child->GetEventHandler()->ProcessEvent(commandEvent);
3487 }
3488
3489 return FALSE;
3490 } // matches event
3491 }// for
3492
3493 // We didn't match the key event against an accelerator.
3494 return FALSE;
3495}
3496
3497/*
3498* wxNoOptimize: switch off size optimization
3499*/
3500
3501int wxNoOptimize::m_count = 0;
3502
3503wxNoOptimize::wxNoOptimize()
3504{
3505 m_count ++;
3506}
3507
3508wxNoOptimize::~wxNoOptimize()
3509{
3510 m_count --;
3511}
3512
3513bool wxNoOptimize::CanOptimize()
3514{
3515 return (m_count == 0);
3516}
3517
wxWidgets (Impactor)