]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/toplevel.cpp
minor tab height bug fix
[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 *WXUNUSED(widget),
206 GtkDirectionType WXUNUSED(d),
207 wxWindow *WXUNUSED(win) )
208 {
209 if (g_isIdle)
210 wxapp_install_idle_handler();
211
212 // This disables GTK's tab traversal
213 return TRUE;
214 }
215 }
216
217 //-----------------------------------------------------------------------------
218 // "size_allocate"
219 //-----------------------------------------------------------------------------
220
221 extern "C" {
222 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
223 {
224 if (g_isIdle)
225 wxapp_install_idle_handler();
226
227 if (!win->m_hasVMT)
228 return;
229
230 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
231 {
232 /*
233 wxPrintf( wxT("gtk_frame_size_callback from ") );
234 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
235 wxPrintf( win->GetClassInfo()->GetClassName() );
236 wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
237 (int)alloc->y,
238 (int)alloc->width,
239 (int)alloc->height );
240 */
241
242 // Tell the wxWindow class about the new size
243 win->m_width = alloc->width;
244 win->m_height = alloc->height;
245
246 win->GtkUpdateSize();
247 }
248 }
249 }
250
251 //-----------------------------------------------------------------------------
252 // "delete_event"
253 //-----------------------------------------------------------------------------
254
255 extern "C" {
256 static gboolean
257 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
258 GdkEvent *WXUNUSED(event),
259 wxTopLevelWindowGTK *win )
260 {
261 // don't need to install idle handler, its done from "event" signal
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 // don't need to install idle handler, its done from "event" signal
284
285 if (!win->m_hasVMT || !win->IsShown())
286 return FALSE;
287
288
289 int x = 0;
290 int y = 0;
291 gdk_window_get_root_origin( win->m_widget->window, &x, &y );
292 win->m_x = x;
293 win->m_y = y;
294
295 wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
296 mevent.SetEventObject( win );
297 win->GetEventHandler()->ProcessEvent( mevent );
298
299 return FALSE;
300 }
301 }
302
303 //-----------------------------------------------------------------------------
304 // "realize" from m_widget
305 //-----------------------------------------------------------------------------
306
307 // we cannot MWM hints and icons before the widget has been realized,
308 // so we do this directly after realization
309
310 extern "C" {
311 static void
312 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
313 wxTopLevelWindowGTK *win )
314 {
315 if (g_isIdle)
316 wxapp_install_idle_handler();
317
318 // All this is for Motif Window Manager "hints" and is supposed to be
319 // recognized by other WM as well. Not tested.
320 gdk_window_set_decorations(win->m_widget->window,
321 (GdkWMDecoration)win->m_gdkDecor);
322 gdk_window_set_functions(win->m_widget->window,
323 (GdkWMFunction)win->m_gdkFunc);
324
325 // GTK's shrinking/growing policy
326 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
327 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
328 else
329 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
330
331 // reset the icon
332 wxIconBundle iconsOld = win->GetIcons();
333 if ( iconsOld.GetIcon(-1).Ok() )
334 {
335 win->SetIcon( wxNullIcon );
336 win->SetIcons( iconsOld );
337 }
338 }
339 }
340
341 //-----------------------------------------------------------------------------
342 // "map_event" from m_widget
343 //-----------------------------------------------------------------------------
344
345 extern "C" {
346 static void
347 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
348 GdkEvent * WXUNUSED(event),
349 wxTopLevelWindow *win )
350 {
351 win->SetIconizeState(false);
352 }
353 }
354
355 //-----------------------------------------------------------------------------
356 // "unmap_event" from m_widget
357 //-----------------------------------------------------------------------------
358
359 extern "C" {
360 static void
361 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
362 GdkEvent * WXUNUSED(event),
363 wxTopLevelWindow *win )
364 {
365 win->SetIconizeState(true);
366 }
367 }
368
369 //-----------------------------------------------------------------------------
370 // "expose_event" of m_client
371 //-----------------------------------------------------------------------------
372
373 extern "C" {
374 static gboolean
375 gtk_window_expose_callback( GtkWidget *widget,
376 GdkEventExpose *gdk_event,
377 wxWindow *win )
378 {
379 GtkPizza *pizza = GTK_PIZZA(widget);
380
381 gtk_paint_flat_box (win->m_widget->style,
382 pizza->bin_window, GTK_STATE_NORMAL,
383 GTK_SHADOW_NONE,
384 &gdk_event->area,
385 win->m_widget,
386 (char *)"base",
387 0, 0, -1, -1);
388
389 return FALSE;
390 }
391 }
392
393 // ----------------------------------------------------------------------------
394 // wxTopLevelWindowGTK itself
395 // ----------------------------------------------------------------------------
396
397 //-----------------------------------------------------------------------------
398 // InsertChild for wxTopLevelWindowGTK
399 //-----------------------------------------------------------------------------
400
401 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
402 * C++ has no virtual methods in a constructor. We have to emulate a
403 * virtual function here as wxWidgets requires different ways to insert
404 * a child in container classes. */
405
406 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
407 {
408 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
409
410 if (!parent->m_insertInClientArea)
411 {
412 // these are outside the client area
413 wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
414 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
415 GTK_WIDGET(child->m_widget),
416 child->m_x,
417 child->m_y,
418 child->m_width,
419 child->m_height );
420 }
421 else
422 {
423 // these are inside the client area
424 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
425 GTK_WIDGET(child->m_widget),
426 child->m_x,
427 child->m_y,
428 child->m_width,
429 child->m_height );
430 }
431 }
432
433 // ----------------------------------------------------------------------------
434 // wxTopLevelWindowGTK creation
435 // ----------------------------------------------------------------------------
436
437 void wxTopLevelWindowGTK::Init()
438 {
439 m_sizeSet = false;
440 m_miniEdge = 0;
441 m_miniTitle = 0;
442 m_mainWidget = (GtkWidget*) NULL;
443 m_insertInClientArea = true;
444 m_isIconized = false;
445 m_fsIsShowing = false;
446 m_fsSaveFlag = 0;
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 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
698 {
699 if (enable)
700 m_gdkFunc |= GDK_FUNC_CLOSE;
701 else
702 m_gdkFunc &= ~GDK_FUNC_CLOSE;
703
704 if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
705 gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
706
707 return true;
708 }
709
710 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
711 {
712 if (show == m_fsIsShowing)
713 return false; // return what?
714
715 m_fsIsShowing = show;
716
717 wxX11FullScreenMethod method =
718 wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
719 (WXWindow)GDK_ROOT_WINDOW());
720
721 #if GTK_CHECK_VERSION(2,2,0)
722 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
723 // to switch to fullscreen, which is not always available. We must
724 // check if WM supports the spec and use legacy methods if it
725 // doesn't.
726 if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
727 {
728 if (show)
729 {
730 m_fsSaveFlag = style;
731 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
732 }
733 else
734 {
735 m_fsSaveFlag = 0;
736 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
737 }
738 }
739 else
740 #endif // GTK+ >= 2.2.0
741 {
742 GdkWindow *window = m_widget->window;
743
744 if (show)
745 {
746 m_fsSaveFlag = style;
747 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
748 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
749
750 int screen_width,screen_height;
751 wxDisplaySize( &screen_width, &screen_height );
752
753 gint client_x, client_y, root_x, root_y;
754 gint width, height;
755
756 if (method != wxX11_FS_WMSPEC)
757 {
758 // don't do it always, Metacity hates it
759 m_fsSaveGdkFunc = m_gdkFunc;
760 m_fsSaveGdkDecor = m_gdkDecor;
761 m_gdkFunc = m_gdkDecor = 0;
762 gdk_window_set_decorations(window, (GdkWMDecoration)0);
763 gdk_window_set_functions(window, (GdkWMFunction)0);
764 }
765
766 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
767 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
768 &width, &height, NULL);
769
770 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
771 screen_width + 1, screen_height + 1);
772
773 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
774 (WXWindow)GDK_ROOT_WINDOW(),
775 (WXWindow)GDK_WINDOW_XWINDOW(window),
776 show, &m_fsSaveFrame, method);
777 }
778 else // hide
779 {
780 m_fsSaveFlag = 0;
781 if (method != wxX11_FS_WMSPEC)
782 {
783 // don't do it always, Metacity hates it
784 m_gdkFunc = m_fsSaveGdkFunc;
785 m_gdkDecor = m_fsSaveGdkDecor;
786 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
787 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
788 }
789
790 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
791 (WXWindow)GDK_ROOT_WINDOW(),
792 (WXWindow)GDK_WINDOW_XWINDOW(window),
793 show, &m_fsSaveFrame, method);
794
795 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
796 m_fsSaveFrame.width, m_fsSaveFrame.height);
797 }
798 }
799
800 // documented behaviour is to show the window if it's still hidden when
801 // showing it full screen
802 if ( show && !IsShown() )
803 Show();
804
805 return true;
806 }
807
808 // ----------------------------------------------------------------------------
809 // overridden wxWindow methods
810 // ----------------------------------------------------------------------------
811
812 bool wxTopLevelWindowGTK::Show( bool show )
813 {
814 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
815
816 if (show == IsShown())
817 return true;
818
819 if (show && !m_sizeSet)
820 {
821 /* by calling GtkOnSize here, we don't have to call
822 either after showing the frame, which would entail
823 much ugly flicker or from within the size_allocate
824 handler, because GTK 1.1.X forbids that. */
825
826 GtkOnSize();
827 }
828
829 // This seems no longer to be needed and the call
830 // itself is deprecated.
831 //
832 //if (show)
833 // gtk_widget_set_uposition( m_widget, m_x, m_y );
834
835 return wxWindow::Show( show );
836 }
837
838 void wxTopLevelWindowGTK::Raise()
839 {
840 gtk_window_present( GTK_WINDOW( m_widget ) );
841 }
842
843 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
844 {
845 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
846 }
847
848 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
849 {
850 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
851
852 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
853 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
854
855 // avoid recursions
856 if (m_resizing)
857 return;
858 m_resizing = true;
859
860 int old_x = m_x;
861 int old_y = m_y;
862
863 int old_width = m_width;
864 int old_height = m_height;
865
866 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
867 {
868 if (x != -1) m_x = x;
869 if (y != -1) m_y = y;
870 }
871 else
872 {
873 m_x = x;
874 m_y = y;
875 }
876 if (width != -1) m_width = width;
877 if (height != -1) m_height = height;
878
879 /*
880 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
881 {
882 if (width == -1) m_width = 80;
883 }
884
885 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
886 {
887 if (height == -1) m_height = 26;
888 }
889 */
890
891 int minWidth = GetMinWidth(),
892 minHeight = GetMinHeight(),
893 maxWidth = GetMaxWidth(),
894 maxHeight = GetMaxHeight();
895
896 #ifdef __WXGPE__
897 // GPE's window manager doesn't like size hints
898 // at all, esp. when the user has to use the
899 // virtual keyboard.
900 minWidth = -1;
901 minHeight = -1;
902 maxWidth = -1;
903 maxHeight = -1;
904 #endif
905
906 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
907 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
908 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
909 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
910
911 if ((m_x != -1) || (m_y != -1))
912 {
913 if ((m_x != old_x) || (m_y != old_y))
914 {
915 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
916 }
917 }
918
919 if ((m_width != old_width) || (m_height != old_height))
920 {
921 gtk_window_resize( GTK_WINDOW(m_widget), m_width, m_height );
922
923 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
924 done either directly before the frame is shown or in idle time
925 so that different calls to SetSize() don't lead to flicker. */
926 m_sizeSet = false;
927 }
928
929 m_resizing = false;
930 }
931
932 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
933 {
934 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
935
936 if (height)
937 {
938 *height = m_height - 2 * m_miniEdge - m_miniTitle;
939 if (*height < 0)
940 *height = 0;
941 }
942 if (width)
943 {
944 *width = m_width - 2 * m_miniEdge;
945 if (*width < 0)
946 *width = 0;
947 }
948 }
949
950 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
951 {
952 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
953
954 DoSetSize(-1, -1,
955 width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0);
956 }
957
958 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
959 int maxW, int maxH,
960 int incW, int incH )
961 {
962 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
963
964 if (m_widget)
965 {
966 int minWidth = GetMinWidth(),
967 minHeight = GetMinHeight(),
968 maxWidth = GetMaxWidth(),
969 maxHeight = GetMaxHeight();
970
971 // set size hints
972 gint flag = 0; // GDK_HINT_POS;
973 GdkGeometry geom;
974
975 if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
976 if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
977
978 geom.min_width = minWidth;
979 geom.min_height = minHeight;
980
981 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
982 // maxHeight or maxWidth is set, we must set them both, else the
983 // remaining -1 will be taken literally.
984
985 // I'm certain this also happens elsewhere, and is the probable
986 // cause of other such things as:
987 // Gtk-WARNING **: gtk_widget_size_allocate():
988 // attempt to allocate widget with width 65535 and height 600
989 // but I don't have time to track them all now..
990 //
991 // Really we need to encapulate all this height/width business and
992 // stop any old method from ripping at the members directly and
993 // scattering -1's without regard for who might resolve them later.
994
995 geom.max_width = ( maxHeight == -1 ) ? maxWidth
996 : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
997 : maxWidth ;
998
999 geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here )
1000 : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1001 : maxHeight ;
1002
1003 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1004 (GtkWidget*) NULL,
1005 &geom,
1006 (GdkWindowHints) flag );
1007 }
1008 }
1009
1010
1011 void wxTopLevelWindowGTK::GtkOnSize()
1012 {
1013 // avoid recursions
1014 if (m_resizing) return;
1015 m_resizing = true;
1016
1017 if ( m_wxwindow == NULL ) return;
1018
1019 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1020 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1021 set in wxFrame::Create so it is used to check what kind of frame we
1022 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1023 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1024 importantly) m_mainWidget */
1025
1026 int minWidth = GetMinWidth(),
1027 minHeight = GetMinHeight(),
1028 maxWidth = GetMaxWidth(),
1029 maxHeight = GetMaxHeight();
1030
1031 #ifdef __WXGPE__
1032 // GPE's window manager doesn't like size hints
1033 // at all, esp. when the user has to use the
1034 // virtual keyboard.
1035 minWidth = -1;
1036 minHeight = -1;
1037 maxWidth = -1;
1038 maxHeight = -1;
1039 #endif
1040
1041 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
1042 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
1043 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
1044 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
1045
1046 if (m_mainWidget)
1047 {
1048 // m_mainWidget holds the menubar, the toolbar and the client area,
1049 // which is represented by m_wxwindow.
1050 int client_x = m_miniEdge;
1051 int client_y = m_miniEdge + m_miniTitle;
1052 int client_w = m_width - 2*m_miniEdge;
1053 int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1054 if (client_w < 0)
1055 client_w = 0;
1056 if (client_h < 0)
1057 client_h = 0;
1058
1059 // Let the parent perform the resize
1060 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1061 m_wxwindow,
1062 client_x, client_y, client_w, client_h );
1063 }
1064 else
1065 {
1066 // If there is no m_mainWidget between m_widget and m_wxwindow there
1067 // is no need to set the size or position of m_wxwindow.
1068 }
1069
1070 m_sizeSet = true;
1071
1072 // send size event to frame
1073 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1074 event.SetEventObject( this );
1075 GetEventHandler()->ProcessEvent( event );
1076
1077 m_resizing = false;
1078 }
1079
1080 void wxTopLevelWindowGTK::OnInternalIdle()
1081 {
1082 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1083 {
1084 GtkOnSize();
1085
1086 // we'll come back later
1087 if (g_isIdle)
1088 wxapp_install_idle_handler();
1089 return;
1090 }
1091
1092 // set the focus if not done yet and if we can already do it
1093 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1094 {
1095 if ( g_delayedFocus &&
1096 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1097 {
1098 wxLogTrace(_T("focus"),
1099 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1100 g_delayedFocus->GetClassInfo()->GetClassName(),
1101 g_delayedFocus->GetLabel().c_str());
1102
1103 g_delayedFocus->SetFocus();
1104 g_delayedFocus = NULL;
1105 }
1106 }
1107
1108 wxWindow::OnInternalIdle();
1109
1110 // Synthetize activate events.
1111 if ( g_sendActivateEvent != -1 )
1112 {
1113 bool activate = g_sendActivateEvent != 0;
1114
1115 // if (!activate) wxPrintf( wxT("de") );
1116 // wxPrintf( wxT("activate\n") );
1117
1118 // do it only once
1119 g_sendActivateEvent = -1;
1120
1121 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1122 }
1123 }
1124
1125 // ----------------------------------------------------------------------------
1126 // frame title/icon
1127 // ----------------------------------------------------------------------------
1128
1129 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1130 {
1131 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1132
1133 if ( title == m_title )
1134 return;
1135
1136 m_title = title;
1137
1138 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1139 }
1140
1141 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1142 {
1143 SetIcons( wxIconBundle( icon ) );
1144 }
1145
1146 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1147 {
1148 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1149
1150 wxTopLevelWindowBase::SetIcons( icons );
1151
1152 GList *list = NULL;
1153 size_t max = icons.m_icons.GetCount();
1154
1155 for (size_t i = 0; i < max; i++)
1156 {
1157 if (icons.m_icons[i].Ok())
1158 {
1159 list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1160 }
1161 }
1162 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1163 g_list_free(list);
1164 }
1165
1166 // ----------------------------------------------------------------------------
1167 // frame state: maximized/iconized/normal
1168 // ----------------------------------------------------------------------------
1169
1170 void wxTopLevelWindowGTK::Maximize(bool maximize)
1171 {
1172 if (maximize)
1173 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1174 else
1175 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1176 }
1177
1178 bool wxTopLevelWindowGTK::IsMaximized() const
1179 {
1180 if(!m_widget->window)
1181 return false;
1182
1183 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1184 }
1185
1186 void wxTopLevelWindowGTK::Restore()
1187 {
1188 // "Present" seems similar enough to "restore"
1189 gtk_window_present( GTK_WINDOW( m_widget ) );
1190 }
1191
1192 void wxTopLevelWindowGTK::Iconize( bool iconize )
1193 {
1194 if (iconize)
1195 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1196 else
1197 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1198 }
1199
1200 bool wxTopLevelWindowGTK::IsIconized() const
1201 {
1202 return m_isIconized;
1203 }
1204
1205 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1206 {
1207 if ( iconize != m_isIconized )
1208 {
1209 m_isIconized = iconize;
1210 (void)SendIconizeEvent(iconize);
1211 }
1212 }
1213
1214 void wxTopLevelWindowGTK::AddGrab()
1215 {
1216 if (!m_grabbed)
1217 {
1218 m_grabbed = true;
1219 gtk_grab_add( m_widget );
1220 wxEventLoop().Run();
1221 gtk_grab_remove( m_widget );
1222 }
1223 }
1224
1225 void wxTopLevelWindowGTK::RemoveGrab()
1226 {
1227 if (m_grabbed)
1228 {
1229 gtk_main_quit();
1230 m_grabbed = false;
1231 }
1232 }
1233
1234
1235 // helper
1236 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1237 {
1238 if (window)
1239 {
1240 if (region.IsEmpty())
1241 {
1242 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1243 }
1244 else
1245 {
1246 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1247 return true;
1248 }
1249 }
1250 return false;
1251 }
1252
1253
1254 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1255 {
1256 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1257 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1258
1259 GdkWindow *window = NULL;
1260 if (m_wxwindow)
1261 {
1262 window = GTK_PIZZA(m_wxwindow)->bin_window;
1263 do_shape_combine_region(window, region);
1264 }
1265 window = m_widget->window;
1266 return do_shape_combine_region(window, region);
1267 }
1268
1269 bool wxTopLevelWindowGTK::IsActive()
1270 {
1271 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1272 }
1273
1274 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1275 {
1276 bool new_hint_value = false;
1277
1278 // FIXME: This is a workaround to focus handling problem
1279 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1280 // yet been processed, and the internal focus system is not up to date yet.
1281 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1282 ::wxYieldIfNeeded();
1283
1284 if(m_urgency_hint >= 0)
1285 g_source_remove(m_urgency_hint);
1286
1287 m_urgency_hint = -2;
1288
1289 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1290 {
1291 new_hint_value = true;
1292
1293 if (flags & wxUSER_ATTENTION_INFO)
1294 {
1295 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1296 } else {
1297 m_urgency_hint = -1;
1298 }
1299 }
1300
1301 #if GTK_CHECK_VERSION(2,7,0)
1302 if(!gtk_check_version(2,7,0))
1303 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1304 else
1305 #endif
1306 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1307 }
1308
1309 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1310 {
1311 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1312 // Store which styles were changed
1313 long styleChanges = style ^ m_windowStyle;
1314 #endif
1315
1316 // Process wxWindow styles. This also updates the internal variable
1317 // Therefore m_windowStyle bits carry now the _new_ style values
1318 wxWindow::SetWindowStyleFlag(style);
1319
1320 // just return for now if widget does not exist yet
1321 if (!m_widget)
1322 return;
1323
1324 #ifdef __WXGTK24__
1325 if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1326 gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1327 #endif // GTK+ 2.4
1328 #if GTK_CHECK_VERSION(2,2,0)
1329 if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1330 {
1331 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1332 }
1333 #endif // GTK+ 2.2
1334 }
1335
1336 #include <X11/Xlib.h>
1337
1338 /* Get the X Window between child and the root window.
1339 This should usually be the WM managed XID */
1340 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1341 {
1342 Window root, parent;
1343 Window* children;
1344 unsigned int nchildren;
1345
1346 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1347 XFree(children);
1348
1349 while (parent != root) {
1350 child = parent;
1351 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1352 XFree(children);
1353 }
1354
1355 return child;
1356 }
1357
1358 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1359 {
1360 if (!m_widget || !m_widget->window)
1361 return false;
1362
1363 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1364 // We need to get the X Window that has the root window as the immediate parent
1365 // and m_widget->window as a child. This should be the X Window that the WM manages and
1366 // from which the opacity property is checked from.
1367 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1368
1369 unsigned int opacity = alpha * 0x1010101;
1370
1371 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1372 if (alpha == 0xff)
1373 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1374 else
1375 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1376 XA_CARDINAL, 32, PropModeReplace,
1377 (unsigned char *) &opacity, 1L);
1378 XSync(dpy, False);
1379 return true;
1380 }
1381
1382 bool wxTopLevelWindowGTK::CanSetTransparent()
1383 {
1384 #if GTK_CHECK_VERSION(2,10,0)
1385 if (!gtk_check_version(2,10,0))
1386 {
1387 if (gtk_widget_is_composited (m_widget))
1388 return true;
1389 }
1390 else
1391 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1392 {
1393 return false;
1394 }
1395
1396 #if 0 // Don't be optimistic here for the sake of wxAUI
1397 int opcode, event, error;
1398 // Check for the existence of a RGBA visual instead?
1399 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1400 "Composite", &opcode, &event, &error);
1401 #endif
1402 }