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