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


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