]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/motif/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Replace dc.cpp with dc.mm and dcclient.cpp with dc.mm
[wxWidgets.git] / src / motif / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: windows.cpp
3// Purpose: wxWindow
4// Author: Julian Smart
5// Modified by:
6// Created: 17/09/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#ifdef __GNUG__
21 #pragma implementation "window.h"
22#endif
23
24#ifdef __VMS
25#define XtDisplay XTDISPLAY
26#define XtWindow XTWINDOW
27#define XtScreen XTSCREEN
28#endif
29
30#include "wx/setup.h"
31#include "wx/menu.h"
32#include "wx/dc.h"
33#include "wx/dcclient.h"
34#include "wx/utils.h"
35#include "wx/app.h"
36#include "wx/layout.h"
37#include "wx/button.h"
38#include "wx/settings.h"
39#include "wx/frame.h"
40#include "wx/scrolwin.h"
41#include "wx/module.h"
42#include "wx/menuitem.h"
43#include "wx/log.h"
44#include "wx/evtloop.h"
45#include "wx/hash.h"
46
47#if wxUSE_DRAG_AND_DROP
48 #include "wx/dnd.h"
49#endif
50
51// DoSetSizeIntr and DoMoveWindowIntr
52// PROBLEM:
53// under Motif composite controls (such as wxCalendarCtrl or generic wxSpinCtrl
54// did nott work and/or segfaulted because
55// 1) wxWindow::Create calls SetSize,
56// which results in a call to DoSetSize much earlier than in the other ports
57// 2) if wxWindow::Create is called (wxControl::Create calls it)
58// then DoSetSize is never called, causing layout problems in composite
59// controls
60//
61// SOLUTION:
62// 1) don't call SetSize, DoSetSize, DoMoveWindow, DoGetPosition,
63// DoSetPosition directly or indirectly from wxWindow::Create
64// 2) call DoMoveWindow from DoSetSize, allowing controls to override it
65
66#ifdef __VMS__
67#pragma message disable nosimpint
68#endif
69#include <Xm/Xm.h>
70
71#include <Xm/DrawingA.h>
72#include <Xm/ScrolledW.h>
73#include <Xm/ScrollBar.h>
74#include <Xm/Frame.h>
75#include <Xm/Label.h>
76#include <Xm/RowColumn.h> // for XmMenuPosition
77#ifdef __VMS__
78#pragma message enable nosimpint
79#endif
80
81#include "wx/motif/private.h"
82
83#include <string.h>
84
85// ----------------------------------------------------------------------------
86// constants
87// ----------------------------------------------------------------------------
88
89static const int SCROLL_MARGIN = 4;
90
91// ----------------------------------------------------------------------------
92// global variables for this module
93// ----------------------------------------------------------------------------
94
95extern wxHashTable *wxWidgetHashTable;
96static wxWindow* g_captureWindow = NULL;
97
98
99// ----------------------------------------------------------------------------
100// private functions
101// ----------------------------------------------------------------------------
102
103static void wxCanvasRepaintProc(Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
104static void wxCanvasInputEvent(Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
105static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
106static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
107static void wxScrollBarCallback(Widget widget, XtPointer clientData,
108 XmScrollBarCallbackStruct *cbs);
109static void wxPanelItemEventHandler(Widget wid,
110 XtPointer client_data,
111 XEvent* event,
112 Boolean *continueToDispatch);
113
114// unused for now
115#if 0
116
117// Helper function for 16-bit fonts
118static int str16len(const char *s)
119{
120 int count = 0;
121
122 while (s[0] && s[1]) {
123 count++;
124 s += 2;
125 }
126
127 return count;
128}
129
130#endif // 0
131
132// ----------------------------------------------------------------------------
133// macros
134// ----------------------------------------------------------------------------
135
136#define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
137#define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
138#define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
139
140// ----------------------------------------------------------------------------
141// event tables
142// ----------------------------------------------------------------------------
143
144 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
145
146 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
147 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
148 EVT_IDLE(wxWindow::OnIdle)
149 END_EVENT_TABLE()
150
151// ============================================================================
152// implementation
153// ============================================================================
154
155// ----------------------------------------------------------------------------
156// helper functions
157// ----------------------------------------------------------------------------
158
159void wxWindow::UnmanageAndDestroy(WXWidget widget)
160{
161 Widget w = (Widget)widget;
162 if ( w )
163 {
164 XtUnmanageChild(w);
165 XtDestroyWidget(w);
166 }
167}
168
169bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
170{
171 Widget w = (Widget)widget;
172 if ( !w )
173 return FALSE;
174
175 if ( domap )
176 XtMapWidget(w);
177 else
178 XtUnmapWidget(w);
179
180 // Rationale: a lot of common operations (including but not
181 // limited to moving, resizing and appending items to a listbox)
182 // unmamange the widget, do their work, then manage it again.
183 // This means that, for example adding an item to a listbox will show it,
184 // or that most controls are shown every time they are moved or resized!
185 XtSetMappedWhenManaged( w, domap );
186
187 return TRUE;
188}
189
190// ----------------------------------------------------------------------------
191// constructors
192// ----------------------------------------------------------------------------
193
194void wxWindow::Init()
195{
196 // generic initializations first
197 InitBase();
198
199 // Motif-specific
200 m_needsRefresh = TRUE;
201 m_mainWidget = (WXWidget) 0;
202
203 m_button1Pressed =
204 m_button2Pressed =
205 m_button3Pressed = FALSE;
206
207 m_winCaptured = FALSE;
208
209 m_isShown = TRUE;
210 m_isBeingDeleted = FALSE;
211
212 m_hScrollBar =
213 m_vScrollBar =
214 m_borderWidget =
215 m_scrolledWindow =
216 m_drawingArea = (WXWidget) 0;
217
218 m_hScroll =
219 m_vScroll = FALSE;
220
221 m_scrollPosX =
222 m_scrollPosY = 0;
223
224 m_backingPixmap = (WXPixmap) 0;
225 m_pixmapWidth =
226 m_pixmapHeight = 0;
227
228 m_pixmapOffsetX =
229 m_pixmapOffsetY = 0;
230
231 m_lastTS = 0;
232 m_lastButton = 0;
233 m_canAddEventHandler = FALSE;
234}
235
236// real construction (Init() must have been called before!)
237bool wxWindow::Create(wxWindow *parent, wxWindowID id,
238 const wxPoint& pos,
239 const wxSize& size,
240 long style,
241 const wxString& name)
242{
243 wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
244
245 CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
246
247 parent->AddChild(this);
248
249 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
250 m_foregroundColour = *wxBLACK;
251
252 //// TODO: we should probably optimize by only creating a
253 //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
254 //// But for now, let's simplify things by always creating the
255 //// drawing area, since otherwise the translations are different.
256
257 // New translations for getting mouse motion feedback
258 static const String translations =
259"<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
260<Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
261<Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
262<BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
263<Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
264<Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
265<Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
266<Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
267<Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
268<Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
269<Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
270<EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
271<LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
272<Key>: DrawingAreaInput()";
273
274 XtActionsRec actions[1];
275 actions[0].string = "wxCanvasMotionEvent";
276 actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
277 XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
278
279 Widget parentWidget = (Widget) parent->GetClientWidget();
280
281 if (style & wxSIMPLE_BORDER)
282 {
283 m_borderWidget = (WXWidget)XtVaCreateManagedWidget
284 (
285 "canvasBorder",
286 xmFrameWidgetClass, parentWidget,
287 XmNshadowType, XmSHADOW_IN,
288 XmNshadowThickness, 1,
289 NULL
290 );
291 } else if (style & wxSUNKEN_BORDER)
292 {
293 m_borderWidget = (WXWidget)XtVaCreateManagedWidget
294 (
295 "canvasBorder",
296 xmFrameWidgetClass, parentWidget,
297 XmNshadowType, XmSHADOW_IN,
298 NULL
299 );
300 } else if (style & wxRAISED_BORDER)
301 {
302 m_borderWidget = (WXWidget)XtVaCreateManagedWidget
303 (
304 "canvasBorder",
305 xmFrameWidgetClass, parentWidget,
306 XmNshadowType, XmSHADOW_OUT,
307 NULL
308 );
309 }
310
311 m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
312 (
313 "scrolledWindow",
314 xmScrolledWindowWidgetClass,
315 m_borderWidget ? (Widget) m_borderWidget
316 : parentWidget,
317 XmNresizePolicy, XmRESIZE_NONE,
318 XmNspacing, 0,
319 XmNscrollingPolicy, XmAPPLICATION_DEFINED,
320 //XmNscrollBarDisplayPolicy, XmAS_NEEDED,
321 NULL
322 );
323
324 XtTranslations ptr = XtParseTranslationTable(translations);
325 m_drawingArea = (WXWidget)XtVaCreateWidget
326 (
327 name,
328 xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
329 XmNunitType, XmPIXELS,
330 // XmNresizePolicy, XmRESIZE_ANY,
331 XmNresizePolicy, XmRESIZE_NONE,
332 XmNmarginHeight, 0,
333 XmNmarginWidth, 0,
334 XmNtranslations, ptr,
335 NULL
336 );
337 XtFree((char *) ptr);
338
339#if 0
340 if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
341 {
342 ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
343 XtOverrideTranslations ((Widget) m_drawingArea, ptr);
344 XtFree ((char *) ptr);
345 }
346#endif // 0
347
348 wxAddWindowToTable((Widget) m_drawingArea, this);
349 wxAddWindowToTable((Widget) m_scrolledWindow, this);
350
351 // This order is very important in Motif 1.2.1
352 XtRealizeWidget ((Widget) m_scrolledWindow);
353 XtRealizeWidget ((Widget) m_drawingArea);
354 XtManageChild ((Widget) m_drawingArea);
355
356 ptr = XtParseTranslationTable("<Configure>: resize()");
357 XtOverrideTranslations((Widget) m_drawingArea, ptr);
358 XtFree ((char *) ptr);
359
360 XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
361 XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
362
363 // TODO?
364#if 0
365 display = XtDisplay (scrolledWindow);
366 xwindow = XtWindow (drawingArea);
367#endif // 0
368
369 XtAddEventHandler(
370 (Widget)m_drawingArea,
371 PointerMotionHintMask | EnterWindowMask |
372 LeaveWindowMask | FocusChangeMask,
373 False,
374 (XtEventHandler) wxCanvasEnterLeave,
375 (XtPointer) this
376 );
377
378 // Scrolled widget needs to have its colour changed or we get a little blue
379 // square where the scrollbars abutt
380 wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
381 DoChangeBackgroundColour(m_scrolledWindow, backgroundColour, TRUE);
382 DoChangeBackgroundColour(m_drawingArea, backgroundColour, TRUE);
383
384 XmScrolledWindowSetAreas(
385 (Widget)m_scrolledWindow,
386 (Widget) 0, (Widget) 0,
387 (Widget) m_drawingArea);
388
389#if 0
390 if (m_hScrollBar)
391 XtRealizeWidget ((Widget) m_hScrollBar);
392 if (m_vScrollBar)
393 XtRealizeWidget ((Widget) m_vScrollBar);
394#endif // 0
395
396 // Without this, the cursor may not be restored properly (e.g. in splitter
397 // sample).
398 SetCursor(*wxSTANDARD_CURSOR);
399 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
400 DoSetSizeIntr(pos.x, pos.y, size.x,size.y, wxSIZE_AUTO, TRUE);
401 return TRUE;
402}
403
404// Destructor
405wxWindow::~wxWindow()
406{
407 if (g_captureWindow == this)
408 g_captureWindow = NULL;
409
410 m_isBeingDeleted = TRUE;
411
412 // Motif-specific actions first
413 WXWidget wMain = GetMainWidget();
414 if ( wMain )
415 {
416 // Removes event handlers
417 DetachWidget(wMain);
418 }
419
420 ClearUpdateRects();
421
422 if ( m_parent )
423 m_parent->RemoveChild( this );
424
425 // If m_drawingArea, we're a fully-fledged window with drawing area,
426 // scrollbars etc. (what wxCanvas used to be)
427 if ( m_drawingArea )
428 {
429 // Destroy children before destroying self
430 DestroyChildren();
431
432 if (m_backingPixmap)
433 XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
434
435 Widget w = (Widget) m_drawingArea;
436 wxDeleteWindowFromTable(w);
437
438 if (w)
439 {
440 XtDestroyWidget(w);
441 m_drawingArea = (WXWidget) 0;
442 }
443
444 // Only if we're _really_ a canvas (not a dialog box/panel)
445 if (m_scrolledWindow)
446 {
447 wxDeleteWindowFromTable((Widget) m_scrolledWindow);
448 }
449
450 if (m_hScrollBar)
451 {
452 wxDeleteWindowFromTable((Widget) m_hScrollBar);
453 XtUnmanageChild((Widget) m_hScrollBar);
454 }
455 if (m_vScrollBar)
456 {
457 wxDeleteWindowFromTable((Widget) m_vScrollBar);
458 XtUnmanageChild((Widget) m_vScrollBar);
459 }
460
461 if (m_hScrollBar)
462 XtDestroyWidget((Widget) m_hScrollBar);
463 if (m_vScrollBar)
464 XtDestroyWidget((Widget) m_vScrollBar);
465
466 UnmanageAndDestroy(m_scrolledWindow);
467
468 if (m_borderWidget)
469 {
470 XtDestroyWidget ((Widget) m_borderWidget);
471 m_borderWidget = (WXWidget) 0;
472 }
473 }
474 else // Why wasn't this here before? JACS 8/3/2000
475 DestroyChildren();
476
477
478 // Destroy the window
479 if (GetMainWidget())
480 {
481 // If this line (XtDestroyWidget) causes a crash, you may comment it out.
482 // Child widgets will get destroyed automatically when a frame
483 // or dialog is destroyed, but before that you may get some memory
484 // leaks and potential layout problems if you delete and then add
485 // child windows.
486
487 // GRG, Feb/2000: commented this out when adding support for
488 // wxSCROLL[WIN]_THUMBRELEASE events. Also it was reported
489 // that this call crashed wxMotif under OS/2, so it seems
490 // that leaving it out is the right thing to do.
491 // SN, Feb/2000: newgrid/griddemo shows why it is needed :-(
492 XtDestroyWidget((Widget) GetMainWidget());
493 SetMainWidget((WXWidget) NULL);
494 }
495}
496
497// ----------------------------------------------------------------------------
498// scrollbar management
499// ----------------------------------------------------------------------------
500
501// Helper function
502void wxWindow::CreateScrollbar(wxOrientation orientation)
503{
504 wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
505
506 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
507
508 // Add scrollbars if required
509 if (orientation == wxHORIZONTAL)
510 {
511 Widget hScrollBar = XtVaCreateManagedWidget ("hsb",
512 xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
513 XmNorientation, XmHORIZONTAL,
514 NULL);
515 XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
516 XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
517 XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
518 XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
519 XtAddCallback (hScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
520 XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
521 XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
522 XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
523
524 XtVaSetValues (hScrollBar,
525 XmNincrement, 1,
526 XmNvalue, 0,
527 NULL);
528
529 m_hScrollBar = (WXWidget) hScrollBar;
530
531 wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
532 DoChangeBackgroundColour(m_hScrollBar, backgroundColour, TRUE);
533
534 XtRealizeWidget(hScrollBar);
535
536 XtVaSetValues((Widget) m_scrolledWindow,
537 XmNhorizontalScrollBar, (Widget) m_hScrollBar,
538 NULL);
539
540 m_hScroll = TRUE;
541
542 wxAddWindowToTable( hScrollBar, this );
543 }
544
545 if (orientation == wxVERTICAL)
546 {
547 Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
548 xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
549 XmNorientation, XmVERTICAL,
550 NULL);
551 XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
552 XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
553 XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
554 XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
555 XtAddCallback (vScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
556 XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
557 XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
558 XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
559
560 XtVaSetValues (vScrollBar,
561 XmNincrement, 1,
562 XmNvalue, 0,
563 NULL);
564
565 m_vScrollBar = (WXWidget) vScrollBar;
566 wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
567 DoChangeBackgroundColour(m_vScrollBar, backgroundColour, TRUE);
568
569 XtRealizeWidget(vScrollBar);
570
571 XtVaSetValues((Widget) m_scrolledWindow,
572 XmNverticalScrollBar, (Widget) m_vScrollBar,
573 NULL);
574
575 m_vScroll = TRUE;
576
577 wxAddWindowToTable( vScrollBar, this );
578 }
579
580 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
581}
582
583void wxWindow::DestroyScrollbar(wxOrientation orientation)
584{
585 wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
586
587 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_NONE, NULL);
588 // Add scrollbars if required
589 if (orientation == wxHORIZONTAL)
590 {
591 if (m_hScrollBar)
592 {
593 wxDeleteWindowFromTable((Widget)m_hScrollBar);
594 XtDestroyWidget((Widget) m_hScrollBar);
595 }
596 m_hScrollBar = (WXWidget) 0;
597 m_hScroll = FALSE;
598
599 XtVaSetValues((Widget) m_scrolledWindow,
600 XmNhorizontalScrollBar, (Widget) 0,
601 NULL);
602
603 }
604
605 if (orientation == wxVERTICAL)
606 {
607 if (m_vScrollBar)
608 {
609 wxDeleteWindowFromTable((Widget)m_vScrollBar);
610 XtDestroyWidget((Widget) m_vScrollBar);
611 }
612 m_vScrollBar = (WXWidget) 0;
613 m_vScroll = FALSE;
614
615 XtVaSetValues((Widget) m_scrolledWindow,
616 XmNverticalScrollBar, (Widget) 0,
617 NULL);
618
619 }
620 XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
621}
622
623// ---------------------------------------------------------------------------
624// basic operations
625// ---------------------------------------------------------------------------
626
627void wxWindow::SetFocus()
628{
629 Widget wMain = (Widget) GetMainWidget();
630 XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
631 XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
632}
633
634// Get the window with the focus
635wxWindow *wxWindowBase::FindFocus()
636{
637 // TODO Problems:
638 // (1) Can there be multiple focussed widgets in an application?
639 // In which case we need to find the top-level window that's
640 // currently active.
641 // (2) The widget with the focus may not be in the widget table
642 // depending on which widgets I put in the table
643 wxWindow *winFocus = (wxWindow *)NULL;
644 for ( wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
645 node;
646 node = node->GetNext() )
647 {
648 wxWindow *win = node->GetData();
649
650 Widget w = XmGetFocusWidget ((Widget) win->GetTopWidget());
651
652 if (w != (Widget) NULL)
653 {
654 winFocus = wxGetWindowFromTable(w);
655 if ( winFocus )
656 break;
657 }
658 }
659
660 return winFocus;
661}
662
663bool wxWindow::Enable(bool enable)
664{
665 if ( !wxWindowBase::Enable(enable) )
666 return FALSE;
667
668 Widget wMain = (Widget)GetMainWidget();
669 if ( wMain )
670 {
671 XtSetSensitive(wMain, enable);
672 XmUpdateDisplay(wMain);
673 }
674
675 return TRUE;
676}
677
678bool wxWindow::Show(bool show)
679{
680 if ( !wxWindowBase::Show(show) )
681 return FALSE;
682
683 if (m_borderWidget || m_scrolledWindow)
684 {
685 MapOrUnmap(m_drawingArea, show);
686 MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
687 }
688 else
689 {
690 if ( !MapOrUnmap(GetTopWidget(), show) )
691 MapOrUnmap(GetMainWidget(), show);
692 }
693
694 return TRUE;
695}
696
697// Raise the window to the top of the Z order
698void wxWindow::Raise()
699{
700 Widget wTop = (Widget) GetTopWidget();
701 Window window = XtWindow(wTop);
702 XRaiseWindow(XtDisplay(wTop), window);
703}
704
705// Lower the window to the bottom of the Z order
706void wxWindow::Lower()
707{
708 Widget wTop = (Widget) GetTopWidget();
709 Window window = XtWindow(wTop);
710 XLowerWindow(XtDisplay(wTop), window);
711}
712
713void wxWindow::SetTitle(const wxString& title)
714{
715 XtVaSetValues((Widget)GetMainWidget(), XmNtitle, title.c_str(), NULL);
716}
717
718wxString wxWindow::GetTitle() const
719{
720 char *title;
721 XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &title, NULL);
722
723 return wxString(title);
724}
725
726void wxWindow::DoCaptureMouse()
727{
728 g_captureWindow = this;
729 if ( m_winCaptured )
730 return;
731
732 Widget wMain = (Widget)GetMainWidget();
733 if ( wMain )
734 XtAddGrab(wMain, TRUE, FALSE);
735
736 m_winCaptured = TRUE;
737}
738
739void wxWindow::DoReleaseMouse()
740{
741 g_captureWindow = NULL;
742 if ( !m_winCaptured )
743 return;
744
745 Widget wMain = (Widget)GetMainWidget();
746 if ( wMain )
747 XtRemoveGrab(wMain);
748
749 m_winCaptured = FALSE;
750}
751
752bool wxWindow::SetFont(const wxFont& font)
753{
754 if ( !wxWindowBase::SetFont(font) )
755 {
756 // nothing to do
757 return FALSE;
758 }
759
760 ChangeFont();
761
762 return TRUE;
763}
764
765bool wxWindow::SetCursor(const wxCursor& cursor)
766{
767 if ( !wxWindowBase::SetCursor(cursor) )
768 {
769 // no change
770 return FALSE;
771 }
772
773 // wxASSERT_MSG( m_cursor.Ok(),
774 // wxT("cursor must be valid after call to the base version"));
775 wxCursor* cursor2 = NULL;
776 if (m_cursor.Ok())
777 cursor2 = & m_cursor;
778 else
779 cursor2 = wxSTANDARD_CURSOR;
780
781 WXDisplay *dpy = GetXDisplay();
782 WXCursor x_cursor = cursor2->GetXCursor(dpy);
783
784 Widget w = (Widget) GetMainWidget();
785 Window win = XtWindow(w);
786 XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
787
788 return TRUE;
789}
790
791// Coordinates relative to the window
792void wxWindow::WarpPointer (int x, int y)
793{
794 Widget wClient = (Widget)GetClientWidget();
795
796 XWarpPointer(XtDisplay(wClient), None, XtWindow(wClient), 0, 0, 0, 0, x, y);
797}
798
799// ---------------------------------------------------------------------------
800// scrolling stuff
801// ---------------------------------------------------------------------------
802
803int wxWindow::GetScrollPos(int orient) const
804{
805 if (orient == wxHORIZONTAL)
806 return m_scrollPosX;
807 else
808 return m_scrollPosY;
809
810#if 0
811 Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
812 if (scrollBar)
813 {
814 int pos;
815 XtVaGetValues(scrollBar, XmNvalue, &pos, NULL);
816 return pos;
817 }
818 else
819 return 0;
820#endif // 0
821}
822
823// This now returns the whole range, not just the number of positions that we
824// can scroll.
825int wxWindow::GetScrollRange(int orient) const
826{
827 Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
828 wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
829
830 int range = 0;
831 if (scrollBar)
832 XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
833 return range;
834}
835
836int wxWindow::GetScrollThumb(int orient) const
837{
838 Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
839 wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
840
841 int thumb;
842 XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
843 return thumb;
844}
845
846void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
847{
848 Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
849
850 if ( scrollBar )
851 {
852 XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
853 }
854
855 SetInternalScrollPos((wxOrientation)orient, pos);
856}
857
858// New function that will replace some of the above.
859void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
860 int range, bool WXUNUSED(refresh))
861{
862 int oldW, oldH;
863 GetSize(& oldW, & oldH);
864
865 if (range == 0)
866 range = 1;
867 if (thumbVisible == 0)
868 thumbVisible = 1;
869
870 if (thumbVisible > range)
871 thumbVisible = range;
872
873 // Save the old state to see if it changed
874 WXWidget oldScrollBar = GetScrollbar((wxOrientation)orient);
875
876 if (orient == wxHORIZONTAL)
877 {
878 if (thumbVisible == range)
879 {
880 if (m_hScrollBar)
881 DestroyScrollbar(wxHORIZONTAL);
882 }
883 else
884 {
885 if (!m_hScrollBar)
886 CreateScrollbar(wxHORIZONTAL);
887 }
888 }
889 if (orient == wxVERTICAL)
890 {
891 if (thumbVisible == range)
892 {
893 if (m_vScrollBar)
894 DestroyScrollbar(wxVERTICAL);
895 }
896 else
897 {
898 if (!m_vScrollBar)
899 CreateScrollbar(wxVERTICAL);
900 }
901 }
902 WXWidget newScrollBar = GetScrollbar((wxOrientation)orient);
903
904 if (oldScrollBar != newScrollBar)
905 {
906 // This is important! Without it, scrollbars misbehave badly.
907 XtUnrealizeWidget((Widget) m_scrolledWindow);
908 XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
909 XtRealizeWidget((Widget) m_scrolledWindow);
910 XtManageChild((Widget) m_scrolledWindow);
911 }
912
913 if (newScrollBar)
914 {
915 XtVaSetValues((Widget) newScrollBar,
916 XmNvalue, pos,
917 XmNminimum, 0,
918 XmNmaximum, range,
919 XmNsliderSize, thumbVisible,
920 NULL);
921 }
922
923 SetInternalScrollPos((wxOrientation)orient, pos);
924
925 int newW, newH;
926 GetSize(& newW, & newH);
927
928 // Adjusting scrollbars can resize the canvas accidentally
929 if (newW != oldW || newH != oldH)
930 SetSize(-1, -1, oldW, oldH);
931}
932
933// Does a physical scroll
934void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
935{
936 int x, y, w, h;
937 if (rect)
938 {
939 // Use specified rectangle
940 x = rect->x; y = rect->y; w = rect->width; h = rect->height;
941 }
942 else
943 {
944 // Use whole client area
945 x = 0; y = 0;
946 GetClientSize(& w, & h);
947 }
948
949 int x1 = (dx >= 0) ? x : x - dx;
950 int y1 = (dy >= 0) ? y : y - dy;
951 int w1 = w - abs(dx);
952 int h1 = h - abs(dy);
953 int x2 = (dx >= 0) ? x + dx : x;
954 int y2 = (dy >= 0) ? y + dy : y;
955
956 wxClientDC dc(this);
957
958 dc.SetLogicalFunction (wxCOPY);
959
960 Widget widget = (Widget) GetMainWidget();
961 Window window = XtWindow(widget);
962 Display* display = XtDisplay(widget);
963
964 XCopyArea(display, window, window, (GC) dc.GetGC(),
965 x1, y1, w1, h1, x2, y2);
966
967 dc.SetAutoSetting(TRUE);
968 wxBrush brush(GetBackgroundColour(), wxSOLID);
969 dc.SetBrush(brush); // FIXME: needed?
970
971 wxWindowList::Node *cnode = m_children.GetFirst();
972 while (cnode)
973 {
974 wxWindow *child = cnode->GetData();
975 int sx = 0;
976 int sy = 0;
977 child->GetSize( &sx, &sy );
978 wxPoint pos( child->GetPosition() );
979 child->SetSize( pos.x + dx, pos.y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
980 cnode = cnode->GetNext();
981 }
982
983 // We'll add rectangles to the list of update rectangles according to which
984 // bits we've exposed.
985 wxList updateRects;
986
987 if (dx > 0)
988 {
989 wxRect *rect = new wxRect;
990 rect->x = x;
991 rect->y = y;
992 rect->width = dx;
993 rect->height = h;
994
995 XFillRectangle(display, window,
996 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
997
998 rect->x = rect->x;
999 rect->y = rect->y;
1000 rect->width = rect->width;
1001 rect->height = rect->height;
1002
1003 updateRects.Append((wxObject*) rect);
1004 }
1005 else if (dx < 0)
1006 {
1007 wxRect *rect = new wxRect;
1008
1009 rect->x = x + w + dx;
1010 rect->y = y;
1011 rect->width = -dx;
1012 rect->height = h;
1013
1014 XFillRectangle(display, window,
1015 (GC) dc.GetGC(), rect->x, rect->y, rect->width,
1016 rect->height);
1017
1018 rect->x = rect->x;
1019 rect->y = rect->y;
1020 rect->width = rect->width;
1021 rect->height = rect->height;
1022
1023 updateRects.Append((wxObject*) rect);
1024 }
1025 if (dy > 0)
1026 {
1027 wxRect *rect = new wxRect;
1028
1029 rect->x = x;
1030 rect->y = y;
1031 rect->width = w;
1032 rect->height = dy;
1033
1034 XFillRectangle(display, window,
1035 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1036
1037 rect->x = rect->x;
1038 rect->y = rect->y;
1039 rect->width = rect->width;
1040 rect->height = rect->height;
1041
1042 updateRects.Append((wxObject*) rect);
1043 }
1044 else if (dy < 0)
1045 {
1046 wxRect *rect = new wxRect;
1047
1048 rect->x = x;
1049 rect->y = y + h + dy;
1050 rect->width = w;
1051 rect->height = -dy;
1052
1053 XFillRectangle(display, window,
1054 (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1055
1056 rect->x = rect->x;
1057 rect->y = rect->y;
1058 rect->width = rect->width;
1059 rect->height = rect->height;
1060
1061 updateRects.Append((wxObject*) rect);
1062 }
1063 dc.SetBrush(wxNullBrush);
1064
1065 // Now send expose events
1066
1067 wxList::Node* node = updateRects.GetFirst();
1068 while (node)
1069 {
1070 wxRect* rect = (wxRect*) node->GetData();
1071 XExposeEvent event;
1072
1073 event.type = Expose;
1074 event.display = display;
1075 event.send_event = True;
1076 event.window = window;
1077
1078 event.x = rect->x;
1079 event.y = rect->y;
1080 event.width = rect->width;
1081 event.height = rect->height;
1082
1083 event.count = 0;
1084
1085 XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
1086
1087 node = node->GetNext();
1088
1089 }
1090
1091 // Delete the update rects
1092 node = updateRects.GetFirst();
1093 while (node)
1094 {
1095 wxRect* rect = (wxRect*) node->GetData();
1096 delete rect;
1097 node = node->GetNext();
1098 }
1099
1100 XmUpdateDisplay((Widget) GetMainWidget());
1101}
1102
1103// ---------------------------------------------------------------------------
1104// drag and drop
1105// ---------------------------------------------------------------------------
1106
1107#if wxUSE_DRAG_AND_DROP
1108
1109void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
1110{
1111 // TODO
1112}
1113
1114#endif
1115
1116// Old style file-manager drag&drop
1117void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
1118{
1119 // TODO
1120}
1121
1122// ----------------------------------------------------------------------------
1123// tooltips
1124// ----------------------------------------------------------------------------
1125
1126#if wxUSE_TOOLTIPS
1127
1128void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
1129{
1130 // TODO
1131}
1132
1133#endif // wxUSE_TOOLTIPS
1134
1135// ----------------------------------------------------------------------------
1136// popup menus
1137// ----------------------------------------------------------------------------
1138
1139#if wxUSE_MENUS
1140
1141bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
1142{
1143 Widget widget = (Widget) GetMainWidget();
1144
1145 /* The menuId field seems to be usused, so we'll use it to
1146 indicate whether a menu is popped up or not:
1147 0: Not currently created as a popup
1148 -1: Created as a popup, but not active
1149 1: Active popup.
1150 */
1151
1152 if (menu->GetParent() && (menu->GetId() != -1))
1153 return FALSE;
1154
1155 if (menu->GetMainWidget())
1156 {
1157 menu->DestroyMenu(TRUE);
1158 }
1159
1160 menu->SetId(1); /* Mark as popped-up */
1161 menu->CreateMenu(NULL, widget, menu);
1162 menu->SetInvokingWindow(this);
1163
1164 menu->UpdateUI();
1165
1166 // menu->SetParent(parent);
1167 // parent->children->Append(menu); // Store menu for later deletion
1168
1169 Widget menuWidget = (Widget) menu->GetMainWidget();
1170
1171 int rootX = 0;
1172 int rootY = 0;
1173
1174 int deviceX = x;
1175 int deviceY = y;
1176 /*
1177 if (this->IsKindOf(CLASSINFO(wxCanvas)))
1178 {
1179 wxCanvas *canvas = (wxCanvas *) this;
1180 deviceX = canvas->GetDC ()->LogicalToDeviceX (x);
1181 deviceY = canvas->GetDC ()->LogicalToDeviceY (y);
1182 }
1183 */
1184
1185 Display *display = XtDisplay (widget);
1186 Window rootWindow = RootWindowOfScreen (XtScreen((Widget)widget));
1187 Window thisWindow = XtWindow (widget);
1188 Window childWindow;
1189 XTranslateCoordinates (display, thisWindow, rootWindow, (int) deviceX, (int) deviceY,
1190 &rootX, &rootY, &childWindow);
1191
1192 XButtonPressedEvent event;
1193 event.type = ButtonPress;
1194 event.button = 1;
1195
1196 event.x = deviceX;
1197 event.y = deviceY;
1198
1199 event.x_root = rootX;
1200 event.y_root = rootY;
1201
1202 XmMenuPosition (menuWidget, &event);
1203 XtManageChild (menuWidget);
1204
1205 // The ID of a pop-up menu is 1 when active, and is set to 0 by the
1206 // idle-time destroy routine.
1207 // Waiting until this ID changes causes this function to block until
1208 // the menu has been dismissed and the widgets cleaned up.
1209 // In other words, once this routine returns, it is safe to delete
1210 // the menu object.
1211 // Ian Brown <ian.brown@printsoft.de>
1212
1213 wxEventLoop evtLoop;
1214
1215 while (menu->GetId() == 1)
1216 {
1217 wxDoEventLoopIteration( evtLoop );
1218 }
1219
1220 return TRUE;
1221}
1222
1223#endif
1224
1225// ---------------------------------------------------------------------------
1226// moving and resizing
1227// ---------------------------------------------------------------------------
1228
1229bool wxWindow::PreResize()
1230{
1231 return TRUE;
1232}
1233
1234// Get total size
1235void wxWindow::DoGetSize(int *x, int *y) const
1236{
1237 Widget widget = (Widget)( !m_drawingArea ? GetTopWidget() :
1238 ( m_borderWidget ? m_borderWidget :
1239 m_scrolledWindow ? m_scrolledWindow :
1240 m_drawingArea ) );
1241 Dimension xx, yy;
1242
1243 XtVaGetValues( widget,
1244 XmNwidth, &xx,
1245 XmNheight, &yy,
1246 NULL );
1247 if(x) *x = xx;
1248 if(y) *y = yy;
1249}
1250
1251void wxWindow::DoGetPosition(int *x, int *y) const
1252{
1253 Widget widget = (Widget)
1254 ( m_drawingArea ?
1255 ( m_borderWidget ? m_borderWidget : m_scrolledWindow ) :
1256 GetTopWidget() );
1257
1258 Position xx, yy;
1259 XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
1260
1261 // We may be faking the client origin. So a window that's really at (0, 30)
1262 // may appear (to wxWin apps) to be at (0, 0).
1263 if (GetParent())
1264 {
1265 wxPoint pt(GetParent()->GetClientAreaOrigin());
1266 xx -= pt.x;
1267 yy -= pt.y;
1268 }
1269
1270 if(x) *x = xx;
1271 if(y) *y = yy;
1272}
1273
1274void wxWindow::DoScreenToClient(int *x, int *y) const
1275{
1276 Widget widget = (Widget) GetClientWidget();
1277 Display *display = XtDisplay((Widget) GetMainWidget());
1278 Window rootWindow = RootWindowOfScreen(XtScreen(widget));
1279 Window thisWindow = XtWindow(widget);
1280
1281 Window childWindow;
1282 int xx = *x;
1283 int yy = *y;
1284 XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
1285}
1286
1287void wxWindow::DoClientToScreen(int *x, int *y) const
1288{
1289 Widget widget = (Widget) GetClientWidget();
1290 Display *display = XtDisplay(widget);
1291 Window rootWindow = RootWindowOfScreen(XtScreen(widget));
1292 Window thisWindow = XtWindow(widget);
1293
1294 Window childWindow;
1295 int xx = *x;
1296 int yy = *y;
1297 XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
1298}
1299
1300
1301// Get size *available for subwindows* i.e. excluding menu bar etc.
1302void wxWindow::DoGetClientSize(int *x, int *y) const
1303{
1304 Widget widget = (Widget) GetClientWidget();
1305 Dimension xx, yy;
1306 XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
1307 if(x) *x = xx; if(y) *y = yy;
1308}
1309
1310void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1311{
1312 DoSetSizeIntr(x, y, width, height, sizeFlags, FALSE);
1313}
1314
1315void wxWindow::DoSetSizeIntr(int x, int y, int width, int height,
1316 int sizeFlags, bool fromCtor)
1317{
1318 // A bit of optimization to help sort out the flickers.
1319 int oldX = -1, oldY = -1, oldW = -1, oldH = -1;
1320 if( !fromCtor )
1321 {
1322 GetSize(& oldW, & oldH);
1323 GetPosition(& oldX, & oldY);
1324 }
1325
1326 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1327 {
1328 if ( x == -1 )
1329 x = oldX;
1330 if ( y == -1 )
1331 y = oldY;
1332 }
1333
1334 wxSize size(-1, -1);
1335 if ( width <= 0 )
1336 {
1337 if ( ( sizeFlags & wxSIZE_AUTO_WIDTH ) && !fromCtor )
1338 {
1339 size = DoGetBestSize();
1340 width = size.x;
1341 }
1342 else
1343 {
1344 width = oldW;
1345 }
1346 }
1347
1348 if ( height == -1 )
1349 {
1350 if( ( sizeFlags & wxSIZE_AUTO_HEIGHT ) && !fromCtor )
1351 {
1352 if( size.x == -1 ) size = DoGetBestSize();
1353 height = size.y;
1354 }
1355 else
1356 {
1357 height = oldH;
1358 }
1359 }
1360
1361 if ( x != oldX || y != oldY || width != oldW || height != oldH
1362 || !wxNoOptimize::CanOptimize() )
1363 {
1364 if (m_drawingArea)
1365 {
1366 int flags = 0;
1367
1368 if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1369 flags |= wxMOVE_X;
1370
1371 if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1372 flags |= wxMOVE_Y;
1373
1374 if (width > 0)
1375 flags |= wxMOVE_WIDTH;
1376
1377 if (height > 0)
1378 flags |= wxMOVE_HEIGHT;
1379
1380 int xx = x; int yy = y;
1381 AdjustForParentClientOrigin(xx, yy, sizeFlags);
1382 if( !fromCtor )
1383 DoMoveWindow( xx, yy, width, height );
1384 else
1385 DoMoveWindowIntr( xx, yy, width, height, flags );
1386
1387 return;
1388 }
1389
1390 Widget widget = (Widget) GetTopWidget();
1391 if (!widget)
1392 return;
1393
1394 bool managed = XtIsManaged( widget );
1395 if (managed)
1396 XtUnmanageChild(widget);
1397
1398 int xx = x;
1399 int yy = y;
1400 AdjustForParentClientOrigin(xx, yy, sizeFlags);
1401
1402 DoMoveWindow(xx, yy, width, height);
1403
1404 if (managed)
1405 XtManageChild(widget);
1406 }
1407}
1408
1409void wxWindow::DoSetClientSize(int width, int height)
1410{
1411 if (m_drawingArea)
1412 {
1413 Widget drawingArea = (Widget) m_drawingArea;
1414
1415 XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
1416
1417 if (width > -1)
1418 XtVaSetValues(drawingArea, XmNwidth, width, NULL);
1419 if (height > -1)
1420 XtVaSetValues(drawingArea, XmNheight, height, NULL);
1421
1422 XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
1423 return;
1424 }
1425
1426 Widget widget = (Widget) GetTopWidget();
1427
1428 if (width > -1)
1429 XtVaSetValues(widget, XmNwidth, width, NULL);
1430 if (height > -1)
1431 XtVaSetValues(widget, XmNheight, height, NULL);
1432}
1433
1434// For implementation purposes - sometimes decorations make the client area
1435// smaller
1436wxPoint wxWindow::GetClientAreaOrigin() const
1437{
1438 return wxPoint(0, 0);
1439}
1440
1441void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
1442 int flags)
1443{
1444 if (m_drawingArea)
1445 {
1446 Widget drawingArea = (Widget) m_drawingArea;
1447 Widget borderOrScrolled = m_borderWidget ?
1448 (Widget) m_borderWidget :
1449 (Widget) m_scrolledWindow;
1450
1451 bool managed = XtIsManaged(borderOrScrolled);
1452 if (managed)
1453 XtUnmanageChild (borderOrScrolled);
1454 XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
1455
1456 if (flags & wxMOVE_X)
1457 XtVaSetValues (borderOrScrolled,
1458 XmNx, xx,
1459 NULL);
1460 if (flags & wxMOVE_Y)
1461 XtVaSetValues (borderOrScrolled,
1462 XmNy, yy,
1463 NULL);
1464
1465 if (flags & wxMOVE_WIDTH)
1466 {
1467 if (m_borderWidget)
1468 {
1469 XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
1470 short thick, margin;
1471 XtVaGetValues ((Widget) m_borderWidget,
1472 XmNshadowThickness, &thick,
1473 XmNmarginWidth, &margin,
1474 NULL);
1475 w -= 2 * (thick + margin);
1476 }
1477
1478 XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
1479 }
1480
1481 if (flags & wxMOVE_HEIGHT)
1482 {
1483 if (m_borderWidget)
1484 {
1485 XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
1486 short thick, margin;
1487 XtVaGetValues ((Widget) m_borderWidget,
1488 XmNshadowThickness, &thick,
1489 XmNmarginHeight, &margin,
1490 NULL);
1491 h -= 2 * (thick + margin);
1492 }
1493
1494 XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
1495 }
1496
1497 if (managed)
1498 XtManageChild (borderOrScrolled);
1499 XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
1500 }
1501 else
1502 {
1503 if( w < 1 ) w = 1;
1504 if( h < 1 ) h = 1;
1505
1506 XtVaSetValues((Widget)GetTopWidget(),
1507 XmNx, xx,
1508 XmNy, yy,
1509 XmNwidth, w,
1510 XmNheight, h,
1511 NULL);
1512 }
1513}
1514
1515void wxWindow::DoMoveWindow(int x, int y, int width, int height)
1516{
1517 DoMoveWindowIntr (x, y, width, height,
1518 wxMOVE_X|wxMOVE_Y|wxMOVE_WIDTH|wxMOVE_HEIGHT);
1519}
1520
1521// ---------------------------------------------------------------------------
1522// text metrics
1523// ---------------------------------------------------------------------------
1524
1525int wxWindow::GetCharHeight() const
1526{
1527 wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
1528
1529 WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
1530
1531 int direction, ascent, descent;
1532 XCharStruct overall;
1533 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1534 &descent, &overall);
1535
1536 // return (overall.ascent + overall.descent);
1537 return (ascent + descent);
1538}
1539
1540int wxWindow::GetCharWidth() const
1541{
1542 wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
1543
1544 WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
1545
1546 int direction, ascent, descent;
1547 XCharStruct overall;
1548 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1549 &descent, &overall);
1550
1551 return overall.width;
1552}
1553
1554void wxWindow::GetTextExtent(const wxString& string,
1555 int *x, int *y,
1556 int *descent, int *externalLeading,
1557 const wxFont *theFont) const
1558{
1559 wxFont *fontToUse = (wxFont *)theFont;
1560 if (!fontToUse)
1561 fontToUse = (wxFont *) & m_font;
1562
1563 wxCHECK_RET( fontToUse->Ok(), "valid window font needed" );
1564
1565 WXFontStructPtr pFontStruct = fontToUse->GetFontStruct(1.0, GetXDisplay());
1566
1567 int direction, ascent, descent2;
1568 XCharStruct overall;
1569 int slen = string.Len();
1570
1571#if 0
1572 if (use16)
1573 XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
1574 &ascent, &descent2, &overall);
1575#endif
1576
1577 XTextExtents((XFontStruct*) pFontStruct, string, slen,
1578 &direction, &ascent, &descent2, &overall);
1579
1580 if ( x )
1581 *x = (overall.width);
1582 if ( y )
1583 *y = (ascent + descent2);
1584 if (descent)
1585 *descent = descent2;
1586 if (externalLeading)
1587 *externalLeading = 0;
1588
1589}
1590
1591// ----------------------------------------------------------------------------
1592// painting
1593// ----------------------------------------------------------------------------
1594
1595void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
1596{
1597 m_needsRefresh = TRUE;
1598 Display *display = XtDisplay((Widget) GetMainWidget());
1599 Window thisWindow = XtWindow((Widget) GetMainWidget());
1600
1601 XExposeEvent dummyEvent;
1602 int width, height;
1603 GetSize(&width, &height);
1604
1605 dummyEvent.type = Expose;
1606 dummyEvent.display = display;
1607 dummyEvent.send_event = True;
1608 dummyEvent.window = thisWindow;
1609 if (rect)
1610 {
1611 dummyEvent.x = rect->x;
1612 dummyEvent.y = rect->y;
1613 dummyEvent.width = rect->width;
1614 dummyEvent.height = rect->height;
1615 }
1616 else
1617 {
1618 dummyEvent.x = 0;
1619 dummyEvent.y = 0;
1620 dummyEvent.width = width;
1621 dummyEvent.height = height;
1622 }
1623 dummyEvent.count = 0;
1624
1625 if (eraseBack)
1626 {
1627 wxClientDC dc(this);
1628 wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
1629 dc.SetBackground(backgroundBrush);
1630 if (rect)
1631 dc.Clear(*rect);
1632 else
1633 dc.Clear();
1634 }
1635
1636 XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
1637}
1638
1639void wxWindow::Clear()
1640{
1641 wxClientDC dc(this);
1642 wxBrush brush(GetBackgroundColour(), wxSOLID);
1643 dc.SetBackground(brush);
1644 dc.Clear();
1645}
1646
1647void wxWindow::ClearUpdateRects()
1648{
1649 wxRectList::Node* node = m_updateRects.GetFirst();
1650 while (node)
1651 {
1652 wxRect* rect = node->GetData();
1653 delete rect;
1654 node = node->GetNext();
1655 }
1656
1657 m_updateRects.Clear();
1658}
1659
1660void wxWindow::DoPaint()
1661{
1662 //TODO : make a temporary gc so we can do the XCopyArea below
1663 if (m_backingPixmap && !m_needsRefresh)
1664 {
1665 wxPaintDC dc(this);
1666
1667 GC tempGC = (GC) dc.GetBackingGC();
1668
1669 Widget widget = (Widget) GetMainWidget();
1670
1671 int scrollPosX = 0;
1672 int scrollPosY = 0;
1673
1674 // We have to test whether it's a wxScrolledWindow (hack!) because
1675 // otherwise we don't know how many pixels have been scrolled. We might
1676 // solve this in the future by defining virtual wxWindow functions to get
1677 // the scroll position in pixels. Or, each kind of scrolled window has to
1678 // implement backing stores itself, using generic wxWindows code.
1679 wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
1680 if ( scrolledWindow )
1681 {
1682 int x, y;
1683 scrolledWindow->CalcScrolledPosition(0, 0, &x, &y);
1684
1685 scrollPosX = - x;
1686 scrollPosY = - y;
1687 }
1688
1689 // TODO: This could be optimized further by only copying the areas in the
1690 // current update region.
1691
1692 // Only blit the part visible in the client area. The backing pixmap
1693 // always starts at 0, 0 but we may be looking at only a portion of it.
1694 wxSize clientArea = GetClientSize();
1695 int toBlitX = m_pixmapWidth - scrollPosX;
1696 int toBlitY = m_pixmapHeight - scrollPosY;
1697
1698 // Copy whichever is samller, the amount of pixmap we have to copy,
1699 // or the size of the client area.
1700 toBlitX = wxMin(toBlitX, clientArea.x);
1701 toBlitY = wxMin(toBlitY, clientArea.y);
1702
1703 // Make sure we're not negative
1704 toBlitX = wxMax(0, toBlitX);
1705 toBlitY = wxMax(0, toBlitY);
1706
1707 XCopyArea
1708 (
1709 XtDisplay(widget),
1710 (Pixmap) m_backingPixmap,
1711 XtWindow (widget),
1712 tempGC,
1713 scrollPosX, scrollPosY, // Start at the scroll position
1714 toBlitX, toBlitY, // How much of the pixmap to copy
1715 0, 0 // Destination
1716 );
1717 }
1718 else
1719 {
1720 wxWindowDC dc(this);
1721 // Set an erase event first
1722 wxEraseEvent eraseEvent(GetId(), &dc);
1723 eraseEvent.SetEventObject(this);
1724 GetEventHandler()->ProcessEvent(eraseEvent);
1725
1726 wxPaintEvent event(GetId());
1727 event.SetEventObject(this);
1728 GetEventHandler()->ProcessEvent(event);
1729
1730 m_needsRefresh = FALSE;
1731 }
1732}
1733
1734// ----------------------------------------------------------------------------
1735// event handlers
1736// ----------------------------------------------------------------------------
1737
1738// Responds to colour changes: passes event on to children.
1739void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
1740{
1741 wxWindowList::Node *node = GetChildren().GetFirst();
1742 while ( node )
1743 {
1744 // Only propagate to non-top-level windows
1745 wxWindow *win = node->GetData();
1746 if ( win->GetParent() )
1747 {
1748 wxSysColourChangedEvent event2;
1749 event.m_eventObject = win;
1750 win->GetEventHandler()->ProcessEvent(event2);
1751 }
1752
1753 node = node->GetNext();
1754 }
1755}
1756
1757void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
1758{
1759 // This calls the UI-update mechanism (querying windows for
1760 // menu/toolbar/control state information)
1761 UpdateWindowUI();
1762}
1763
1764// ----------------------------------------------------------------------------
1765// accelerators
1766// ----------------------------------------------------------------------------
1767
1768bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
1769{
1770#if wxUSE_ACCEL
1771 if (!m_acceleratorTable.Ok())
1772 return FALSE;
1773
1774 int count = m_acceleratorTable.GetCount();
1775 wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
1776 int i;
1777 for (i = 0; i < count; i++)
1778 {
1779 wxAcceleratorEntry* entry = & (entries[i]);
1780 if (entry->MatchesEvent(event))
1781 {
1782 // Bingo, we have a match. Now find a control that matches the
1783 // entry command id.
1784
1785 // Need to go up to the top of the window hierarchy, since it might
1786 // be e.g. a menu item
1787 wxWindow* parent = this;
1788 while ( parent && !parent->IsTopLevel() )
1789 parent = parent->GetParent();
1790
1791 if (!parent)
1792 return FALSE;
1793
1794 wxFrame* frame = wxDynamicCast(parent, wxFrame);
1795 if ( frame )
1796 {
1797#if wxUSE_MENUS
1798 // Try for a menu command
1799 if (frame->GetMenuBar())
1800 {
1801 wxMenuItem* item = frame->GetMenuBar()->FindItem(entry->GetCommand());
1802 if (item)
1803 {
1804 wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
1805 commandEvent.SetEventObject(frame);
1806
1807 // If ProcessEvent returns TRUE (it was handled), then
1808 // the calling code will skip the event handling.
1809 return frame->GetEventHandler()->ProcessEvent(commandEvent);
1810 }
1811 }
1812#endif
1813 }
1814
1815 // Find a child matching the command id
1816 wxWindow* child = parent->FindWindow(entry->GetCommand());
1817
1818 // No such child
1819 if (!child)
1820 return FALSE;
1821
1822 // Now we process those kinds of windows that we can.
1823 // For now, only buttons.
1824 if ( wxDynamicCast(child, wxButton) )
1825 {
1826 wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
1827 commandEvent.SetEventObject(child);
1828 return child->GetEventHandler()->ProcessEvent(commandEvent);
1829 }
1830
1831 return FALSE;
1832 } // matches event
1833 }// for
1834#endif
1835
1836 // We didn't match the key event against an accelerator.
1837 return FALSE;
1838}
1839
1840// ============================================================================
1841// Motif-specific stuff from here on
1842// ============================================================================
1843
1844// ----------------------------------------------------------------------------
1845// function which maintain the global hash table mapping Widgets to wxWindows
1846// ----------------------------------------------------------------------------
1847
1848bool wxAddWindowToTable(Widget w, wxWindow *win)
1849{
1850 wxWindow *oldItem = NULL;
1851 if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
1852 {
1853 wxLogDebug("Widget table clash: new widget is %ld, %s",
1854 (long)w, win->GetClassInfo()->GetClassName());
1855 return FALSE;
1856 }
1857
1858 wxWidgetHashTable->Put((long) w, win);
1859
1860 wxLogTrace("widget", "Widget 0x%p <-> window %p (%s)",
1861 (WXWidget)w, win, win->GetClassInfo()->GetClassName());
1862
1863 return TRUE;
1864}
1865
1866wxWindow *wxGetWindowFromTable(Widget w)
1867{
1868 return (wxWindow *)wxWidgetHashTable->Get((long) w);
1869}
1870
1871void wxDeleteWindowFromTable(Widget w)
1872{
1873 wxLogTrace("widget", "Widget 0x%p", (WXWidget)w);
1874
1875 wxWidgetHashTable->Delete((long)w);
1876}
1877
1878// ----------------------------------------------------------------------------
1879// add/remove window from the table
1880// ----------------------------------------------------------------------------
1881
1882// Add to hash table, add event handler
1883bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
1884 WXWidget formWidget, int x, int y, int width, int height)
1885{
1886 wxAddWindowToTable((Widget) mainWidget, this);
1887 if (CanAddEventHandler())
1888 {
1889 XtAddEventHandler((Widget) mainWidget,
1890 ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
1891 False,
1892 wxPanelItemEventHandler,
1893 (XtPointer) this);
1894 }
1895
1896 if (!formWidget)
1897 {
1898 XtTranslations ptr;
1899 XtOverrideTranslations ((Widget) mainWidget,
1900 ptr = XtParseTranslationTable ("<Configure>: resize()"));
1901 XtFree ((char *) ptr);
1902 }
1903
1904 // Some widgets have a parent form widget, e.g. wxRadioBox
1905 if (formWidget)
1906 {
1907 if (!wxAddWindowToTable((Widget) formWidget, this))
1908 return FALSE;
1909
1910 XtTranslations ptr;
1911 XtOverrideTranslations ((Widget) formWidget,
1912 ptr = XtParseTranslationTable ("<Configure>: resize()"));
1913 XtFree ((char *) ptr);
1914 }
1915
1916 if (x == -1)
1917 x = 0;
1918 if (y == -1)
1919 y = 0;
1920 SetSize (x, y, width, height);
1921
1922 return TRUE;
1923}
1924
1925// Remove event handler, remove from hash table
1926bool wxWindow::DetachWidget(WXWidget widget)
1927{
1928 if (CanAddEventHandler())
1929 {
1930 XtRemoveEventHandler((Widget) widget,
1931 ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
1932 False,
1933 wxPanelItemEventHandler,
1934 (XtPointer)this);
1935 }
1936
1937 wxDeleteWindowFromTable((Widget) widget);
1938 return TRUE;
1939}
1940
1941// ----------------------------------------------------------------------------
1942// Motif-specific accessors
1943// ----------------------------------------------------------------------------
1944
1945// Get the underlying X window
1946WXWindow wxWindow::GetXWindow() const
1947{
1948 Widget wMain = (Widget)GetMainWidget();
1949 if ( wMain )
1950 return (WXWindow) XtWindow(wMain);
1951 else
1952 return (WXWindow) 0;
1953}
1954
1955// Get the underlying X display
1956WXDisplay *wxWindow::GetXDisplay() const
1957{
1958 Widget wMain = (Widget)GetMainWidget();
1959 if ( wMain )
1960 return (WXDisplay*) XtDisplay(wMain);
1961 else
1962 return (WXDisplay*) NULL;
1963}
1964
1965WXWidget wxWindow::GetMainWidget() const
1966{
1967 if (m_drawingArea)
1968 return m_drawingArea;
1969 else
1970 return m_mainWidget;
1971}
1972
1973WXWidget wxWindow::GetClientWidget() const
1974{
1975 if (m_drawingArea != (WXWidget) 0)
1976 return m_drawingArea;
1977 else
1978 return GetMainWidget();
1979}
1980
1981WXWidget wxWindow::GetTopWidget() const
1982{
1983 return GetMainWidget();
1984}
1985
1986WXWidget wxWindow::GetLabelWidget() const
1987{
1988 return GetMainWidget();
1989}
1990
1991// ----------------------------------------------------------------------------
1992// Motif callbacks
1993// ----------------------------------------------------------------------------
1994
1995// All widgets should have this as their resize proc.
1996// OnSize sent to wxWindow via client data.
1997void wxWidgetResizeProc(Widget w, XConfigureEvent *WXUNUSED(event),
1998 String WXUNUSED(args)[], int *WXUNUSED(num_args))
1999{
2000 wxWindow *win = wxGetWindowFromTable(w);
2001 if (!win)
2002 return;
2003
2004 if (win->PreResize())
2005 {
2006 int width, height;
2007 win->GetSize(&width, &height);
2008 wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
2009 sizeEvent.SetEventObject(win);
2010 win->GetEventHandler()->ProcessEvent(sizeEvent);
2011 }
2012}
2013
2014static void wxCanvasRepaintProc(Widget drawingArea,
2015 XtPointer clientData,
2016 XmDrawingAreaCallbackStruct * cbs)
2017{
2018 if (!wxGetWindowFromTable(drawingArea))
2019 return;
2020
2021 XEvent * event = cbs->event;
2022 wxWindow * win = (wxWindow *) clientData;
2023
2024 switch (event->type)
2025 {
2026 case Expose:
2027 {
2028 win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
2029 event->xexpose.width, event->xexpose.height);
2030
2031 if (event -> xexpose.count == 0)
2032 {
2033 win->DoPaint();
2034 win->ClearUpdateRects();
2035 }
2036 break;
2037 }
2038 }
2039}
2040
2041// Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
2042static void wxCanvasEnterLeave(Widget drawingArea,
2043 XtPointer WXUNUSED(clientData),
2044 XCrossingEvent * event)
2045{
2046 XmDrawingAreaCallbackStruct cbs;
2047 XEvent ev;
2048
2049 ((XCrossingEvent &) ev) = *event;
2050
2051 cbs.reason = XmCR_INPUT;
2052 cbs.event = &ev;
2053
2054 wxCanvasInputEvent(drawingArea, (XtPointer) NULL, &cbs);
2055}
2056
2057// Fix to make it work under Motif 1.0 (!)
2058static void wxCanvasMotionEvent (Widget WXUNUSED(drawingArea),
2059 XButtonEvent *WXUNUSED(event))
2060{
2061#if XmVersion <= 1000
2062 XmDrawingAreaCallbackStruct cbs;
2063 XEvent ev;
2064
2065 ev = *((XEvent *) event);
2066 cbs.reason = XmCR_INPUT;
2067 cbs.event = &ev;
2068
2069 wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2070#endif // XmVersion <= 1000
2071}
2072
2073static void wxCanvasInputEvent(Widget drawingArea,
2074 XtPointer WXUNUSED(data),
2075 XmDrawingAreaCallbackStruct * cbs)
2076{
2077 wxWindow *canvas = wxGetWindowFromTable(drawingArea);
2078 XEvent local_event;
2079
2080 if (canvas==NULL)
2081 return;
2082
2083 if (cbs->reason != XmCR_INPUT)
2084 return;
2085
2086 local_event = *(cbs->event); // We must keep a copy!
2087
2088 switch (local_event.xany.type)
2089 {
2090 case EnterNotify:
2091 case LeaveNotify:
2092 case ButtonPress:
2093 case ButtonRelease:
2094 case MotionNotify:
2095 {
2096 // FIXME: most of this mouse event code is more or less
2097 // duplicated in wxTranslateMouseEvent
2098 //
2099 wxEventType eventType = wxEVT_NULL;
2100
2101 if (local_event.xany.type == EnterNotify)
2102 {
2103 //if (local_event.xcrossing.mode!=NotifyNormal)
2104 // return ; // Ignore grab events
2105 eventType = wxEVT_ENTER_WINDOW;
2106 // canvas->GetEventHandler()->OnSetFocus();
2107 }
2108 else if (local_event.xany.type == LeaveNotify)
2109 {
2110 //if (local_event.xcrossingr.mode!=NotifyNormal)
2111 // return ; // Ignore grab events
2112 eventType = wxEVT_LEAVE_WINDOW;
2113 // canvas->GetEventHandler()->OnKillFocus();
2114 }
2115 else if (local_event.xany.type == MotionNotify)
2116 {
2117 eventType = wxEVT_MOTION;
2118 }
2119
2120 else if (local_event.xany.type == ButtonPress)
2121 {
2122 if (local_event.xbutton.button == Button1)
2123 {
2124 eventType = wxEVT_LEFT_DOWN;
2125 canvas->SetButton1(TRUE);
2126 }
2127 else if (local_event.xbutton.button == Button2)
2128 {
2129 eventType = wxEVT_MIDDLE_DOWN;
2130 canvas->SetButton2(TRUE);
2131 }
2132 else if (local_event.xbutton.button == Button3)
2133 {
2134 eventType = wxEVT_RIGHT_DOWN;
2135 canvas->SetButton3(TRUE);
2136 }
2137 }
2138 else if (local_event.xany.type == ButtonRelease)
2139 {
2140 if (local_event.xbutton.button == Button1)
2141 {
2142 eventType = wxEVT_LEFT_UP;
2143 canvas->SetButton1(FALSE);
2144 }
2145 else if (local_event.xbutton.button == Button2)
2146 {
2147 eventType = wxEVT_MIDDLE_UP;
2148 canvas->SetButton2(FALSE);
2149 }
2150 else if (local_event.xbutton.button == Button3)
2151 {
2152 eventType = wxEVT_RIGHT_UP;
2153 canvas->SetButton3(FALSE);
2154 }
2155 }
2156
2157 wxMouseEvent wxevent (eventType);
2158
2159 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2160 || (event_left_is_down (&local_event)
2161 && (eventType != wxEVT_LEFT_UP)));
2162 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2163 || (event_middle_is_down (&local_event)
2164 && (eventType != wxEVT_MIDDLE_UP)));
2165 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2166 || (event_right_is_down (&local_event)
2167 && (eventType != wxEVT_RIGHT_UP)));
2168
2169 wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
2170 wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
2171 wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
2172 wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
2173 wxevent.SetTimestamp(local_event.xbutton.time);
2174
2175 if ( eventType == wxEVT_MOTION )
2176 {
2177 if (local_event.xmotion.is_hint == NotifyHint)
2178 {
2179 Window root, child;
2180 Display *dpy = XtDisplay (drawingArea);
2181
2182 XQueryPointer (dpy, XtWindow (drawingArea),
2183 &root, &child,
2184 &local_event.xmotion.x_root,
2185 &local_event.xmotion.y_root,
2186 &local_event.xmotion.x,
2187 &local_event.xmotion.y,
2188 &local_event.xmotion.state);
2189 }
2190 else
2191 {
2192 }
2193 }
2194
2195 // Now check if we need to translate this event into a double click
2196 if (TRUE) // canvas->doubleClickAllowed)
2197 {
2198 if (wxevent.ButtonDown())
2199 {
2200 long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
2201
2202 // get button and time-stamp
2203 int button = 0;
2204 if (wxevent.LeftDown())
2205 button = 1;
2206 else if (wxevent.MiddleDown())
2207 button = 2;
2208 else if (wxevent.RightDown())
2209 button = 3;
2210 long ts = wxevent.GetTimestamp();
2211
2212 // check, if single or double click
2213 int buttonLast = canvas->GetLastClickedButton();
2214 long lastTS = canvas->GetLastClickTime();
2215 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
2216 {
2217 // I have a dclick
2218 canvas->SetLastClick(0, ts);
2219
2220 wxEventType typeDouble;
2221 if ( eventType == wxEVT_LEFT_DOWN )
2222 typeDouble = wxEVT_LEFT_DCLICK;
2223 else if ( eventType == wxEVT_MIDDLE_DOWN )
2224 typeDouble = wxEVT_MIDDLE_DCLICK;
2225 else if ( eventType == wxEVT_RIGHT_DOWN )
2226 typeDouble = wxEVT_RIGHT_DCLICK;
2227 else
2228 typeDouble = wxEVT_NULL;
2229
2230 if ( typeDouble != wxEVT_NULL )
2231 {
2232 wxevent.SetEventType(typeDouble);
2233 }
2234 }
2235 else
2236 {
2237 // not fast enough or different button
2238 canvas->SetLastClick(button, ts);
2239 }
2240 }
2241 }
2242
2243 wxevent.SetId(canvas->GetId());
2244 wxevent.SetEventObject(canvas);
2245 wxevent.m_x = local_event.xbutton.x;
2246 wxevent.m_y = local_event.xbutton.y;
2247 canvas->GetEventHandler()->ProcessEvent (wxevent);
2248#if 0
2249 if (eventType == wxEVT_ENTER_WINDOW ||
2250 eventType == wxEVT_LEAVE_WINDOW ||
2251 eventType == wxEVT_MOTION
2252 )
2253 return;
2254#endif // 0
2255 break;
2256 }
2257 case KeyPress:
2258 {
2259 wxKeyEvent event (wxEVT_CHAR);
2260 if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
2261 {
2262 // Implement wxFrame::OnCharHook by checking ancestor.
2263 wxWindow *parent = canvas;
2264 while (parent && !parent->IsTopLevel())
2265 parent = parent->GetParent();
2266
2267 if (parent)
2268 {
2269 event.SetEventType(wxEVT_CHAR_HOOK);
2270 if (parent->GetEventHandler()->ProcessEvent(event))
2271 return;
2272 }
2273
2274 // For simplicity, OnKeyDown is the same as OnChar
2275 // TODO: filter modifier key presses from OnChar
2276 event.SetEventType(wxEVT_KEY_DOWN);
2277
2278 // Only process OnChar if OnKeyDown didn't swallow it
2279 if (!canvas->GetEventHandler()->ProcessEvent (event))
2280 {
2281 event.SetEventType(wxEVT_CHAR);
2282 canvas->GetEventHandler()->ProcessEvent (event);
2283 }
2284 }
2285 break;
2286 }
2287 case KeyRelease:
2288 {
2289 wxKeyEvent event (wxEVT_KEY_UP);
2290 if (wxTranslateKeyEvent (event, canvas, (Widget) 0, &local_event))
2291 {
2292 canvas->GetEventHandler()->ProcessEvent (event);
2293 }
2294 break;
2295 }
2296 case FocusIn:
2297 {
2298 if (local_event.xfocus.detail != NotifyPointer)
2299 {
2300 wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
2301 event.SetEventObject(canvas);
2302 canvas->GetEventHandler()->ProcessEvent(event);
2303 }
2304 break;
2305 }
2306 case FocusOut:
2307 {
2308 if (local_event.xfocus.detail != NotifyPointer)
2309 {
2310 wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
2311 event.SetEventObject(canvas);
2312 canvas->GetEventHandler()->ProcessEvent(event);
2313 }
2314 break;
2315 }
2316 default:
2317 break;
2318 }
2319}
2320
2321static void wxPanelItemEventHandler(Widget wid,
2322 XtPointer WXUNUSED(client_data),
2323 XEvent* event,
2324 Boolean *continueToDispatch)
2325{
2326 // Widget can be a label or the actual widget.
2327
2328 wxWindow *window = wxGetWindowFromTable(wid);
2329 if (window)
2330 {
2331 wxMouseEvent wxevent(0);
2332 if (wxTranslateMouseEvent(wxevent, window, wid, event))
2333 {
2334 window->GetEventHandler()->ProcessEvent(wxevent);
2335 }
2336 }
2337
2338 // TODO: probably the key to allowing default behaviour to happen. Say we
2339 // set a m_doDefault flag to FALSE at the start of this function. Then in
2340 // e.g. wxWindow::OnMouseEvent we can call Default() which sets this flag to
2341 // TRUE, indicating that default processing can happen. Thus, behaviour can
2342 // appear to be overridden just by adding an event handler and not calling
2343 // wxWindow::OnWhatever. ALSO, maybe we can use this instead of the current
2344 // way of handling drawing area events, to simplify things.
2345 *continueToDispatch = True;
2346}
2347
2348static void wxScrollBarCallback(Widget scrollbar,
2349 XtPointer clientData,
2350 XmScrollBarCallbackStruct *cbs)
2351{
2352 wxWindow *win = wxGetWindowFromTable(scrollbar);
2353 int orientation = (int) clientData;
2354
2355 wxEventType eventType = wxEVT_NULL;
2356 switch (cbs->reason)
2357 {
2358 case XmCR_INCREMENT:
2359 {
2360 eventType = wxEVT_SCROLLWIN_LINEDOWN;
2361 break;
2362 }
2363 case XmCR_DECREMENT:
2364 {
2365 eventType = wxEVT_SCROLLWIN_LINEUP;
2366 break;
2367 }
2368 case XmCR_DRAG:
2369 {
2370 eventType = wxEVT_SCROLLWIN_THUMBTRACK;
2371 break;
2372 }
2373 case XmCR_VALUE_CHANGED:
2374 {
2375 eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
2376 break;
2377 }
2378 case XmCR_PAGE_INCREMENT:
2379 {
2380 eventType = wxEVT_SCROLLWIN_PAGEDOWN;
2381 break;
2382 }
2383 case XmCR_PAGE_DECREMENT:
2384 {
2385 eventType = wxEVT_SCROLLWIN_PAGEUP;
2386 break;
2387 }
2388 case XmCR_TO_TOP:
2389 {
2390 eventType = wxEVT_SCROLLWIN_TOP;
2391 break;
2392 }
2393 case XmCR_TO_BOTTOM:
2394 {
2395 eventType = wxEVT_SCROLLWIN_BOTTOM;
2396 break;
2397 }
2398 default:
2399 {
2400 // Should never get here
2401 wxFAIL_MSG("Unknown scroll event.");
2402 break;
2403 }
2404 }
2405
2406 wxScrollWinEvent event(eventType,
2407 cbs->value,
2408 ((orientation == XmHORIZONTAL) ?
2409 wxHORIZONTAL : wxVERTICAL));
2410 event.SetEventObject( win );
2411 win->GetEventHandler()->ProcessEvent(event);
2412}
2413
2414// For repainting arbitrary windows
2415void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *)
2416{
2417 Window window;
2418 Display *display;
2419
2420 wxWindow* win = wxGetWindowFromTable(w);
2421 if (!win)
2422 return;
2423
2424 switch(event -> type)
2425 {
2426 case Expose:
2427 {
2428 window = (Window) win -> GetXWindow();
2429 display = (Display *) win -> GetXDisplay();
2430
2431 if (event -> xexpose.count == 0)
2432 {
2433 win->DoPaint();
2434
2435 win->ClearUpdateRects();
2436 }
2437 else
2438 {
2439 win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
2440 event->xexpose.width, event->xexpose.height);
2441 }
2442
2443 break;
2444 }
2445 }
2446}
2447
2448// ----------------------------------------------------------------------------
2449// TranslateXXXEvent() functions
2450// ----------------------------------------------------------------------------
2451
2452bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
2453{
2454 switch (xevent->xany.type)
2455 {
2456 case EnterNotify: // never received here - yes ? MB
2457 case LeaveNotify: // never received here - yes ? MB
2458 case ButtonPress:
2459 case ButtonRelease:
2460 case MotionNotify:
2461 {
2462 wxEventType eventType = wxEVT_NULL;
2463
2464 // FIXME: this is never true I think - MB
2465 //
2466 if (xevent->xany.type == LeaveNotify)
2467 {
2468 win->SetButton1(FALSE);
2469 win->SetButton2(FALSE);
2470 win->SetButton3(FALSE);
2471 return FALSE;
2472 }
2473 else if (xevent->xany.type == MotionNotify)
2474 {
2475 eventType = wxEVT_MOTION;
2476 }
2477 else if (xevent->xany.type == ButtonPress)
2478 {
2479 wxevent.SetTimestamp(xevent->xbutton.time);
2480 int button = 0;
2481 if (xevent->xbutton.button == Button1)
2482 {
2483 eventType = wxEVT_LEFT_DOWN;
2484 win->SetButton1(TRUE);
2485 button = 1;
2486 }
2487 else if (xevent->xbutton.button == Button2)
2488 {
2489 eventType = wxEVT_MIDDLE_DOWN;
2490 win->SetButton2(TRUE);
2491 button = 2;
2492 }
2493 else if (xevent->xbutton.button == Button3)
2494 {
2495 eventType = wxEVT_RIGHT_DOWN;
2496 win->SetButton3(TRUE);
2497 button = 3;
2498 }
2499
2500 // check for a double click
2501 //
2502 long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay());
2503 long ts = wxevent.GetTimestamp();
2504
2505 int buttonLast = win->GetLastClickedButton();
2506 long lastTS = win->GetLastClickTime();
2507 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
2508 {
2509 // I have a dclick
2510 win->SetLastClick(0, ts);
2511 if ( eventType == wxEVT_LEFT_DOWN )
2512 eventType = wxEVT_LEFT_DCLICK;
2513 else if ( eventType == wxEVT_MIDDLE_DOWN )
2514 eventType = wxEVT_MIDDLE_DCLICK;
2515 else if ( eventType == wxEVT_RIGHT_DOWN )
2516 eventType = wxEVT_RIGHT_DCLICK;
2517 }
2518 else
2519 {
2520 // not fast enough or different button
2521 win->SetLastClick(button, ts);
2522 }
2523 }
2524 else if (xevent->xany.type == ButtonRelease)
2525 {
2526 if (xevent->xbutton.button == Button1)
2527 {
2528 eventType = wxEVT_LEFT_UP;
2529 win->SetButton1(FALSE);
2530 }
2531 else if (xevent->xbutton.button == Button2)
2532 {
2533 eventType = wxEVT_MIDDLE_UP;
2534 win->SetButton2(FALSE);
2535 }
2536 else if (xevent->xbutton.button == Button3)
2537 {
2538 eventType = wxEVT_RIGHT_UP;
2539 win->SetButton3(FALSE);
2540 }
2541 else return FALSE;
2542 }
2543 else
2544 {
2545 return FALSE;
2546 }
2547
2548 wxevent.SetEventType(eventType);
2549
2550 Position x1, y1;
2551 XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
2552
2553 int x2, y2;
2554 win->GetPosition(&x2, &y2);
2555
2556 // The button x/y must be translated to wxWindows
2557 // window space - the widget might be a label or button,
2558 // within a form.
2559 int dx = 0;
2560 int dy = 0;
2561 if (widget != (Widget)win->GetMainWidget())
2562 {
2563 dx = x1;
2564 dy = y1;
2565 }
2566
2567 wxevent.m_x = xevent->xbutton.x + dx;
2568 wxevent.m_y = xevent->xbutton.y + dy;
2569
2570 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2571 || (event_left_is_down (xevent)
2572 && (eventType != wxEVT_LEFT_UP)));
2573 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2574 || (event_middle_is_down (xevent)
2575 && (eventType != wxEVT_MIDDLE_UP)));
2576 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2577 || (event_right_is_down (xevent)
2578 && (eventType != wxEVT_RIGHT_UP)));
2579
2580 wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
2581 wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
2582 wxevent.m_altDown = xevent->xbutton.state & Mod3Mask;
2583 wxevent.m_metaDown = xevent->xbutton.state & Mod1Mask;
2584
2585 wxevent.SetId(win->GetId());
2586 wxevent.SetEventObject(win);
2587
2588 return TRUE;
2589 }
2590 }
2591 return FALSE;
2592}
2593
2594bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,
2595 Widget WXUNUSED(widget), XEvent *xevent)
2596{
2597 switch (xevent->xany.type)
2598 {
2599 case KeyPress:
2600 case KeyRelease:
2601 {
2602 char buf[20];
2603
2604 KeySym keySym;
2605 (void) XLookupString((XKeyEvent *)xevent, buf, 20, &keySym, NULL);
2606 int id = wxCharCodeXToWX (keySym);
2607 // id may be WXK_xxx code - these are outside ASCII range, so we
2608 // can't just use toupper() on id
2609 if (id >= 'a' && id <= 'z')
2610 id = toupper(id);
2611
2612 if (xevent->xkey.state & ShiftMask)
2613 wxevent.m_shiftDown = TRUE;
2614 if (xevent->xkey.state & ControlMask)
2615 wxevent.m_controlDown = TRUE;
2616 if (xevent->xkey.state & Mod3Mask)
2617 wxevent.m_altDown = TRUE;
2618 if (xevent->xkey.state & Mod1Mask)
2619 wxevent.m_metaDown = TRUE;
2620 wxevent.SetEventObject(win);
2621 wxevent.m_keyCode = id;
2622 wxevent.SetTimestamp(xevent->xkey.time);
2623
2624 wxevent.m_x = xevent->xbutton.x;
2625 wxevent.m_y = xevent->xbutton.y;
2626
2627 if (id > -1)
2628 return TRUE;
2629 else
2630 return FALSE;
2631 break;
2632 }
2633 default:
2634 break;
2635 }
2636 return FALSE;
2637}
2638
2639// ----------------------------------------------------------------------------
2640// Colour stuff
2641// ----------------------------------------------------------------------------
2642
2643#define YAllocColor XAllocColor
2644XColor g_itemColors[5];
2645int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
2646{
2647 int result;
2648 static XmColorProc colorProc;
2649
2650 result = wxNO_COLORS;
2651
2652 if (back)
2653 {
2654 g_itemColors[0].red = (((long) back->Red ()) << 8);
2655 g_itemColors[0].green = (((long) back->Green ()) << 8);
2656 g_itemColors[0].blue = (((long) back->Blue ()) << 8);
2657 g_itemColors[0].flags = DoRed | DoGreen | DoBlue;
2658 if (colorProc == (XmColorProc) NULL)
2659 {
2660 // Get a ptr to the actual function
2661 colorProc = XmSetColorCalculation ((XmColorProc) NULL);
2662 // And set it back to motif.
2663 XmSetColorCalculation (colorProc);
2664 }
2665 (*colorProc) (&g_itemColors[wxBACK_INDEX],
2666 &g_itemColors[wxFORE_INDEX],
2667 &g_itemColors[wxSELE_INDEX],
2668 &g_itemColors[wxTOPS_INDEX],
2669 &g_itemColors[wxBOTS_INDEX]);
2670 result = wxBACK_COLORS;
2671 }
2672 if (fore)
2673 {
2674 g_itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
2675 g_itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
2676 g_itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
2677 g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
2678 if (result == wxNO_COLORS)
2679 result = wxFORE_COLORS;
2680 }
2681
2682 Display *dpy = display;
2683 Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
2684
2685 if (back)
2686 {
2687 /* 5 Colours to allocate */
2688 for (int i = 0; i < 5; i++)
2689 if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
2690 result = wxNO_COLORS;
2691 }
2692 else if (fore)
2693 {
2694 /* Only 1 colour to allocate */
2695 if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
2696 result = wxNO_COLORS;
2697 }
2698
2699 return result;
2700}
2701
2702// Changes the foreground and background colours to be derived from the current
2703// background colour. To change the foreground colour, you must call
2704// SetForegroundColour explicitly.
2705void wxWindow::ChangeBackgroundColour()
2706{
2707 WXWidget mainWidget = GetMainWidget();
2708 if ( mainWidget )
2709 DoChangeBackgroundColour(mainWidget, m_backgroundColour);
2710}
2711
2712void wxWindow::ChangeForegroundColour()
2713{
2714 WXWidget mainWidget = GetMainWidget();
2715 if ( mainWidget )
2716 DoChangeForegroundColour(mainWidget, m_foregroundColour);
2717 if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
2718 DoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
2719}
2720
2721// Change a widget's foreground and background colours.
2722void wxWindow::DoChangeForegroundColour(WXWidget widget,
2723 wxColour& foregroundColour)
2724{
2725 wxDoChangeForegroundColour( widget, foregroundColour );
2726}
2727
2728void wxWindow::DoChangeBackgroundColour(WXWidget widget,
2729 wxColour& backgroundColour,
2730 bool changeArmColour)
2731{
2732 wxDoChangeBackgroundColour( widget, backgroundColour, changeArmColour );
2733}
2734
2735bool wxWindow::SetBackgroundColour(const wxColour& col)
2736{
2737 if ( !wxWindowBase::SetBackgroundColour(col) )
2738 return FALSE;
2739
2740 ChangeBackgroundColour();
2741
2742 return TRUE;
2743}
2744
2745bool wxWindow::SetForegroundColour(const wxColour& col)
2746{
2747 if ( !wxWindowBase::SetForegroundColour(col) )
2748 return FALSE;
2749
2750 ChangeForegroundColour();
2751
2752 return TRUE;
2753}
2754
2755void wxWindow::ChangeFont(bool keepOriginalSize)
2756{
2757 // Note that this causes the widget to be resized back
2758 // to its original size! We therefore have to set the size
2759 // back again. TODO: a better way in Motif?
2760 Widget w = (Widget) GetLabelWidget(); // Usually the main widget
2761 if (w && m_font.Ok())
2762 {
2763 int width, height, width1, height1;
2764 GetSize(& width, & height);
2765
2766 wxDoChangeFont( GetLabelWidget(), m_font );
2767
2768 GetSize(& width1, & height1);
2769 if (keepOriginalSize && (width != width1 || height != height1))
2770 {
2771 SetSize(-1, -1, width, height);
2772 }
2773 }
2774}
2775
2776// ----------------------------------------------------------------------------
2777// global functions
2778// ----------------------------------------------------------------------------
2779
2780wxWindow *wxGetActiveWindow()
2781{
2782 // TODO
2783 wxFAIL_MSG("Not implemented");
2784 return NULL;
2785}
2786
2787/* static */
2788wxWindow *wxWindowBase::GetCapture()
2789{
2790 return (wxWindow *)g_captureWindow;
2791}
2792
2793
2794// Find the wxWindow at the current mouse position, returning the mouse
2795// position.
2796wxWindow* wxFindWindowAtPointer(wxPoint& pt)
2797{
2798 return wxFindWindowAtPoint(wxGetMousePosition());
2799}
2800
2801// Get the current mouse position.
2802wxPoint wxGetMousePosition()
2803{
2804 Display *display = (Display*) wxGetDisplay();
2805 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
2806 Window rootReturn, childReturn;
2807 int rootX, rootY, winX, winY;
2808 unsigned int maskReturn;
2809
2810 XQueryPointer (display,
2811 rootWindow,
2812 &rootReturn,
2813 &childReturn,
2814 &rootX, &rootY, &winX, &winY, &maskReturn);
2815 return wxPoint(rootX, rootY);
2816}
2817
2818
2819// ----------------------------------------------------------------------------
2820// wxNoOptimize: switch off size optimization
2821// ----------------------------------------------------------------------------
2822
2823int wxNoOptimize::ms_count = 0;
2824
wxWidgets (Impactor)