]> git.saurik.com Git - wxWidgets.git/blob - src/x11/window.cpp
added iconbndl method, removed deleted files from project
[wxWidgets.git] / src / x11 / window.cpp
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 #include "wx/setup.h"
25 #include "wx/menu.h"
26 #include "wx/dc.h"
27 #include "wx/dcclient.h"
28 #include "wx/utils.h"
29 #include "wx/app.h"
30 #include "wx/panel.h"
31 #include "wx/layout.h"
32 #include "wx/dialog.h"
33 #include "wx/listbox.h"
34 #include "wx/button.h"
35 #include "wx/settings.h"
36 #include "wx/msgdlg.h"
37 #include "wx/frame.h"
38 #include "wx/scrolwin.h"
39 #include "wx/scrolbar.h"
40 #include "wx/module.h"
41 #include "wx/menuitem.h"
42 #include "wx/log.h"
43
44 #if wxUSE_DRAG_AND_DROP
45 #include "wx/dnd.h"
46 #endif
47
48 #include "wx/x11/private.h"
49 #include "X11/Xutil.h"
50
51 #if wxUSE_NANOX
52 // For wxGetLocalTime, used by XButtonEventGetTime
53 #include "wx/timer.h"
54 #endif
55
56 #include <string.h>
57
58 // ----------------------------------------------------------------------------
59 // global variables for this module
60 // ----------------------------------------------------------------------------
61
62 extern wxHashTable *wxWidgetHashTable;
63 extern wxHashTable *wxClientWidgetHashTable;
64 static wxWindow* g_captureWindow = NULL;
65
66 // ----------------------------------------------------------------------------
67 // macros
68 // ----------------------------------------------------------------------------
69
70 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
71 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
72 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
73
74 // ----------------------------------------------------------------------------
75 // event tables
76 // ----------------------------------------------------------------------------
77
78 IMPLEMENT_ABSTRACT_CLASS(wxWindowX11, wxWindowBase)
79
80 BEGIN_EVENT_TABLE(wxWindowX11, wxWindowBase)
81 EVT_SYS_COLOUR_CHANGED(wxWindowX11::OnSysColourChanged)
82 END_EVENT_TABLE()
83
84 // ============================================================================
85 // implementation
86 // ============================================================================
87
88 // ----------------------------------------------------------------------------
89 // helper functions
90 // ----------------------------------------------------------------------------
91
92 // ----------------------------------------------------------------------------
93 // constructors
94 // ----------------------------------------------------------------------------
95
96 void wxWindowX11::Init()
97 {
98 // generic initializations first
99 InitBase();
100
101 // X11-specific
102 m_mainWindow = (WXWindow) 0;
103 m_clientWindow = (WXWindow) 0;
104 m_insertIntoMain = FALSE;
105 m_updateNcArea = FALSE;
106
107 m_winCaptured = FALSE;
108 m_needsInputFocus = FALSE;
109 m_isShown = TRUE;
110 m_isBeingDeleted = FALSE;
111 m_lastTS = 0;
112 m_lastButton = 0;
113 }
114
115 // real construction (Init() must have been called before!)
116 bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
117 const wxPoint& pos,
118 const wxSize& size,
119 long style,
120 const wxString& name)
121 {
122 wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
123
124 CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
125
126 parent->AddChild(this);
127
128 int w = size.GetWidth();
129 int h = size.GetHeight();
130 int x = size.GetX();
131 int y = size.GetY();
132 if (w == -1) w = 20;
133 if (h == -1) h = 20;
134 if (x == -1) x = 0;
135 if (y == -1) y = 0;
136
137 Display *xdisplay = (Display*) wxGlobalDisplay();
138 int xscreen = DefaultScreen( xdisplay );
139 Visual *xvisual = DefaultVisual( xdisplay, xscreen );
140 Colormap cm = DefaultColormap( xdisplay, xscreen );
141
142 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
143 m_backgroundColour.CalcPixel( (WXColormap) cm );
144
145 m_foregroundColour = *wxBLACK;
146 m_foregroundColour.CalcPixel( (WXColormap) cm );
147
148 Window xparent = (Window) parent->GetClientWindow();
149
150 // Add window's own scrollbars to main window, not to client window
151 if (parent->GetInsertIntoMain())
152 {
153 // wxLogDebug( "Inserted into main: %s", GetName().c_str() );
154 xparent = (Window) parent->GetMainWindow();
155 }
156
157 wxSize size2(size);
158 if (size2.x == -1)
159 size2.x = 20;
160 if (size2.y == -1)
161 size2.y = 20;
162
163 wxPoint pos2(pos);
164 if (pos2.x == -1)
165 pos2.x = 0;
166 if (pos2.y == -1)
167 pos2.y = 0;
168
169 #if !wxUSE_NANOX
170
171 #if wxUSE_TWO_WINDOWS
172 bool need_two_windows =
173 ((( wxSUNKEN_BORDER | wxRAISED_BORDER | wxSIMPLE_BORDER | wxHSCROLL | wxVSCROLL ) & m_windowStyle) != 0);
174 #else
175 bool need_two_windows = FALSE;
176 #endif
177
178 XSetWindowAttributes xattributes;
179 long xattributes_mask = 0;
180
181 xattributes_mask |= CWBackPixel;
182 xattributes.background_pixel = m_backgroundColour.GetPixel();
183
184 xattributes_mask |= CWBorderPixel;
185 xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
186
187 xattributes_mask |= CWEventMask;
188
189 if (need_two_windows)
190 {
191 xattributes.event_mask =
192 ExposureMask | StructureNotifyMask | ColormapChangeMask;
193
194 Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
195 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
196
197 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
198
199 m_mainWindow = (WXWindow) xwindow;
200 wxAddWindowToTable( xwindow, (wxWindow*) this );
201
202 XMapWindow( xdisplay, xwindow );
203
204 xattributes.event_mask =
205 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
206 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
207 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
208 PropertyChangeMask | VisibilityChangeMask ;
209
210 if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
211 {
212 xattributes_mask |= CWBitGravity;
213 xattributes.bit_gravity = StaticGravity;
214 }
215
216 if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
217 {
218 pos2.x = 2;
219 pos2.y = 2;
220 size2.x -= 4;
221 size2.y -= 4;
222 } else
223 if (HasFlag( wxSIMPLE_BORDER ))
224 {
225 pos2.x = 1;
226 pos2.y = 1;
227 size2.x -= 2;
228 size2.y -= 2;
229 } else
230 {
231 pos2.x = 0;
232 pos2.y = 0;
233 }
234
235 xwindow = XCreateWindow( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y,
236 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
237
238 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
239
240 m_clientWindow = (WXWindow) xwindow;
241 wxAddClientWindowToTable( xwindow, (wxWindow*) this );
242
243 XMapWindow( xdisplay, xwindow );
244 }
245 else
246 {
247 // wxLogDebug( "No two windows needed %s", GetName().c_str() );
248
249 xattributes.event_mask =
250 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
251 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
252 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
253 PropertyChangeMask | VisibilityChangeMask ;
254
255 if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
256 {
257 xattributes_mask |= CWBitGravity;
258 xattributes.bit_gravity = NorthWestGravity;
259 }
260
261 Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
262 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
263
264 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
265
266 m_mainWindow = (WXWindow) xwindow;
267 m_clientWindow = m_mainWindow;
268 wxAddWindowToTable( xwindow, (wxWindow*) this );
269
270 XMapWindow( xdisplay, xwindow );
271 }
272 #else
273
274 int extraFlags = GR_EVENT_MASK_CLOSE_REQ;
275
276 long backColor, foreColor;
277 backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
278 foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
279
280 Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
281 0, 0, InputOutput, xvisual, backColor, foreColor);
282 XSelectInput( xdisplay, xwindow,
283 extraFlags | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
284 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
285 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
286 PropertyChangeMask );
287
288 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
289
290 m_mainWindow = (WXWindow) xwindow;
291 wxAddWindowToTable( xwindow, (wxWindow*) this );
292
293 XMapWindow( xdisplay, xwindow );
294 #endif
295
296 // Is a subwindow, so map immediately
297 m_isShown = TRUE;
298
299 // Without this, the cursor may not be restored properly (e.g. in splitter
300 // sample).
301 SetCursor(*wxSTANDARD_CURSOR);
302 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
303
304 // Don't call this, it can have nasty repercussions for composite controls,
305 // for example
306 // SetSize(pos.x, pos.y, size.x, size.y);
307
308 return TRUE;
309 }
310
311 // Destructor
312 wxWindowX11::~wxWindowX11()
313 {
314 if (g_captureWindow == this)
315 g_captureWindow = NULL;
316
317 m_isBeingDeleted = TRUE;
318
319 if (m_parent)
320 m_parent->RemoveChild( this );
321
322 DestroyChildren();
323
324 if (m_clientWindow != m_mainWindow)
325 {
326 // Destroy the cleint window
327 Window xwindow = (Window) m_clientWindow;
328 wxDeleteClientWindowFromTable( xwindow );
329 XDestroyWindow( wxGlobalDisplay(), xwindow );
330 m_clientWindow = NULL;
331 }
332
333 // Destroy the window
334 Window xwindow = (Window) m_mainWindow;
335 wxDeleteWindowFromTable( xwindow );
336 XDestroyWindow( wxGlobalDisplay(), xwindow );
337 m_mainWindow = NULL;
338 }
339
340 // ---------------------------------------------------------------------------
341 // basic operations
342 // ---------------------------------------------------------------------------
343
344 void wxWindowX11::SetFocus()
345 {
346 Window xwindow = (Window) m_clientWindow;
347
348 wxCHECK_RET( xwindow, wxT("invalid window") );
349
350 wxCHECK_RET( AcceptsFocus(), wxT("set focus on window that doesn't accept the focus") );
351
352 #if 0
353 if (GetName() == "scrollBar")
354 {
355 char *crash = NULL;
356 *crash = 0;
357 }
358 #endif
359
360 if (wxWindowIsVisible(xwindow))
361 {
362 XSetInputFocus( wxGlobalDisplay(), xwindow, RevertToParent, CurrentTime );
363 m_needsInputFocus = FALSE;
364 }
365 else
366 {
367 m_needsInputFocus = TRUE;
368 }
369 }
370
371 // Get the window with the focus
372 wxWindow *wxWindowBase::FindFocus()
373 {
374 Window xfocus = (Window) 0;
375 int revert = 0;
376
377 XGetInputFocus( wxGlobalDisplay(), &xfocus, &revert);
378 if (xfocus)
379 {
380 wxWindow *win = wxGetWindowFromTable( xfocus );
381
382 return win;
383 }
384
385 return NULL;
386 }
387
388 // Enabling/disabling handled by event loop, and not sending events
389 // if disabled.
390 bool wxWindowX11::Enable(bool enable)
391 {
392 if ( !wxWindowBase::Enable(enable) )
393 return FALSE;
394
395 return TRUE;
396 }
397
398 bool wxWindowX11::Show(bool show)
399 {
400 wxWindowBase::Show(show);
401
402 Window xwindow = (Window) m_mainWindow;
403 Display *xdisp = wxGlobalDisplay();
404 if (show)
405 {
406 // wxLogDebug( "Mapping window of type %s", GetName().c_str() );
407 XMapWindow(xdisp, xwindow);
408 }
409 else
410 {
411 // wxLogDebug( "Unmapping window of type %s", GetName().c_str() );
412 XUnmapWindow(xdisp, xwindow);
413 }
414
415 return TRUE;
416 }
417
418 // Raise the window to the top of the Z order
419 void wxWindowX11::Raise()
420 {
421 if (m_mainWindow)
422 XRaiseWindow( wxGlobalDisplay(), (Window) m_mainWindow );
423 }
424
425 // Lower the window to the bottom of the Z order
426 void wxWindowX11::Lower()
427 {
428 if (m_mainWindow)
429 XLowerWindow( wxGlobalDisplay(), (Window) m_mainWindow );
430 }
431
432 void wxWindowX11::DoCaptureMouse()
433 {
434 if ((g_captureWindow != NULL) && (g_captureWindow != this))
435 {
436 wxASSERT_MSG(FALSE, "Trying to capture before mouse released.");
437
438 // Core dump now
439 int *tmp = NULL;
440 (*tmp) = 1;
441 return;
442 }
443
444 if (m_winCaptured)
445 return;
446
447 Window xwindow = (Window) m_clientWindow;
448
449 wxCHECK_RET( xwindow, wxT("invalid window") );
450
451 g_captureWindow = (wxWindow*) this;
452
453 if (xwindow)
454 {
455 int res = XGrabPointer(wxGlobalDisplay(), xwindow,
456 FALSE,
457 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
458 GrabModeAsync,
459 GrabModeAsync,
460 None,
461 None, /* cursor */ // TODO: This may need to be set to the cursor of this window
462 CurrentTime );
463
464 if (res != GrabSuccess)
465 {
466 wxString msg;
467 msg.Printf("Failed to grab pointer for window %s", this->GetClassInfo()->GetClassName());
468 wxLogDebug(msg);
469 if (res == GrabNotViewable)
470 {
471 wxLogDebug("This is not a viewable window - perhaps not shown yet?");
472 }
473 g_captureWindow = NULL;
474 return;
475 }
476
477 m_winCaptured = TRUE;
478 }
479 }
480
481 void wxWindowX11::DoReleaseMouse()
482 {
483 g_captureWindow = NULL;
484
485 if ( !m_winCaptured )
486 return;
487
488 Window xwindow = (Window) m_clientWindow;
489
490 if (xwindow)
491 {
492 XUngrabPointer( wxGlobalDisplay(), CurrentTime );
493 }
494
495 // wxLogDebug( "Ungrabbed pointer in %s", GetName().c_str() );
496
497 m_winCaptured = FALSE;
498 }
499
500 bool wxWindowX11::SetFont(const wxFont& font)
501 {
502 if ( !wxWindowBase::SetFont(font) )
503 {
504 // nothing to do
505 return FALSE;
506 }
507
508 return TRUE;
509 }
510
511 bool wxWindowX11::SetCursor(const wxCursor& cursor)
512 {
513 if ( !wxWindowBase::SetCursor(cursor) )
514 {
515 // no change
516 return FALSE;
517 }
518
519 Window xwindow = (Window) m_clientWindow;
520
521 wxCHECK_MSG( xwindow, FALSE, wxT("invalid window") );
522
523 wxCursor cursorToUse;
524 if (m_cursor.Ok())
525 cursorToUse = m_cursor;
526 else
527 cursorToUse = *wxSTANDARD_CURSOR;
528
529 Cursor xcursor = (Cursor) cursorToUse.GetCursor();
530
531 XDefineCursor( wxGlobalDisplay(), xwindow, xcursor );
532
533 return TRUE;
534 }
535
536 // Coordinates relative to the window
537 void wxWindowX11::WarpPointer (int x, int y)
538 {
539 Window xwindow = (Window) m_clientWindow;
540
541 wxCHECK_RET( xwindow, wxT("invalid window") );
542
543 XWarpPointer( wxGlobalDisplay(), None, xwindow, 0, 0, 0, 0, x, y);
544 }
545
546 // Does a physical scroll
547 void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
548 {
549 // No scrolling requested.
550 if ((dx == 0) && (dy == 0)) return;
551
552 if (!m_updateRegion.IsEmpty())
553 {
554 m_updateRegion.Offset( dx, dy );
555
556 int cw = 0;
557 int ch = 0;
558 GetSize( &cw, &ch ); // GetClientSize() ??
559 m_updateRegion.Intersect( 0, 0, cw, ch );
560 }
561
562 if (!m_clearRegion.IsEmpty())
563 {
564 m_clearRegion.Offset( dx, dy );
565
566 int cw = 0;
567 int ch = 0;
568 GetSize( &cw, &ch ); // GetClientSize() ??
569 m_clearRegion.Intersect( 0, 0, cw, ch );
570 }
571
572 Window xwindow = (Window) GetClientWindow();
573
574 wxCHECK_RET( xwindow, wxT("invalid window") );
575
576 Display *xdisplay = wxGlobalDisplay();
577
578 GC xgc = XCreateGC( xdisplay, xwindow, 0, NULL );
579 XSetGraphicsExposures( xdisplay, xgc, True );
580
581 int s_x = 0;
582 int s_y = 0;
583 int cw;
584 int ch;
585 if (rect)
586 {
587 s_x = rect->x;
588 s_y = rect->y;
589
590 cw = rect->width;
591 ch = rect->height;
592 }
593 else
594 {
595 s_x = 0;
596 s_y = 0;
597 GetClientSize( &cw, &ch );
598 }
599
600 #if wxUSE_TWO_WINDOWS
601 wxPoint offset( 0,0 );
602 #else
603 wxPoint offset = GetClientAreaOrigin();
604 s_x += offset.x;
605 s_y += offset.y;
606 #endif
607
608 int w = cw - abs(dx);
609 int h = ch - abs(dy);
610
611 if ((h < 0) || (w < 0))
612 {
613 Refresh();
614 }
615 else
616 {
617 wxRect rect;
618 if (dx < 0) rect.x = cw+dx + offset.x; else rect.x = s_x;
619 if (dy < 0) rect.y = ch+dy + offset.y; else rect.y = s_y;
620 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
621 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
622
623 int d_x = s_x;
624 int d_y = s_y;
625
626 if (dx < 0) s_x += -dx;
627 if (dy < 0) s_y += -dy;
628 if (dx > 0) d_x = dx + offset.x;
629 if (dy > 0) d_y = dy + offset.y;
630
631 XCopyArea( xdisplay, xwindow, xwindow, xgc, s_x, s_y, w, h, d_x, d_y );
632
633 // wxLogDebug( "Copy: s_x %d s_y %d w %d h %d d_x %d d_y %d", s_x, s_y, w, h, d_x, d_y );
634
635 // wxLogDebug( "Update: %d %d %d %d", rect.x, rect.y, rect.width, rect.height );
636
637 m_updateRegion.Union( rect );
638 m_clearRegion.Union( rect );
639 }
640
641 XFreeGC( xdisplay, xgc );
642 }
643
644 // ---------------------------------------------------------------------------
645 // drag and drop
646 // ---------------------------------------------------------------------------
647
648 #if wxUSE_DRAG_AND_DROP
649
650 void wxWindowX11::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
651 {
652 // TODO
653 }
654
655 #endif
656
657 // Old style file-manager drag&drop
658 void wxWindowX11::DragAcceptFiles(bool WXUNUSED(accept))
659 {
660 // TODO
661 }
662
663 // ----------------------------------------------------------------------------
664 // tooltips
665 // ----------------------------------------------------------------------------
666
667 #if wxUSE_TOOLTIPS
668
669 void wxWindowX11::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
670 {
671 // TODO
672 }
673
674 #endif // wxUSE_TOOLTIPS
675
676 // ---------------------------------------------------------------------------
677 // moving and resizing
678 // ---------------------------------------------------------------------------
679
680 bool wxWindowX11::PreResize()
681 {
682 return TRUE;
683 }
684
685 // Get total size
686 void wxWindowX11::DoGetSize(int *x, int *y) const
687 {
688 Window xwindow = (Window) m_mainWindow;
689
690 wxCHECK_RET( xwindow, wxT("invalid window") );
691
692 //XSync(wxGlobalDisplay(), False);
693
694 XWindowAttributes attr;
695 Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
696 wxASSERT(status);
697
698 if (status)
699 {
700 *x = attr.width /* + 2*m_borderSize */ ;
701 *y = attr.height /* + 2*m_borderSize */ ;
702 }
703 }
704
705 void wxWindowX11::DoGetPosition(int *x, int *y) const
706 {
707 Window window = (Window) m_mainWindow;
708 if (window)
709 {
710 //XSync(wxGlobalDisplay(), False);
711 XWindowAttributes attr;
712 Status status = XGetWindowAttributes(wxGlobalDisplay(), window, & attr);
713 wxASSERT(status);
714
715 if (status)
716 {
717 *x = attr.x;
718 *y = attr.y;
719
720 // We may be faking the client origin. So a window that's really at (0, 30)
721 // may appear (to wxWin apps) to be at (0, 0).
722 if (GetParent())
723 {
724 wxPoint pt(GetParent()->GetClientAreaOrigin());
725 *x -= pt.x;
726 *y -= pt.y;
727 }
728 }
729 }
730 }
731
732 void wxWindowX11::DoScreenToClient(int *x, int *y) const
733 {
734 Display *display = wxGlobalDisplay();
735 Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
736 Window thisWindow = (Window) m_clientWindow;
737
738 Window childWindow;
739 int xx = *x;
740 int yy = *y;
741 XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
742 }
743
744 void wxWindowX11::DoClientToScreen(int *x, int *y) const
745 {
746 Display *display = wxGlobalDisplay();
747 Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
748 Window thisWindow = (Window) m_clientWindow;
749
750 Window childWindow;
751 int xx = *x;
752 int yy = *y;
753 XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
754 }
755
756
757 // Get size *available for subwindows* i.e. excluding menu bar etc.
758 void wxWindowX11::DoGetClientSize(int *x, int *y) const
759 {
760 Window window = (Window) m_mainWindow;
761
762 if (window)
763 {
764 XWindowAttributes attr;
765 Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
766 wxASSERT(status);
767
768 if (status)
769 {
770 *x = attr.width ;
771 *y = attr.height ;
772 }
773 }
774 }
775
776 void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
777 {
778 // wxLogDebug("DoSetSize: %s (%ld) %d, %d %dx%d", GetClassInfo()->GetClassName(), GetId(), x, y, width, height);
779
780 Window xwindow = (Window) m_mainWindow;
781
782 wxCHECK_RET( xwindow, wxT("invalid window") );
783
784 XWindowAttributes attr;
785 Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
786 wxCHECK_RET( status, wxT("invalid window attributes") );
787
788 int new_x = attr.x;
789 int new_y = attr.y;
790 int new_w = attr.width;
791 int new_h = attr.height;
792
793 if (x != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
794 {
795 int yy = 0;
796 AdjustForParentClientOrigin( x, yy, sizeFlags);
797 new_x = x;
798 }
799 if (y != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
800 {
801 int xx = 0;
802 AdjustForParentClientOrigin( xx, y, sizeFlags);
803 new_y = y;
804 }
805 if (width != -1)
806 {
807 new_w = width;
808 if (new_w <= 0)
809 new_w = 20;
810 }
811 if (height != -1)
812 {
813 new_h = height;
814 if (new_h <= 0)
815 new_h = 20;
816 }
817
818 DoMoveWindow( new_x, new_y, new_w, new_h );
819
820 #if 0
821 wxSizeEvent event(wxSize(new_w, new_h), GetId());
822 event.SetEventObject(this);
823 GetEventHandler()->ProcessEvent(event);
824 #endif
825 }
826
827 void wxWindowX11::DoSetClientSize(int width, int height)
828 {
829 // wxLogDebug("DoSetClientSize: %s (%ld) %dx%d", GetClassInfo()->GetClassName(), GetId(), width, height);
830
831 Window xwindow = (Window) m_mainWindow;
832
833 wxCHECK_RET( xwindow, wxT("invalid window") );
834
835 XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
836
837 if (m_mainWindow != m_clientWindow)
838 {
839 xwindow = (Window) m_clientWindow;
840
841 if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
842 {
843 width -= 4;
844 height -= 4;
845 } else
846 if (HasFlag( wxSIMPLE_BORDER ))
847 {
848 width -= 2;
849 height -= 2;
850 }
851
852 XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
853 }
854 }
855
856 // For implementation purposes - sometimes decorations make the client area
857 // smaller
858 wxPoint wxWindowX11::GetClientAreaOrigin() const
859 {
860 return wxPoint(0, 0);
861 }
862
863 void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
864 {
865 Window xwindow = (Window) m_mainWindow;
866
867 wxCHECK_RET( xwindow, wxT("invalid window") );
868
869 #if !wxUSE_NANOX
870
871 XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
872 if (m_mainWindow != m_clientWindow)
873 {
874 xwindow = (Window) m_clientWindow;
875
876 if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
877 {
878 x = 2;
879 y = 2;
880 width -= 4;
881 height -= 4;
882 } else
883 if (HasFlag( wxSIMPLE_BORDER ))
884 {
885 x = 1;
886 y = 1;
887 width -= 2;
888 height -= 2;
889 } else
890 {
891 x = 0;
892 y = 0;
893 }
894
895 wxWindow *window = (wxWindow*) this;
896 wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
897 if (sb && sb->IsShown())
898 {
899 wxSize size = sb->GetSize();
900 height -= size.y;
901 }
902 sb = window->GetScrollbar( wxVERTICAL );
903 if (sb && sb->IsShown())
904 {
905 wxSize size = sb->GetSize();
906 width -= size.x;
907 }
908
909 XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
910 }
911
912 #else
913
914 XWindowChanges windowChanges;
915 windowChanges.x = x;
916 windowChanges.y = y;
917 windowChanges.width = width;
918 windowChanges.height = height;
919 windowChanges.stack_mode = 0;
920 int valueMask = CWX | CWY | CWWidth | CWHeight;
921
922 XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
923
924 #endif
925 }
926
927 void wxWindowX11::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
928 {
929 m_minWidth = minW;
930 m_minHeight = minH;
931 m_maxWidth = maxW;
932 m_maxHeight = maxH;
933
934 #if !wxUSE_NANOX
935 XSizeHints sizeHints;
936 sizeHints.flags = 0;
937
938 if (minW > -1 && minH > -1)
939 {
940 sizeHints.flags |= PMinSize;
941 sizeHints.min_width = minW;
942 sizeHints.min_height = minH;
943 }
944 if (maxW > -1 && maxH > -1)
945 {
946 sizeHints.flags |= PMaxSize;
947 sizeHints.max_width = maxW;
948 sizeHints.max_height = maxH;
949 }
950 if (incW > -1 && incH > -1)
951 {
952 sizeHints.flags |= PResizeInc;
953 sizeHints.width_inc = incW;
954 sizeHints.height_inc = incH;
955 }
956
957 XSetWMNormalHints(wxGlobalDisplay(), (Window) m_mainWindow, &sizeHints );
958 #endif
959 }
960
961 // ---------------------------------------------------------------------------
962 // text metrics
963 // ---------------------------------------------------------------------------
964
965 int wxWindowX11::GetCharHeight() const
966 {
967 wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
968
969 WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, wxGlobalDisplay());
970
971 int direction, ascent, descent;
972 XCharStruct overall;
973 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
974 &descent, &overall);
975
976 // return (overall.ascent + overall.descent);
977 return (ascent + descent);
978 }
979
980 int wxWindowX11::GetCharWidth() const
981 {
982 wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
983
984 WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, wxGlobalDisplay());
985
986 int direction, ascent, descent;
987 XCharStruct overall;
988 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
989 &descent, &overall);
990
991 return overall.width;
992 }
993
994 void wxWindowX11::GetTextExtent(const wxString& string,
995 int *x, int *y,
996 int *descent, int *externalLeading,
997 const wxFont *theFont) const
998 {
999 wxFont fontToUse = m_font;
1000 if (theFont) fontToUse = *theFont;
1001
1002 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
1003
1004 WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
1005
1006 int direction, ascent, descent2;
1007 XCharStruct overall;
1008 int slen = string.Len();
1009
1010 #if 0
1011 if (use16)
1012 XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
1013 &ascent, &descent2, &overall);
1014 #endif
1015
1016 XTextExtents((XFontStruct*) pFontStruct, (char*) string.c_str(), slen,
1017 &direction, &ascent, &descent2, &overall);
1018
1019 if ( x )
1020 *x = (overall.width);
1021 if ( y )
1022 *y = (ascent + descent2);
1023 if (descent)
1024 *descent = descent2;
1025 if (externalLeading)
1026 *externalLeading = 0;
1027
1028 }
1029
1030 // ----------------------------------------------------------------------------
1031 // painting
1032 // ----------------------------------------------------------------------------
1033
1034 void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
1035 {
1036 if (eraseBack)
1037 {
1038 if (rect)
1039 {
1040 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1041 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
1042 }
1043 else
1044 {
1045 int height,width;
1046 GetSize( &width, &height );
1047
1048 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1049 m_clearRegion.Clear();
1050 m_clearRegion.Union( 0, 0, width, height );
1051 }
1052 }
1053
1054 if (rect)
1055 {
1056 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1057 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
1058 }
1059 else
1060 {
1061 int height,width;
1062 GetSize( &width, &height );
1063
1064 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1065 m_updateRegion.Clear();
1066 m_updateRegion.Union( 0, 0, width, height );
1067 }
1068 }
1069
1070 void wxWindowX11::Update()
1071 {
1072 if (m_updateNcArea)
1073 {
1074 // wxLogDebug("wxWindowX11::UpdateNC: %s", GetClassInfo()->GetClassName());
1075 // Send nc paint events.
1076 SendNcPaintEvents();
1077 }
1078
1079 if (!m_updateRegion.IsEmpty())
1080 {
1081 // wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
1082 // Actually send erase events.
1083 SendEraseEvents();
1084
1085 // Actually send paint events.
1086 SendPaintEvents();
1087 }
1088 }
1089
1090 void wxWindowX11::Clear()
1091 {
1092 // wxClientDC dc((wxWindow*) this);
1093 // wxBrush brush(GetBackgroundColour(), wxSOLID);
1094 // dc.SetBackground(brush);
1095 // dc.Clear();
1096 }
1097
1098 void wxWindowX11::SendEraseEvents()
1099 {
1100 if (m_clearRegion.IsEmpty()) return;
1101
1102 wxClientDC dc( (wxWindow*)this );
1103 dc.SetClippingRegion( m_clearRegion );
1104
1105 wxEraseEvent erase_event( GetId(), &dc );
1106 erase_event.SetEventObject( this );
1107
1108 if (!GetEventHandler()->ProcessEvent(erase_event))
1109 {
1110 Window xwindow = (Window) m_clientWindow;
1111 Display *xdisplay = wxGlobalDisplay();
1112 GC xgc = XCreateGC( xdisplay, xwindow, 0, NULL );
1113 XSetFillStyle( xdisplay, xgc, FillSolid );
1114 XSetForeground( xdisplay, xgc, m_backgroundColour.GetPixel() );
1115 wxRegionIterator upd( m_clearRegion );
1116 while (upd)
1117 {
1118 XFillRectangle( xdisplay, xwindow, xgc,
1119 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
1120 upd ++;
1121 }
1122 XFreeGC( xdisplay, xgc );
1123 }
1124
1125 m_clearRegion.Clear();
1126 }
1127
1128 void wxWindowX11::SendPaintEvents()
1129 {
1130 // wxLogDebug("SendPaintEvents: %s (%ld)", GetClassInfo()->GetClassName(), GetId());
1131
1132 m_clipPaintRegion = TRUE;
1133
1134 wxPaintEvent paint_event( GetId() );
1135 paint_event.SetEventObject( this );
1136 GetEventHandler()->ProcessEvent( paint_event );
1137
1138 m_updateRegion.Clear();
1139
1140 m_clipPaintRegion = FALSE;
1141 }
1142
1143 void wxWindowX11::SendNcPaintEvents()
1144 {
1145 wxNcPaintEvent nc_paint_event( GetId() );
1146 nc_paint_event.SetEventObject( this );
1147 GetEventHandler()->ProcessEvent( nc_paint_event );
1148
1149 m_updateNcArea = FALSE;
1150 }
1151
1152 // ----------------------------------------------------------------------------
1153 // event handlers
1154 // ----------------------------------------------------------------------------
1155
1156 // Responds to colour changes: passes event on to children.
1157 void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)
1158 {
1159 wxWindowList::Node *node = GetChildren().GetFirst();
1160 while ( node )
1161 {
1162 // Only propagate to non-top-level windows
1163 wxWindow *win = node->GetData();
1164 if ( win->GetParent() )
1165 {
1166 wxSysColourChangedEvent event2;
1167 event.m_eventObject = win;
1168 win->GetEventHandler()->ProcessEvent(event2);
1169 }
1170
1171 node = node->GetNext();
1172 }
1173 }
1174
1175 void wxWindowX11::OnInternalIdle()
1176 {
1177 // Update invalidated regions.
1178 Update();
1179
1180 // This calls the UI-update mechanism (querying windows for
1181 // menu/toolbar/control state information)
1182 UpdateWindowUI();
1183
1184 // Set the input focus if couldn't do it before
1185 if (m_needsInputFocus)
1186 {
1187 SetFocus();
1188 }
1189 }
1190
1191 // ----------------------------------------------------------------------------
1192 // function which maintain the global hash table mapping Widgets to wxWindows
1193 // ----------------------------------------------------------------------------
1194
1195 bool wxAddWindowToTable(Window w, wxWindow *win)
1196 {
1197 wxWindow *oldItem = NULL;
1198 if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
1199 {
1200 wxLogDebug("Widget table clash: new widget is %ld, %s",
1201 (long)w, win->GetClassInfo()->GetClassName());
1202 return FALSE;
1203 }
1204
1205 wxWidgetHashTable->Put((long) w, win);
1206
1207 wxLogTrace("widget", "XWindow 0x%08x <-> window %p (%s)",
1208 w, win, win->GetClassInfo()->GetClassName());
1209
1210 return TRUE;
1211 }
1212
1213 wxWindow *wxGetWindowFromTable(Window w)
1214 {
1215 return (wxWindow *)wxWidgetHashTable->Get((long) w);
1216 }
1217
1218 void wxDeleteWindowFromTable(Window w)
1219 {
1220 wxWidgetHashTable->Delete((long)w);
1221 }
1222
1223 // ----------------------------------------------------------------------------
1224 // function which maintain the global hash table mapping client widgets
1225 // ----------------------------------------------------------------------------
1226
1227 bool wxAddClientWindowToTable(Window w, wxWindow *win)
1228 {
1229 wxWindow *oldItem = NULL;
1230 if ((oldItem = (wxWindow *)wxClientWidgetHashTable->Get ((long) w)))
1231 {
1232 wxLogDebug("Client window table clash: new window is %ld, %s",
1233 (long)w, win->GetClassInfo()->GetClassName());
1234 return FALSE;
1235 }
1236
1237 wxClientWidgetHashTable->Put((long) w, win);
1238
1239 wxLogTrace("widget", "XWindow 0x%08x <-> window %p (%s)",
1240 w, win, win->GetClassInfo()->GetClassName());
1241
1242 return TRUE;
1243 }
1244
1245 wxWindow *wxGetClientWindowFromTable(Window w)
1246 {
1247 return (wxWindow *)wxClientWidgetHashTable->Get((long) w);
1248 }
1249
1250 void wxDeleteClientWindowFromTable(Window w)
1251 {
1252 wxClientWidgetHashTable->Delete((long)w);
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // add/remove window from the table
1257 // ----------------------------------------------------------------------------
1258
1259 // ----------------------------------------------------------------------------
1260 // X11-specific accessors
1261 // ----------------------------------------------------------------------------
1262
1263 WXWindow wxWindowX11::GetMainWindow() const
1264 {
1265 return m_mainWindow;
1266 }
1267
1268 WXWindow wxWindowX11::GetClientWindow() const
1269 {
1270 return m_clientWindow;
1271 }
1272
1273 // ----------------------------------------------------------------------------
1274 // TranslateXXXEvent() functions
1275 // ----------------------------------------------------------------------------
1276
1277 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Window window, XEvent *xevent)
1278 {
1279 switch (XEventGetType(xevent))
1280 {
1281 case EnterNotify:
1282 case LeaveNotify:
1283 case ButtonPress:
1284 case ButtonRelease:
1285 case MotionNotify:
1286 {
1287 wxEventType eventType = wxEVT_NULL;
1288
1289 if (XEventGetType(xevent) == EnterNotify)
1290 {
1291 //if (local_event.xcrossing.mode!=NotifyNormal)
1292 // return ; // Ignore grab events
1293 eventType = wxEVT_ENTER_WINDOW;
1294 // canvas->GetEventHandler()->OnSetFocus();
1295 }
1296 else if (XEventGetType(xevent) == LeaveNotify)
1297 {
1298 //if (local_event.xcrossingr.mode!=NotifyNormal)
1299 // return ; // Ignore grab events
1300 eventType = wxEVT_LEAVE_WINDOW;
1301 // canvas->GetEventHandler()->OnKillFocus();
1302 }
1303 else if (XEventGetType(xevent) == MotionNotify)
1304 {
1305 eventType = wxEVT_MOTION;
1306 }
1307 else if (XEventGetType(xevent) == ButtonPress)
1308 {
1309 wxevent.SetTimestamp(XButtonEventGetTime(xevent));
1310 int button = 0;
1311 if (XButtonEventLChanged(xevent))
1312 {
1313 eventType = wxEVT_LEFT_DOWN;
1314 button = 1;
1315 }
1316 else if (XButtonEventMChanged(xevent))
1317 {
1318 eventType = wxEVT_MIDDLE_DOWN;
1319 button = 2;
1320 }
1321 else if (XButtonEventRChanged(xevent))
1322 {
1323 eventType = wxEVT_RIGHT_DOWN;
1324 button = 3;
1325 }
1326
1327 // check for a double click
1328 // TODO: where can we get this value from?
1329 //long dclickTime = XtGetMultiClickTime(wxGlobalDisplay());
1330 long dclickTime = 200;
1331 long ts = wxevent.GetTimestamp();
1332
1333 int buttonLast = win->GetLastClickedButton();
1334 long lastTS = win->GetLastClickTime();
1335 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
1336 {
1337 // I have a dclick
1338 win->SetLastClick(0, ts);
1339 if ( eventType == wxEVT_LEFT_DOWN )
1340 eventType = wxEVT_LEFT_DCLICK;
1341 else if ( eventType == wxEVT_MIDDLE_DOWN )
1342 eventType = wxEVT_MIDDLE_DCLICK;
1343 else if ( eventType == wxEVT_RIGHT_DOWN )
1344 eventType = wxEVT_RIGHT_DCLICK;
1345 }
1346 else
1347 {
1348 // not fast enough or different button
1349 win->SetLastClick(button, ts);
1350 }
1351 }
1352 else if (XEventGetType(xevent) == ButtonRelease)
1353 {
1354 if (XButtonEventLChanged(xevent))
1355 {
1356 eventType = wxEVT_LEFT_UP;
1357 }
1358 else if (XButtonEventMChanged(xevent))
1359 {
1360 eventType = wxEVT_MIDDLE_UP;
1361 }
1362 else if (XButtonEventRChanged(xevent))
1363 {
1364 eventType = wxEVT_RIGHT_UP;
1365 }
1366 else return FALSE;
1367 }
1368 else
1369 {
1370 return FALSE;
1371 }
1372
1373 wxevent.SetEventType(eventType);
1374
1375 wxevent.m_x = XButtonEventGetX(xevent);
1376 wxevent.m_y = XButtonEventGetY(xevent);
1377
1378 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
1379 || (XButtonEventLIsDown(xevent)
1380 && (eventType != wxEVT_LEFT_UP)));
1381 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
1382 || (XButtonEventMIsDown(xevent)
1383 && (eventType != wxEVT_MIDDLE_UP)));
1384 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
1385 || (XButtonEventRIsDown (xevent)
1386 && (eventType != wxEVT_RIGHT_UP)));
1387
1388 wxevent.m_shiftDown = XButtonEventShiftIsDown(xevent);
1389 wxevent.m_controlDown = XButtonEventCtrlIsDown(xevent);
1390 wxevent.m_altDown = XButtonEventAltIsDown(xevent);
1391 wxevent.m_metaDown = XButtonEventMetaIsDown(xevent);
1392
1393 wxevent.SetId(win->GetId());
1394 wxevent.SetEventObject(win);
1395
1396 return TRUE;
1397 }
1398 }
1399 return FALSE;
1400 }
1401
1402 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win), XEvent *xevent)
1403 {
1404 switch (XEventGetType(xevent))
1405 {
1406 case KeyPress:
1407 case KeyRelease:
1408 {
1409 char buf[20];
1410
1411 KeySym keySym;
1412 (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
1413 int id = wxCharCodeXToWX (keySym);
1414
1415 wxevent.m_shiftDown = XKeyEventShiftIsDown(xevent);
1416 wxevent.m_controlDown = XKeyEventCtrlIsDown(xevent);
1417 wxevent.m_altDown = XKeyEventAltIsDown(xevent);
1418 wxevent.m_metaDown = XKeyEventMetaIsDown(xevent);
1419 wxevent.SetEventObject(win);
1420 wxevent.m_keyCode = id;
1421 wxevent.SetTimestamp(XKeyEventGetTime(xevent));
1422
1423 wxevent.m_x = XKeyEventGetX(xevent);
1424 wxevent.m_y = XKeyEventGetY(xevent);
1425
1426 if (id > -1)
1427 return TRUE;
1428 else
1429 return FALSE;
1430 break;
1431 }
1432 default:
1433 break;
1434 }
1435 return FALSE;
1436 }
1437
1438 // ----------------------------------------------------------------------------
1439 // Colour stuff
1440 // ----------------------------------------------------------------------------
1441
1442 bool wxWindowX11::SetBackgroundColour(const wxColour& col)
1443 {
1444 wxWindowBase::SetBackgroundColour(col);
1445
1446 Display *xdisplay = (Display*) wxGlobalDisplay();
1447 int xscreen = DefaultScreen( xdisplay );
1448 Colormap cm = DefaultColormap( xdisplay, xscreen );
1449
1450 m_backgroundColour.CalcPixel( (WXColormap) cm );
1451
1452 if (!GetMainWindow())
1453 return FALSE;
1454
1455 /*
1456 XSetWindowAttributes attrib;
1457 attrib.background_pixel = colour.GetPixel();
1458
1459 XChangeWindowAttributes(wxGlobalDisplay(),
1460 (Window) GetMainWindow(),
1461 CWBackPixel,
1462 & attrib);
1463 */
1464
1465 return TRUE;
1466 }
1467
1468 bool wxWindowX11::SetForegroundColour(const wxColour& col)
1469 {
1470 if ( !wxWindowBase::SetForegroundColour(col) )
1471 return FALSE;
1472
1473 return TRUE;
1474 }
1475
1476 // ----------------------------------------------------------------------------
1477 // global functions
1478 // ----------------------------------------------------------------------------
1479
1480 wxWindow *wxGetActiveWindow()
1481 {
1482 // TODO
1483 wxFAIL_MSG("Not implemented");
1484 return NULL;
1485 }
1486
1487 /* static */
1488 wxWindow *wxWindowBase::GetCapture()
1489 {
1490 return (wxWindow *)g_captureWindow;
1491 }
1492
1493
1494 // Find the wxWindow at the current mouse position, returning the mouse
1495 // position.
1496 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1497 {
1498 return wxFindWindowAtPoint(wxGetMousePosition());
1499 }
1500
1501 // Get the current mouse position.
1502 wxPoint wxGetMousePosition()
1503 {
1504 #if wxUSE_NANOX
1505 /* TODO */
1506 return wxPoint(0, 0);
1507 #else
1508 Display *display = wxGlobalDisplay();
1509 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
1510 Window rootReturn, childReturn;
1511 int rootX, rootY, winX, winY;
1512 unsigned int maskReturn;
1513
1514 XQueryPointer (display,
1515 rootWindow,
1516 &rootReturn,
1517 &childReturn,
1518 &rootX, &rootY, &winX, &winY, &maskReturn);
1519 return wxPoint(rootX, rootY);
1520 #endif
1521 }
1522
1523
1524 // ----------------------------------------------------------------------------
1525 // wxNoOptimize: switch off size optimization
1526 // ----------------------------------------------------------------------------
1527
1528 int wxNoOptimize::ms_count = 0;
1529