]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/toplevel.cpp
projects / wxWidgets.git / blob
? search:


3ee1c1efe072e3e0ca6717ea4a9aa036893cb2c2
[wxWidgets.git] / src / gtk / toplevel.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/toplevel.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 // ============================================================================
14 // declarations
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 #ifdef __VMS
22 #define XIconifyWindow XICONIFYWINDOW
23 #endif
24
25 #include "wx/toplevel.h"
26
27 #ifndef WX_PRECOMP
28 #include "wx/frame.h"
29 #include "wx/icon.h"
30 #include "wx/log.h"
31 #include "wx/app.h"
32 #endif
33
34 #include "wx/gtk/private.h"
35 #include "wx/evtloop.h"
36
37 #include <gtk/gtk.h>
38 #include <gdk/gdkx.h>
39
40 #include "wx/gtk/win_gtk.h"
41
42 #include "wx/unix/utilsx11.h"
43
44 // XA_CARDINAL
45 #include <X11/Xatom.h>
46
47 // ----------------------------------------------------------------------------
48 // data
49 // ----------------------------------------------------------------------------
50
51 extern int g_openDialogs;
52 extern wxWindowGTK *g_delayedFocus;
53
54 // the frame that is currently active (i.e. its child has focus). It is
55 // used to generate wxActivateEvents
56 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
57 static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
58
59 // if we detect that the app has got/lost the focus, we set this variable to
60 // either TRUE or FALSE and an activate event will be sent during the next
61 // OnIdle() call and it is reset to -1: this value means that we shouldn't
62 // send any activate events at all
63 static int g_sendActivateEvent = -1;
64
65 //-----------------------------------------------------------------------------
66 // RequestUserAttention related functions
67 //-----------------------------------------------------------------------------
68
69 extern "C" {
70 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
71 gboolean setting)
72 {
73 wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
74 GdkWindow *window = GTK_WIDGET(win)->window;
75 XWMHints *wm_hints;
76
77 wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
78
79 if (!wm_hints)
80 wm_hints = XAllocWMHints();
81
82 if (setting)
83 wm_hints->flags |= XUrgencyHint;
84 else
85 wm_hints->flags &= ~XUrgencyHint;
86
87 XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
88 XFree(wm_hints);
89 }
90
91 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
92 {
93 #if GTK_CHECK_VERSION(2,7,0)
94 if(!gtk_check_version(2,7,0))
95 gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
96 else
97 #endif
98 wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
99
100 win->m_urgency_hint = -2;
101 return FALSE;
102 }
103 }
104
105 //-----------------------------------------------------------------------------
106 // "focus_in_event"
107 //-----------------------------------------------------------------------------
108
109 extern "C" {
110 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
111 GdkEvent *WXUNUSED(event),
112 wxTopLevelWindowGTK *win )
113 {
114 // don't need to install idle handler, its done from "event" signal
115
116 switch ( g_sendActivateEvent )
117 {
118 case -1:
119 // we've got focus from outside, synthetize wxActivateEvent
120 g_sendActivateEvent = 1;
121 break;
122
123 case 0:
124 // another our window just lost focus, it was already ours before
125 // - don't send any wxActivateEvent
126 g_sendActivateEvent = -1;
127 break;
128 }
129
130 g_activeFrame = win;
131 g_lastActiveFrame = g_activeFrame;
132
133 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
134
135 // MR: wxRequestUserAttention related block
136 switch( win->m_urgency_hint )
137 {
138 default:
139 g_source_remove( win->m_urgency_hint );
140 // no break, fallthrough to remove hint too
141 case -1:
142 #if GTK_CHECK_VERSION(2,7,0)
143 if(!gtk_check_version(2,7,0))
144 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
145 else
146 #endif
147 {
148 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
149 }
150
151 win->m_urgency_hint = -2;
152 break;
153
154 case -2: break;
155 }
156
157 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
158 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
159 event.SetEventObject(g_activeFrame);
160 g_activeFrame->GetEventHandler()->ProcessEvent(event);
161
162 return FALSE;
163 }
164 }
165
166 //-----------------------------------------------------------------------------
167 // "focus_out_event"
168 //-----------------------------------------------------------------------------
169
170 extern "C" {
171 static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
172 GdkEventFocus *WXUNUSED(gdk_event),
173 wxTopLevelWindowGTK *win )
174 {
175 // don't need to install idle handler, its done from "event" signal
176
177 // if the focus goes out of our app alltogether, OnIdle() will send
178 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
179 // g_sendActivateEvent to -1
180 g_sendActivateEvent = 0;
181
182 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
183
184 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
185
186 if (g_activeFrame)
187 {
188 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
189 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
190 event.SetEventObject(g_activeFrame);
191 g_activeFrame->GetEventHandler()->ProcessEvent(event);
192
193 g_activeFrame = NULL;
194 }
195
196 return FALSE;
197 }
198 }
199
200 //-----------------------------------------------------------------------------
201 // "focus" from m_window
202 //-----------------------------------------------------------------------------
203
204 extern "C" {
205 static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
206 {
207 if (g_isIdle)
208 wxapp_install_idle_handler();
209
210 // This disables GTK's tab traversal
211 return TRUE;
212 }
213 }
214
215 //-----------------------------------------------------------------------------
216 // "size_allocate"
217 //-----------------------------------------------------------------------------
218
219 extern "C" {
220 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
221 {
222 if (g_isIdle)
223 wxapp_install_idle_handler();
224
225 if (!win->m_hasVMT)
226 return;
227
228 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
229 {
230 /*
231 wxPrintf( wxT("gtk_frame_size_callback from ") );
232 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
233 wxPrintf( win->GetClassInfo()->GetClassName() );
234 wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
235 (int)alloc->y,
236 (int)alloc->width,
237 (int)alloc->height );
238 */
239
240 win->m_width = alloc->width;
241 win->m_height = alloc->height;
242 win->GtkUpdateSize();
243 }
244 }
245 }
246
247 //-----------------------------------------------------------------------------
248 // "delete_event"
249 //-----------------------------------------------------------------------------
250
251 extern "C" {
252 static gboolean
253 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
254 GdkEvent *WXUNUSED(event),
255 wxTopLevelWindowGTK *win )
256 {
257 // don't need to install idle handler, its done from "event" signal
258
259 if (win->IsEnabled() &&
260 (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
261 win->IsGrabbed()))
262 win->Close();
263
264 return TRUE;
265 }
266 }
267
268
269 //-----------------------------------------------------------------------------
270 // "configure_event"
271 //-----------------------------------------------------------------------------
272
273 extern "C" {
274 static gboolean
275 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
276 GdkEventConfigure *WXUNUSED(event),
277 wxTopLevelWindowGTK *win )
278 {
279 // don't need to install idle handler, its done from "event" signal
280
281 if (!win->m_hasVMT || !win->IsShown())
282 return FALSE;
283
284
285 int x = 0;
286 int y = 0;
287 gdk_window_get_root_origin( win->m_widget->window, &x, &y );
288 win->m_x = x;
289 win->m_y = y;
290
291 wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
292 mevent.SetEventObject( win );
293 win->GetEventHandler()->ProcessEvent( mevent );
294
295 return FALSE;
296 }
297 }
298
299 //-----------------------------------------------------------------------------
300 // "realize" from m_widget
301 //-----------------------------------------------------------------------------
302
303 // we cannot MWM hints and icons before the widget has been realized,
304 // so we do this directly after realization
305
306 extern "C" {
307 static void
308 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
309 wxTopLevelWindowGTK *win )
310 {
311 if (g_isIdle)
312 wxapp_install_idle_handler();
313
314 // All this is for Motif Window Manager "hints" and is supposed to be
315 // recognized by other WM as well. Not tested.
316 gdk_window_set_decorations(win->m_widget->window,
317 (GdkWMDecoration)win->m_gdkDecor);
318 gdk_window_set_functions(win->m_widget->window,
319 (GdkWMFunction)win->m_gdkFunc);
320
321 // GTK's shrinking/growing policy
322 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
323 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
324 else
325 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
326
327 // reset the icon
328 wxIconBundle iconsOld = win->GetIcons();
329 if ( iconsOld.GetIcon(-1).Ok() )
330 {
331 win->SetIcon( wxNullIcon );
332 win->SetIcons( iconsOld );
333 }
334 }
335 }
336
337 //-----------------------------------------------------------------------------
338 // "map_event" from m_widget
339 //-----------------------------------------------------------------------------
340
341 extern "C" {
342 static void
343 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
344 GdkEvent * WXUNUSED(event),
345 wxTopLevelWindow *win )
346 {
347 win->SetIconizeState(false);
348 }
349 }
350
351 //-----------------------------------------------------------------------------
352 // "unmap_event" from m_widget
353 //-----------------------------------------------------------------------------
354
355 extern "C" {
356 static void
357 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
358 GdkEvent * WXUNUSED(event),
359 wxTopLevelWindow *win )
360 {
361 win->SetIconizeState(true);
362 }
363 }
364
365 //-----------------------------------------------------------------------------
366 // "expose_event" of m_client
367 //-----------------------------------------------------------------------------
368
369 extern "C" {
370 static gboolean
371 gtk_window_expose_callback( GtkWidget *widget,
372 GdkEventExpose *gdk_event,
373 wxWindow *win )
374 {
375 GtkPizza *pizza = GTK_PIZZA(widget);
376
377 gtk_paint_flat_box (win->m_widget->style,
378 pizza->bin_window, GTK_STATE_NORMAL,
379 GTK_SHADOW_NONE,
380 &gdk_event->area,
381 win->m_widget,
382 (char *)"base",
383 0, 0, -1, -1);
384
385 return FALSE;
386 }
387 }
388
389 // ----------------------------------------------------------------------------
390 // wxTopLevelWindowGTK itself
391 // ----------------------------------------------------------------------------
392
393 //-----------------------------------------------------------------------------
394 // InsertChild for wxTopLevelWindowGTK
395 //-----------------------------------------------------------------------------
396
397 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
398 * C++ has no virtual methods in a constructor. We have to emulate a
399 * virtual function here as wxWidgets requires different ways to insert
400 * a child in container classes. */
401
402 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
403 {
404 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
405
406 if (!parent->m_insertInClientArea)
407 {
408 // these are outside the client area
409 wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
410 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
411 GTK_WIDGET(child->m_widget),
412 child->m_x,
413 child->m_y,
414 child->m_width,
415 child->m_height );
416 }
417 else
418 {
419 // these are inside the client area
420 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
421 GTK_WIDGET(child->m_widget),
422 child->m_x,
423 child->m_y,
424 child->m_width,
425 child->m_height );
426 }
427 }
428
429 // ----------------------------------------------------------------------------
430 // wxTopLevelWindowGTK creation
431 // ----------------------------------------------------------------------------
432
433 void wxTopLevelWindowGTK::Init()
434 {
435 m_sizeSet = false;
436 m_miniEdge = 0;
437 m_miniTitle = 0;
438 m_mainWidget = (GtkWidget*) NULL;
439 m_insertInClientArea = true;
440 m_isIconized = false;
441 m_fsIsShowing = false;
442 m_themeEnabled = true;
443 m_gdkDecor = m_gdkFunc = 0;
444 m_grabbed = false;
445
446 m_urgency_hint = -2;
447 }
448
449 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
450 wxWindowID id,
451 const wxString& title,
452 const wxPoint& pos,
453 const wxSize& sizeOrig,
454 long style,
455 const wxString &name )
456 {
457 // always create a frame of some reasonable, even if arbitrary, size (at
458 // least for MSW compatibility)
459 wxSize size = sizeOrig;
460 size.x = WidthDefault(size.x);
461 size.y = HeightDefault(size.y);
462
463 wxTopLevelWindows.Append( this );
464
465 m_needParent = false;
466
467 if (!PreCreation( parent, pos, size ) ||
468 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
469 {
470 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
471 return false;
472 }
473
474 m_title = title;
475
476 m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
477
478 // NB: m_widget may be !=NULL if it was created by derived class' Create,
479 // e.g. in wxTaskBarIconAreaGTK
480 if (m_widget == NULL)
481 {
482 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
483 {
484 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
485 // Tell WM that this is a dialog window and make it center
486 // on parent by default (this is what GtkDialog ctor does):
487 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
488 GDK_WINDOW_TYPE_HINT_DIALOG);
489 gtk_window_set_position(GTK_WINDOW(m_widget),
490 GTK_WIN_POS_CENTER_ON_PARENT);
491 }
492 else
493 {
494 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
495 #if GTK_CHECK_VERSION(2,1,0)
496 if (!gtk_check_version(2,1,0))
497 {
498 if (style & wxFRAME_TOOL_WINDOW)
499 {
500 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
501 GDK_WINDOW_TYPE_HINT_UTILITY);
502
503 // On some WMs, like KDE, a TOOL_WINDOW will still show
504 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
505 // For consistency between WMs and with Windows, we
506 // should set the NO_TASKBAR flag which will apply
507 // the set_skip_taskbar_hint if it is available,
508 // ensuring no taskbar entry will appear.
509 style |= wxFRAME_NO_TASKBAR;
510 }
511 }
512 #endif
513 }
514 }
515
516 wxWindow *topParent = wxGetTopLevelParent(m_parent);
517 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
518 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
519 (style & wxFRAME_FLOAT_ON_PARENT)))
520 {
521 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
522 GTK_WINDOW(topParent->m_widget) );
523 }
524
525 #if GTK_CHECK_VERSION(2,2,0)
526 if (!gtk_check_version(2,2,0))
527 {
528 if (style & wxFRAME_NO_TASKBAR)
529 {
530 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
531 }
532 }
533 #endif
534
535 #ifdef __WXGTK24__
536 if (!gtk_check_version(2,4,0))
537 {
538 if (style & wxSTAY_ON_TOP)
539 {
540 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
541 }
542 }
543 #endif
544
545 #if 0
546 if (!name.empty())
547 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
548 #endif
549
550 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
551 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
552
553 g_signal_connect (m_widget, "delete_event",
554 G_CALLBACK (gtk_frame_delete_callback), this);
555
556 // m_mainWidget holds the toolbar, the menubar and the client area
557 m_mainWidget = gtk_pizza_new();
558 gtk_widget_show( m_mainWidget );
559 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
560 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
561
562 if (m_miniEdge == 0) // wxMiniFrame has its own version.
563 {
564 // For m_mainWidget themes
565 g_signal_connect (m_mainWidget, "expose_event",
566 G_CALLBACK (gtk_window_expose_callback), this);
567 }
568
569 // m_wxwindow only represents the client area without toolbar and menubar
570 m_wxwindow = gtk_pizza_new();
571 gtk_widget_show( m_wxwindow );
572 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
573
574 // we donm't allow the frame to get the focus as otherwise
575 // the frame will grab it at arbitrary focus changes
576 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
577
578 if (m_parent) m_parent->AddChild( this );
579
580 // the user resized the frame by dragging etc.
581 g_signal_connect (m_widget, "size_allocate",
582 G_CALLBACK (gtk_frame_size_callback), this);
583
584 PostCreation();
585
586 if ((m_x != -1) || (m_y != -1))
587 gtk_widget_set_uposition( m_widget, m_x, m_y );
588
589 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
590
591 // we cannot set MWM hints and icons before the widget has
592 // been realized, so we do this directly after realization
593 g_signal_connect (m_widget, "realize",
594 G_CALLBACK (gtk_frame_realized_callback), this);
595
596 // map and unmap for iconized state
597 g_signal_connect (m_widget, "map_event",
598 G_CALLBACK (gtk_frame_map_callback), this);
599 g_signal_connect (m_widget, "unmap_event",
600 G_CALLBACK (gtk_frame_unmap_callback), this);
601
602 // the only way to get the window size is to connect to this event
603 g_signal_connect (m_widget, "configure_event",
604 G_CALLBACK (gtk_frame_configure_callback), this);
605
606 // disable native tab traversal
607 g_signal_connect (m_widget, "focus",
608 G_CALLBACK (gtk_frame_focus_callback), this);
609
610 // activation
611 g_signal_connect_after (m_widget, "focus_in_event",
612 G_CALLBACK (gtk_frame_focus_in_callback), this);
613 g_signal_connect_after (m_widget, "focus_out_event",
614 G_CALLBACK (gtk_frame_focus_out_callback), this);
615
616 // decorations
617 if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
618 {
619 m_gdkDecor = 0;
620 m_gdkFunc = 0;
621 }
622 else
623 if (m_miniEdge > 0)
624 {
625 m_gdkDecor = 0;
626 m_gdkFunc = 0;
627
628 if ((style & wxRESIZE_BORDER) != 0)
629 m_gdkFunc |= GDK_FUNC_RESIZE;
630 }
631 else
632 {
633 m_gdkDecor = (long) GDK_DECOR_BORDER;
634 m_gdkFunc = (long) GDK_FUNC_MOVE;
635
636 // All this is for Motif Window Manager "hints" and is supposed to be
637 // recognized by other WMs as well.
638 if ((style & wxCAPTION) != 0)
639 {
640 m_gdkDecor |= GDK_DECOR_TITLE;
641 }
642 if ((style & wxCLOSE_BOX) != 0)
643 {
644 m_gdkFunc |= GDK_FUNC_CLOSE;
645 }
646 if ((style & wxSYSTEM_MENU) != 0)
647 {
648 m_gdkDecor |= GDK_DECOR_MENU;
649 }
650 if ((style & wxMINIMIZE_BOX) != 0)
651 {
652 m_gdkFunc |= GDK_FUNC_MINIMIZE;
653 m_gdkDecor |= GDK_DECOR_MINIMIZE;
654 }
655 if ((style & wxMAXIMIZE_BOX) != 0)
656 {
657 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
658 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
659 }
660 if ((style & wxRESIZE_BORDER) != 0)
661 {
662 m_gdkFunc |= GDK_FUNC_RESIZE;
663 m_gdkDecor |= GDK_DECOR_RESIZEH;
664 }
665 }
666
667 return true;
668 }
669
670 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
671 {
672 if (m_grabbed)
673 {
674 wxFAIL_MSG(_T("Window still grabbed"));
675 RemoveGrab();
676 }
677
678 m_isBeingDeleted = true;
679
680 // it may also be GtkScrolledWindow in the case of an MDI child
681 if (GTK_IS_WINDOW(m_widget))
682 {
683 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
684 }
685
686 if (g_activeFrame == this)
687 g_activeFrame = NULL;
688 if (g_lastActiveFrame == this)
689 g_lastActiveFrame = NULL;
690 }
691
692
693
694 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
695 {
696 if (show == m_fsIsShowing)
697 return false; // return what?
698
699 m_fsIsShowing = show;
700
701 wxX11FullScreenMethod method =
702 wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
703 (WXWindow)GDK_ROOT_WINDOW());
704
705 #if GTK_CHECK_VERSION(2,2,0)
706 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
707 // to switch to fullscreen, which is not always available. We must
708 // check if WM supports the spec and use legacy methods if it
709 // doesn't.
710 if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
711 {
712 if (show)
713 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
714 else
715 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
716 }
717 else
718 #endif // GTK+ >= 2.2.0
719 {
720 GdkWindow *window = m_widget->window;
721
722 if (show)
723 {
724 m_fsSaveFlag = style;
725 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
726 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
727
728 int screen_width,screen_height;
729 wxDisplaySize( &screen_width, &screen_height );
730
731 gint client_x, client_y, root_x, root_y;
732 gint width, height;
733
734 if (method != wxX11_FS_WMSPEC)
735 {
736 // don't do it always, Metacity hates it
737 m_fsSaveGdkFunc = m_gdkFunc;
738 m_fsSaveGdkDecor = m_gdkDecor;
739 m_gdkFunc = m_gdkDecor = 0;
740 gdk_window_set_decorations(window, (GdkWMDecoration)0);
741 gdk_window_set_functions(window, (GdkWMFunction)0);
742 }
743
744 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
745 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
746 &width, &height, NULL);
747
748 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
749 screen_width + 1, screen_height + 1);
750
751 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
752 (WXWindow)GDK_ROOT_WINDOW(),
753 (WXWindow)GDK_WINDOW_XWINDOW(window),
754 show, &m_fsSaveFrame, method);
755 }
756 else // hide
757 {
758 if (method != wxX11_FS_WMSPEC)
759 {
760 // don't do it always, Metacity hates it
761 m_gdkFunc = m_fsSaveGdkFunc;
762 m_gdkDecor = m_fsSaveGdkDecor;
763 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
764 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
765 }
766
767 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
768 (WXWindow)GDK_ROOT_WINDOW(),
769 (WXWindow)GDK_WINDOW_XWINDOW(window),
770 show, &m_fsSaveFrame, method);
771
772 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
773 m_fsSaveFrame.width, m_fsSaveFrame.height);
774 }
775 }
776
777 // documented behaviour is to show the window if it's still hidden when
778 // showing it full screen
779 if ( show && !IsShown() )
780 Show();
781
782 return true;
783 }
784
785 // ----------------------------------------------------------------------------
786 // overridden wxWindow methods
787 // ----------------------------------------------------------------------------
788
789 bool wxTopLevelWindowGTK::Show( bool show )
790 {
791 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
792
793 if (show == IsShown())
794 return true;
795
796 if (show && !m_sizeSet)
797 {
798 /* by calling GtkOnSize here, we don't have to call
799 either after showing the frame, which would entail
800 much ugly flicker or from within the size_allocate
801 handler, because GTK 1.1.X forbids that. */
802
803 GtkOnSize( m_x, m_y, m_width, m_height );
804 }
805
806 // This seems no longer to be needed and the call
807 // itself is deprecated.
808 //
809 //if (show)
810 // gtk_widget_set_uposition( m_widget, m_x, m_y );
811
812 return wxWindow::Show( show );
813 }
814
815 void wxTopLevelWindowGTK::Raise()
816 {
817 gtk_window_present( GTK_WINDOW( m_widget ) );
818 }
819
820 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
821 {
822 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
823 }
824
825 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
826 {
827 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
828
829 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
830 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
831
832 // avoid recursions
833 if (m_resizing)
834 return;
835 m_resizing = true;
836
837 int old_x = m_x;
838 int old_y = m_y;
839
840 int old_width = m_width;
841 int old_height = m_height;
842
843 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
844 {
845 if (x != -1) m_x = x;
846 if (y != -1) m_y = y;
847 }
848 else
849 {
850 m_x = x;
851 m_y = y;
852 }
853 if (width != -1) m_width = width;
854 if (height != -1) m_height = height;
855
856 /*
857 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
858 {
859 if (width == -1) m_width = 80;
860 }
861
862 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
863 {
864 if (height == -1) m_height = 26;
865 }
866 */
867
868 int minWidth = GetMinWidth(),
869 minHeight = GetMinHeight(),
870 maxWidth = GetMaxWidth(),
871 maxHeight = GetMaxHeight();
872
873 #ifdef __WXGPE__
874 // GPE's window manager doesn't like size hints
875 // at all, esp. when the user has to use the
876 // virtual keyboard.
877 minWidth = -1;
878 minHeight = -1;
879 maxWidth = -1;
880 maxHeight = -1;
881 #endif
882
883 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
884 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
885 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
886 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
887
888 if ((m_x != -1) || (m_y != -1))
889 {
890 if ((m_x != old_x) || (m_y != old_y))
891 {
892 gtk_widget_set_uposition( m_widget, m_x, m_y );
893 }
894 }
895
896 if ((m_width != old_width) || (m_height != old_height))
897 {
898 if (m_widget->window)
899 gdk_window_resize( m_widget->window, m_width, m_height );
900 else
901 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
902
903 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
904 done either directly before the frame is shown or in idle time
905 so that different calls to SetSize() don't lead to flicker. */
906 m_sizeSet = false;
907 }
908
909 m_resizing = false;
910 }
911
912 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
913 {
914 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
915
916 if (height)
917 {
918 *height = m_height;
919
920 // mini edge
921 *height -= m_miniEdge*2 + m_miniTitle;
922 }
923 if (width)
924 {
925 *width = m_width;
926
927 *width -= m_miniEdge*2;
928 }
929
930 }
931
932 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
933 {
934 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
935
936 DoSetSize(-1, -1,
937 width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0);
938 }
939
940 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
941 int width, int height )
942 {
943 // due to a bug in gtk, x,y are always 0
944 // m_x = x;
945 // m_y = y;
946
947 // avoid recursions
948 if (m_resizing) return;
949 m_resizing = true;
950
951 if ( m_wxwindow == NULL ) return;
952
953 m_width = width;
954 m_height = height;
955
956 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
957 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
958 set in wxFrame::Create so it is used to check what kind of frame we
959 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
960 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
961 importantly) m_mainWidget */
962
963 int minWidth = GetMinWidth(),
964 minHeight = GetMinHeight(),
965 maxWidth = GetMaxWidth(),
966 maxHeight = GetMaxHeight();
967
968 #ifdef __WXGPE__
969 // GPE's window manager doesn't like size hints
970 // at all, esp. when the user has to use the
971 // virtual keyboard.
972 minWidth = -1;
973 minHeight = -1;
974 maxWidth = -1;
975 maxHeight = -1;
976 #endif
977
978 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
979 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
980 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
981 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
982
983 if (m_mainWidget)
984 {
985 // set size hints
986 gint flag = 0; // GDK_HINT_POS;
987 GdkGeometry geom;
988
989 if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
990 if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
991
992 geom.min_width = minWidth;
993 geom.min_height = minHeight;
994
995 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
996 // maxHeight or maxWidth is set, we must set them both, else the
997 // remaining -1 will be taken literally.
998
999 // I'm certain this also happens elsewhere, and is the probable
1000 // cause of other such things as:
1001 // Gtk-WARNING **: gtk_widget_size_allocate():
1002 // attempt to allocate widget with width 65535 and height 600
1003 // but I don't have time to track them all now..
1004 //
1005 // Really we need to encapulate all this height/width business and
1006 // stop any old method from ripping at the members directly and
1007 // scattering -1's without regard for who might resolve them later.
1008
1009 geom.max_width = ( maxHeight == -1 ) ? maxWidth
1010 : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1011 : maxWidth ;
1012
1013 geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here )
1014 : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1015 : maxHeight ;
1016
1017 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1018 (GtkWidget*) NULL,
1019 &geom,
1020 (GdkWindowHints) flag );
1021
1022 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1023 * menubar, the toolbar and the client area, which is represented by
1024 * m_wxwindow.
1025 * this hurts in the eye, but I don't want to call SetSize()
1026 * because I don't want to call any non-native functions here. */
1027
1028 int client_x = m_miniEdge;
1029 int client_y = m_miniEdge + m_miniTitle;
1030 int client_w = m_width - 2*m_miniEdge;
1031 int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1032
1033 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1034 m_wxwindow,
1035 client_x, client_y, client_w, client_h );
1036 }
1037 else
1038 {
1039 // If there is no m_mainWidget between m_widget and m_wxwindow there
1040 // is no need to set the size or position of m_wxwindow.
1041 }
1042
1043 m_sizeSet = true;
1044
1045 // send size event to frame
1046 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1047 event.SetEventObject( this );
1048 GetEventHandler()->ProcessEvent( event );
1049
1050 m_resizing = false;
1051 }
1052
1053 void wxTopLevelWindowGTK::OnInternalIdle()
1054 {
1055 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1056 {
1057 GtkOnSize( m_x, m_y, m_width, m_height );
1058
1059 // we'll come back later
1060 if (g_isIdle)
1061 wxapp_install_idle_handler();
1062 return;
1063 }
1064
1065 // set the focus if not done yet and if we can already do it
1066 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1067 {
1068 if ( g_delayedFocus &&
1069 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1070 {
1071 wxLogTrace(_T("focus"),
1072 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1073 g_delayedFocus->GetClassInfo()->GetClassName(),
1074 g_delayedFocus->GetLabel().c_str());
1075
1076 g_delayedFocus->SetFocus();
1077 g_delayedFocus = NULL;
1078 }
1079 }
1080
1081 wxWindow::OnInternalIdle();
1082
1083 // Synthetize activate events.
1084 if ( g_sendActivateEvent != -1 )
1085 {
1086 bool activate = g_sendActivateEvent != 0;
1087
1088 // if (!activate) wxPrintf( wxT("de") );
1089 // wxPrintf( wxT("activate\n") );
1090
1091 // do it only once
1092 g_sendActivateEvent = -1;
1093
1094 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1095 }
1096 }
1097
1098 // ----------------------------------------------------------------------------
1099 // frame title/icon
1100 // ----------------------------------------------------------------------------
1101
1102 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1103 {
1104 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1105
1106 if ( title == m_title )
1107 return;
1108
1109 m_title = title;
1110
1111 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1112 }
1113
1114 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1115 {
1116 SetIcons( wxIconBundle( icon ) );
1117 }
1118
1119 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1120 {
1121 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1122
1123 wxTopLevelWindowBase::SetIcons( icons );
1124
1125 GList *list = NULL;
1126 size_t max = icons.m_icons.GetCount();
1127
1128 for (size_t i = 0; i < max; i++)
1129 {
1130 if (icons.m_icons[i].Ok())
1131 {
1132 list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1133 }
1134 }
1135 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1136 g_list_free(list);
1137 }
1138
1139 // ----------------------------------------------------------------------------
1140 // frame state: maximized/iconized/normal
1141 // ----------------------------------------------------------------------------
1142
1143 void wxTopLevelWindowGTK::Maximize(bool maximize)
1144 {
1145 if (maximize)
1146 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1147 else
1148 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1149 }
1150
1151 bool wxTopLevelWindowGTK::IsMaximized() const
1152 {
1153 if(!m_widget->window)
1154 return false;
1155
1156 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1157 }
1158
1159 void wxTopLevelWindowGTK::Restore()
1160 {
1161 // "Present" seems similar enough to "restore"
1162 gtk_window_present( GTK_WINDOW( m_widget ) );
1163 }
1164
1165 void wxTopLevelWindowGTK::Iconize( bool iconize )
1166 {
1167 if (iconize)
1168 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1169 else
1170 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1171 }
1172
1173 bool wxTopLevelWindowGTK::IsIconized() const
1174 {
1175 return m_isIconized;
1176 }
1177
1178 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1179 {
1180 if ( iconize != m_isIconized )
1181 {
1182 m_isIconized = iconize;
1183 (void)SendIconizeEvent(iconize);
1184 }
1185 }
1186
1187 void wxTopLevelWindowGTK::AddGrab()
1188 {
1189 if (!m_grabbed)
1190 {
1191 m_grabbed = true;
1192 gtk_grab_add( m_widget );
1193 wxEventLoop().Run();
1194 gtk_grab_remove( m_widget );
1195 }
1196 }
1197
1198 void wxTopLevelWindowGTK::RemoveGrab()
1199 {
1200 if (m_grabbed)
1201 {
1202 gtk_main_quit();
1203 m_grabbed = false;
1204 }
1205 }
1206
1207
1208 // helper
1209 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1210 {
1211 if (window)
1212 {
1213 if (region.IsEmpty())
1214 {
1215 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1216 }
1217 else
1218 {
1219 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1220 return true;
1221 }
1222 }
1223 return false;
1224 }
1225
1226
1227 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1228 {
1229 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1230 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1231
1232 GdkWindow *window = NULL;
1233 if (m_wxwindow)
1234 {
1235 window = GTK_PIZZA(m_wxwindow)->bin_window;
1236 do_shape_combine_region(window, region);
1237 }
1238 window = m_widget->window;
1239 return do_shape_combine_region(window, region);
1240 }
1241
1242 bool wxTopLevelWindowGTK::IsActive()
1243 {
1244 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1245 }
1246
1247 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1248 {
1249 bool new_hint_value = false;
1250
1251 // FIXME: This is a workaround to focus handling problem
1252 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1253 // yet been processed, and the internal focus system is not up to date yet.
1254 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1255 ::wxYieldIfNeeded();
1256
1257 if(m_urgency_hint >= 0)
1258 g_source_remove(m_urgency_hint);
1259
1260 m_urgency_hint = -2;
1261
1262 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1263 {
1264 new_hint_value = true;
1265
1266 if (flags & wxUSER_ATTENTION_INFO)
1267 {
1268 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1269 } else {
1270 m_urgency_hint = -1;
1271 }
1272 }
1273
1274 #if GTK_CHECK_VERSION(2,7,0)
1275 if(!gtk_check_version(2,7,0))
1276 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1277 else
1278 #endif
1279 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1280 }
1281
1282 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1283 {
1284 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1285 // Store which styles were changed
1286 long styleChanges = style ^ m_windowStyle;
1287 #endif
1288
1289 // Process wxWindow styles. This also updates the internal variable
1290 // Therefore m_windowStyle bits carry now the _new_ style values
1291 wxWindow::SetWindowStyleFlag(style);
1292
1293 // just return for now if widget does not exist yet
1294 if (!m_widget)
1295 return;
1296
1297 #ifdef __WXGTK24__
1298 if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1299 gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1300 #endif // GTK+ 2.4
1301 #if GTK_CHECK_VERSION(2,2,0)
1302 if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1303 {
1304 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1305 }
1306 #endif // GTK+ 2.2
1307 }
1308
1309 #include <X11/Xlib.h>
1310
1311 /* Get the X Window between child and the root window.
1312 This should usually be the WM managed XID */
1313 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1314 {
1315 Window root, parent;
1316 Window* children;
1317 unsigned int nchildren;
1318
1319 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1320 XFree(children);
1321
1322 while (parent != root) {
1323 child = parent;
1324 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1325 XFree(children);
1326 }
1327
1328 return child;
1329 }
1330
1331 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1332 {
1333 if (!m_widget || !m_widget->window)
1334 return false;
1335
1336 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1337 // We need to get the X Window that has the root window as the immediate parent
1338 // and m_widget->window as a child. This should be the X Window that the WM manages and
1339 // from which the opacity property is checked from.
1340 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1341
1342 unsigned int opacity = alpha * 0x1010101;
1343
1344 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1345 if (alpha == 0xff)
1346 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1347 else
1348 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1349 XA_CARDINAL, 32, PropModeReplace,
1350 (unsigned char *) &opacity, 1L);
1351 XSync(dpy, False);
1352 return true;
1353 }
1354
1355 bool wxTopLevelWindowGTK::CanSetTransparent()
1356 {
1357 #if GTK_CHECK_VERSION(2,10,0)
1358 if (!gtk_check_version(2,10,0))
1359 {
1360 if (gtk_widget_is_composited (m_widget))
1361 return true;
1362 }
1363 else
1364 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1365 {
1366 return false;
1367 }
1368
1369 #if 0 // Don't be optimistic here for the sake of wxAUI
1370 int opcode, event, error;
1371 // Check for the existence of a RGBA visual instead?
1372 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1373 "Composite", &opcode, &event, &error);
1374 #endif
1375 }
wxWidgets (Impactor)