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