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