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