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


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