]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/toplevel.cpp
Added wxFDIOHandler::IsOk() and use it with wxSocketImplUnix.
[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 #include "wx/sysopt.h"
37
38 #include <gtk/gtk.h>
39 #include <gdk/gdkx.h>
40
41 #include "wx/gtk/private/win_gtk.h"
42
43 #include "wx/unix/utilsx11.h"
44
45 // XA_CARDINAL
46 #include <X11/Xatom.h>
47
48 #if wxUSE_LIBHILDON
49 #include <hildon-widgets/hildon-program.h>
50 #include <hildon-widgets/hildon-window.h>
51 #endif // wxUSE_LIBHILDON
52
53 // ----------------------------------------------------------------------------
54 // data
55 // ----------------------------------------------------------------------------
56
57 // this is incremented while a modal dialog is shown
58 int wxOpenModalDialogsCount = 0;
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 = NULL;
63 static wxTopLevelWindowGTK *g_lastActiveFrame = 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 switch ( g_sendActivateEvent )
121 {
122 case -1:
123 // we've got focus from outside, synthetize wxActivateEvent
124 g_sendActivateEvent = 1;
125 break;
126
127 case 0:
128 // another our window just lost focus, it was already ours before
129 // - don't send any wxActivateEvent
130 g_sendActivateEvent = -1;
131 break;
132 }
133
134 g_activeFrame = win;
135 g_lastActiveFrame = g_activeFrame;
136
137 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
138
139 // MR: wxRequestUserAttention related block
140 switch( win->m_urgency_hint )
141 {
142 default:
143 g_source_remove( win->m_urgency_hint );
144 // no break, fallthrough to remove hint too
145 case -1:
146 #if GTK_CHECK_VERSION(2,7,0)
147 if(!gtk_check_version(2,7,0))
148 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
149 else
150 #endif
151 {
152 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
153 }
154
155 win->m_urgency_hint = -2;
156 break;
157
158 case -2: break;
159 }
160
161 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
162 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
163 event.SetEventObject(g_activeFrame);
164 g_activeFrame->HandleWindowEvent(event);
165
166 return FALSE;
167 }
168 }
169
170 //-----------------------------------------------------------------------------
171 // "focus_out_event"
172 //-----------------------------------------------------------------------------
173
174 extern "C" {
175 static
176 gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget),
177 GdkEventFocus *WXUNUSED(gdk_event),
178 wxTopLevelWindowGTK * WXUNUSED(win))
179 {
180 // if the focus goes out of our app alltogether, OnIdle() will send
181 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
182 // g_sendActivateEvent to -1
183 g_sendActivateEvent = 0;
184
185 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
186
187 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
188
189 if (g_activeFrame)
190 {
191 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
192 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
193 event.SetEventObject(g_activeFrame);
194 g_activeFrame->HandleWindowEvent(event);
195
196 g_activeFrame = NULL;
197 }
198
199 return FALSE;
200 }
201 }
202
203 //-----------------------------------------------------------------------------
204 // "size_allocate" from m_wxwindow
205 //-----------------------------------------------------------------------------
206
207 extern "C" {
208 static void
209 size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
210 {
211 if (win->m_oldClientWidth != alloc->width ||
212 win->m_oldClientHeight != alloc->height)
213 {
214 win->m_oldClientWidth = alloc->width;
215 win->m_oldClientHeight = alloc->height;
216
217 wxSize size(win->m_widget->allocation.width,
218 win->m_widget->allocation.height);
219 size += win->m_decorSize;
220 win->m_width = size.x;
221 win->m_height = size.y;
222
223 if (!win->IsIconized())
224 {
225 wxSizeEvent event(size, win->GetId());
226 event.SetEventObject(win);
227 win->HandleWindowEvent(event);
228 }
229 // else the window is currently unmapped, don't generate size events
230 }
231 }
232 }
233
234 // ----------------------------------------------------------------------------
235 // "size_request"
236 // ----------------------------------------------------------------------------
237
238 extern "C" {
239 static
240 void wxgtk_tlw_size_request_callback(GtkWidget * WXUNUSED(widget),
241 GtkRequisition *requisition,
242 wxTopLevelWindowGTK *win)
243 {
244 // we must return the size of the window without WM decorations, otherwise
245 // GTK+ gets confused, so don't call just GetSize() here
246 win->GTKDoGetSize(&requisition->width, &requisition->height);
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 (win->IsEnabled() &&
261 (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
262 win->IsGrabbed()))
263 win->Close();
264
265 return TRUE;
266 }
267 }
268
269 //-----------------------------------------------------------------------------
270 // "configure_event"
271 //-----------------------------------------------------------------------------
272
273 extern "C" {
274 static gboolean
275 gtk_frame_configure_callback( GtkWidget* widget,
276 GdkEventConfigure *WXUNUSED(event),
277 wxTopLevelWindowGTK *win )
278 {
279 if (!win->m_hasVMT || !win->IsShown())
280 return FALSE;
281
282 wxPoint point;
283 gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
284
285 win->m_x = point.x;
286 win->m_y = point.y;
287 wxMoveEvent mevent(point, win->GetId());
288 mevent.SetEventObject( win );
289 win->HandleWindowEvent( mevent );
290
291 return FALSE;
292 }
293 }
294
295 //-----------------------------------------------------------------------------
296 // "realize" from m_widget
297 //-----------------------------------------------------------------------------
298
299 // we cannot the WM hints and icons before the widget has been realized,
300 // so we do this directly after realization
301
302 extern "C" {
303 static void
304 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
305 wxTopLevelWindowGTK *win )
306 {
307 gdk_window_set_decorations(win->m_widget->window,
308 (GdkWMDecoration)win->m_gdkDecor);
309 gdk_window_set_functions(win->m_widget->window,
310 (GdkWMFunction)win->m_gdkFunc);
311
312 // GTK's shrinking/growing policy
313 if ( !(win->m_gdkFunc & GDK_FUNC_RESIZE) )
314 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
315 else
316 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
317
318 const wxIconBundle& icons = win->GetIcons();
319 if (icons.GetIconCount())
320 win->SetIcons(icons);
321
322 if (win->HasFlag(wxFRAME_SHAPED))
323 win->SetShape(win->m_shape); // it will really set the window shape now
324 }
325 }
326
327 //-----------------------------------------------------------------------------
328 // "map_event" from m_widget
329 //-----------------------------------------------------------------------------
330
331 extern "C" {
332 static gboolean
333 gtk_frame_map_callback( GtkWidget*,
334 GdkEvent * WXUNUSED(event),
335 wxTopLevelWindow *win )
336 {
337 const bool wasIconized = win->IsIconized();
338 win->SetIconizeState(false);
339 if (wasIconized)
340 {
341 // Because GetClientSize() returns (0,0) when IsIconized() is true,
342 // a size event must be generated, just in case GetClientSize() was
343 // called while iconized. This specifically happens when restoring a
344 // tlw that was "rolled up" with some WMs.
345 // Queue a resize rather than sending size event directly to allow
346 // children to be made visible first.
347 win->m_oldClientWidth = 0;
348 gtk_widget_queue_resize(win->m_wxwindow);
349 }
350 // it is possible for m_isShown to be false here, see bug #9909
351 if (win->wxWindowBase::Show(true))
352 {
353 wxShowEvent eventShow(win->GetId(), true);
354 eventShow.SetEventObject(win);
355 win->GetEventHandler()->ProcessEvent(eventShow);
356 }
357 return false;
358 }
359 }
360
361 //-----------------------------------------------------------------------------
362 // "unmap_event" from m_widget
363 //-----------------------------------------------------------------------------
364
365 extern "C" {
366 static gboolean
367 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
368 GdkEvent * WXUNUSED(event),
369 wxTopLevelWindow *win )
370 {
371 win->SetIconizeState(true);
372 return false;
373 }
374 }
375
376 //-----------------------------------------------------------------------------
377
378 bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
379 {
380 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
381 Atom xproperty = gdk_x11_atom_to_xatom_for_display(
382 gdk_drawable_get_display(window), property);
383 Atom type;
384 int format;
385 gulong nitems, bytes_after;
386 guchar* data;
387 Status status = XGetWindowProperty(
388 gdk_x11_drawable_get_xdisplay(window),
389 gdk_x11_drawable_get_xid(window),
390 xproperty,
391 0, 4, false, XA_CARDINAL,
392 &type, &format, &nitems, &bytes_after, &data);
393 const bool success = status == Success && data && nitems == 4;
394 if (success)
395 {
396 long* p = (long*)data;
397 if (left) *left = int(p[0]);
398 if (right) *right = int(p[1]);
399 if (top) *top = int(p[2]);
400 if (bottom) *bottom = int(p[3]);
401 }
402 if (data)
403 XFree(data);
404 return success;
405 }
406
407 //-----------------------------------------------------------------------------
408 // "property_notify_event" from m_widget
409 //-----------------------------------------------------------------------------
410
411 extern "C" {
412 static gboolean property_notify_event(
413 GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win)
414 {
415 // Watch for changes to _NET_FRAME_EXTENTS property
416 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
417 if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
418 {
419 int left, right, top, bottom;
420 if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom))
421 {
422 const wxSize decorSize =
423 wxSize(left + right, top + bottom);
424 win->GTKUpdateDecorSize(decorSize);
425 }
426 }
427 return false;
428 }
429 }
430
431 // ----------------------------------------------------------------------------
432 // wxTopLevelWindowGTK creation
433 // ----------------------------------------------------------------------------
434
435 void wxTopLevelWindowGTK::Init()
436 {
437 m_mainWidget = NULL;
438 m_isIconized = false;
439 m_fsIsShowing = false;
440 m_themeEnabled = true;
441 m_gdkDecor =
442 m_gdkFunc = 0;
443 m_grabbed = false;
444 m_deferShow = true;
445 m_deferShowAllowed = true;
446 m_updateDecorSize = true;
447
448 m_urgency_hint = -2;
449 }
450
451 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
452 wxWindowID id,
453 const wxString& title,
454 const wxPoint& pos,
455 const wxSize& sizeOrig,
456 long style,
457 const wxString &name )
458 {
459 // always create a frame of some reasonable, even if arbitrary, size (at
460 // least for MSW compatibility)
461 wxSize size = sizeOrig;
462 size.x = WidthDefault(size.x);
463 size.y = HeightDefault(size.y);
464
465 wxTopLevelWindows.Append( this );
466
467 if (!PreCreation( parent, pos, size ) ||
468 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
469 {
470 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
471 return false;
472 }
473
474 m_title = title;
475
476 // NB: m_widget may be !=NULL if it was created by derived class' Create,
477 // e.g. in wxTaskBarIconAreaGTK
478 if (m_widget == NULL)
479 {
480 #if wxUSE_LIBHILDON
481 // we must create HildonWindow and not a normal GtkWindow as the latter
482 // doesn't look correctly in Maemo environment and it must also be
483 // registered with the main program object
484 m_widget = hildon_window_new();
485 hildon_program_add_window(wxTheApp->GetHildonProgram(),
486 HILDON_WINDOW(m_widget));
487 #else // !wxUSE_LIBHILDON
488 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
489 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
490 {
491 // Tell WM that this is a dialog window and make it center
492 // on parent by default (this is what GtkDialog ctor does):
493 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
494 GDK_WINDOW_TYPE_HINT_DIALOG);
495 gtk_window_set_position(GTK_WINDOW(m_widget),
496 GTK_WIN_POS_CENTER_ON_PARENT);
497 }
498 else
499 {
500 if (style & wxFRAME_TOOL_WINDOW)
501 {
502 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
503 GDK_WINDOW_TYPE_HINT_UTILITY);
504
505 // On some WMs, like KDE, a TOOL_WINDOW will still show
506 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
507 // For consistency between WMs and with Windows, we
508 // should set the NO_TASKBAR flag which will apply
509 // the set_skip_taskbar_hint if it is available,
510 // ensuring no taskbar entry will appear.
511 style |= wxFRAME_NO_TASKBAR;
512 }
513 }
514 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
515
516 g_object_ref(m_widget);
517 }
518
519 wxWindow *topParent = wxGetTopLevelParent(m_parent);
520 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
521 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
522 (style & wxFRAME_FLOAT_ON_PARENT)))
523 {
524 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
525 GTK_WINDOW(topParent->m_widget) );
526 }
527
528 if (style & wxFRAME_NO_TASKBAR)
529 {
530 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
531 }
532
533 if (style & wxSTAY_ON_TOP)
534 {
535 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
536 }
537
538 #if 0
539 if (!name.empty())
540 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
541 #endif
542
543 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
544 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
545
546 g_signal_connect (m_widget, "delete_event",
547 G_CALLBACK (gtk_frame_delete_callback), this);
548
549 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
550 m_mainWidget = gtk_vbox_new(false, 0);
551 gtk_widget_show( m_mainWidget );
552 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
553 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
554
555 // m_wxwindow is the client area
556 m_wxwindow = wxPizza::New(0,this);
557 gtk_widget_show( m_wxwindow );
558 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
559
560 // we donm't allow the frame to get the focus as otherwise
561 // the frame will grab it at arbitrary focus changes
562 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
563
564 if (m_parent) m_parent->AddChild( this );
565
566 g_signal_connect(m_wxwindow, "size_allocate",
567 G_CALLBACK(size_allocate), this);
568
569 g_signal_connect (m_widget, "size_request",
570 G_CALLBACK (wxgtk_tlw_size_request_callback), this);
571 PostCreation();
572
573 if ((m_x != -1) || (m_y != -1))
574 gtk_widget_set_uposition( m_widget, m_x, m_y );
575
576 // we cannot set MWM hints and icons before the widget has
577 // been realized, so we do this directly after realization
578 g_signal_connect (m_widget, "realize",
579 G_CALLBACK (gtk_frame_realized_callback), this);
580
581 // map and unmap for iconized state
582 g_signal_connect (m_widget, "map_event",
583 G_CALLBACK (gtk_frame_map_callback), this);
584 g_signal_connect (m_widget, "unmap_event",
585 G_CALLBACK (gtk_frame_unmap_callback), this);
586
587 // for wxMoveEvent
588 g_signal_connect (m_widget, "configure_event",
589 G_CALLBACK (gtk_frame_configure_callback), this);
590
591 // activation
592 g_signal_connect_after (m_widget, "focus_in_event",
593 G_CALLBACK (gtk_frame_focus_in_callback), this);
594 g_signal_connect_after (m_widget, "focus_out_event",
595 G_CALLBACK (gtk_frame_focus_out_callback), this);
596
597 gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
598 g_signal_connect(m_widget, "property_notify_event",
599 G_CALLBACK(property_notify_event), this);
600
601 // translate wx decorations styles into Motif WM hints (they are recognized
602 // by other WMs as well)
603
604 // always enable moving the window as we have no separate flag for enabling
605 // it
606 m_gdkFunc = GDK_FUNC_MOVE;
607
608 if ( style & wxCLOSE_BOX )
609 m_gdkFunc |= GDK_FUNC_CLOSE;
610
611 if ( style & wxMINIMIZE_BOX )
612 m_gdkFunc |= GDK_FUNC_MINIMIZE;
613
614 if ( style & wxMAXIMIZE_BOX )
615 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
616
617 if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
618 {
619 m_gdkDecor = 0;
620 }
621 else // have border
622 {
623 m_gdkDecor = GDK_DECOR_BORDER;
624
625 if ( style & wxCAPTION )
626 m_gdkDecor |= GDK_DECOR_TITLE;
627
628 if ( style & wxSYSTEM_MENU )
629 m_gdkDecor |= GDK_DECOR_MENU;
630
631 if ( style & wxMINIMIZE_BOX )
632 m_gdkDecor |= GDK_DECOR_MINIMIZE;
633
634 if ( style & wxMAXIMIZE_BOX )
635 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
636
637 if ( style & wxRESIZE_BORDER )
638 {
639 m_gdkFunc |= GDK_FUNC_RESIZE;
640 m_gdkDecor |= GDK_DECOR_RESIZEH;
641 }
642 }
643
644 m_decorSize = GetCachedDecorSize();
645 int w, h;
646 GTKDoGetSize(&w, &h);
647 gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
648
649 return true;
650 }
651
652 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
653 {
654 #if wxUSE_LIBHILDON
655 // it can also be a (standard) dialog
656 if ( HILDON_IS_WINDOW(m_widget) )
657 {
658 hildon_program_remove_window(wxTheApp->GetHildonProgram(),
659 HILDON_WINDOW(m_widget));
660 }
661 #endif // wxUSE_LIBHILDON
662
663 if (m_grabbed)
664 {
665 wxFAIL_MSG(wxT("Window still grabbed"));
666 RemoveGrab();
667 }
668
669 SendDestroyEvent();
670
671 // it may also be GtkScrolledWindow in the case of an MDI child
672 if (GTK_IS_WINDOW(m_widget))
673 {
674 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
675 }
676
677 if (g_activeFrame == this)
678 g_activeFrame = NULL;
679 if (g_lastActiveFrame == this)
680 g_lastActiveFrame = NULL;
681 }
682
683 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
684 {
685 if (enable)
686 m_gdkFunc |= GDK_FUNC_CLOSE;
687 else
688 m_gdkFunc &= ~GDK_FUNC_CLOSE;
689
690 if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
691 gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
692
693 return true;
694 }
695
696 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
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 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
708 // to switch to fullscreen, which is not always available. We must
709 // check if WM supports the spec and use legacy methods if it
710 // doesn't.
711 if ( method == wxX11_FS_WMSPEC )
712 {
713 if (show)
714 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
715 else
716 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
717 }
718 else
719 {
720 GdkWindow *window = m_widget->window;
721
722 if (show)
723 {
724 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
725 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
726
727 int screen_width,screen_height;
728 wxDisplaySize( &screen_width, &screen_height );
729
730 gint client_x, client_y, root_x, root_y;
731 gint width, height;
732
733 m_fsSaveGdkFunc = m_gdkFunc;
734 m_fsSaveGdkDecor = m_gdkDecor;
735 m_gdkFunc = m_gdkDecor = 0;
736 gdk_window_set_decorations(window, (GdkWMDecoration)0);
737 gdk_window_set_functions(window, (GdkWMFunction)0);
738
739 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
740 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
741 &width, &height, NULL);
742
743 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
744 screen_width + 1, screen_height + 1);
745
746 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
747 (WXWindow)GDK_ROOT_WINDOW(),
748 (WXWindow)GDK_WINDOW_XWINDOW(window),
749 show, &m_fsSaveFrame, method);
750 }
751 else // hide
752 {
753 m_gdkFunc = m_fsSaveGdkFunc;
754 m_gdkDecor = m_fsSaveGdkDecor;
755 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
756 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
757
758 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
759 (WXWindow)GDK_ROOT_WINDOW(),
760 (WXWindow)GDK_WINDOW_XWINDOW(window),
761 show, &m_fsSaveFrame, method);
762
763 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
764 m_fsSaveFrame.width, m_fsSaveFrame.height);
765 }
766 }
767
768 // documented behaviour is to show the window if it's still hidden when
769 // showing it full screen
770 if (show)
771 Show();
772
773 return true;
774 }
775
776 // ----------------------------------------------------------------------------
777 // overridden wxWindow methods
778 // ----------------------------------------------------------------------------
779
780 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) )
781 {
782 wxCHECK_RET( m_widget, wxT("invalid frame") );
783
784 gtk_widget_queue_draw( m_widget );
785
786 if (m_wxwindow && m_wxwindow->window)
787 gdk_window_invalidate_rect( m_wxwindow->window, NULL, TRUE );
788 }
789
790 bool wxTopLevelWindowGTK::Show( bool show )
791 {
792 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
793
794 bool deferShow = show && !m_isShown && m_deferShow && m_deferShowAllowed;
795 if (deferShow)
796 {
797 deferShow = false;
798 if (!GTK_WIDGET_REALIZED(m_widget) &&
799 g_signal_handler_find(m_widget,
800 GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
801 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
802 0, NULL, NULL, this))
803 {
804 if (gdk_x11_screen_supports_net_wm_hint(
805 gtk_widget_get_screen(m_widget),
806 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)))
807 {
808 deferShow = true;
809 }
810 else
811 {
812 // Don't allow changes to m_decorSize, it breaks saving/restoring
813 // window size with GetSize()/SetSize() because it makes window
814 // bigger between each restore and save.
815 m_updateDecorSize = false;
816 }
817 }
818 m_deferShow = deferShow;
819 }
820 if (deferShow)
821 {
822 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
823 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
824 // notification is received, so correct frame extents are known.
825 // This allows resizing m_widget to keep the overall size in sync with
826 // what wxWidgets expects it to be without an obvious change in the
827 // window size immediately after it becomes visible.
828
829 // Realize m_widget, so m_widget->window can be used. Realizing normally
830 // causes the widget tree to be size_allocated, which generates size
831 // events in the wrong order. However, the size_allocates will not be
832 // done if the allocation is not the default (1,1).
833 const int alloc_width = m_widget->allocation.width;
834 if (alloc_width == 1)
835 m_widget->allocation.width = 2;
836 gtk_widget_realize(m_widget);
837 if (alloc_width == 1)
838 m_widget->allocation.width = 1;
839
840 // send _NET_REQUEST_FRAME_EXTENTS
841 XClientMessageEvent xevent;
842 memset(&xevent, 0, sizeof(xevent));
843 xevent.type = ClientMessage;
844 xevent.window = gdk_x11_drawable_get_xid(m_widget->window);
845 xevent.message_type = gdk_x11_atom_to_xatom_for_display(
846 gdk_drawable_get_display(m_widget->window),
847 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
848 xevent.format = 32;
849 Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window);
850 XSendEvent(display, DefaultRootWindow(display), false,
851 SubstructureNotifyMask | SubstructureRedirectMask,
852 (XEvent*)&xevent);
853
854 // defer calling gtk_widget_show()
855 m_isShown = true;
856 return true;
857 }
858
859 if (show && !GTK_WIDGET_REALIZED(m_widget))
860 {
861 // size_allocate signals occur in reverse order (bottom to top).
862 // Things work better if the initial wxSizeEvents are sent (from the
863 // top down), before the initial size_allocate signals occur.
864 wxSizeEvent event(GetSize(), GetId());
865 event.SetEventObject(this);
866 HandleWindowEvent(event);
867 }
868
869 bool change = wxTopLevelWindowBase::Show(show);
870
871 if (change && !show)
872 {
873 // make sure window has a non-default position, so when it is shown
874 // again, it won't be repositioned by WM as if it were a new window
875 // Note that this must be done _after_ the window is hidden.
876 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
877 }
878
879 return change;
880 }
881
882 void wxTopLevelWindowGTK::Raise()
883 {
884 gtk_window_present( GTK_WINDOW( m_widget ) );
885 }
886
887 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
888 {
889 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
890 }
891
892 // ----------------------------------------------------------------------------
893 // window geometry
894 // ----------------------------------------------------------------------------
895
896 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
897 {
898 wxSize size(m_width, m_height);
899 size -= m_decorSize;
900 if (size.x < 0) size.x = 0;
901 if (size.y < 0) size.y = 0;
902 if (width) *width = size.x;
903 if (height) *height = size.y;
904 }
905
906 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
907 {
908 wxCHECK_RET( m_widget, wxT("invalid frame") );
909
910 m_deferShowAllowed = true;
911
912 // deal with the position first
913 int old_x = m_x;
914 int old_y = m_y;
915
916 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
917 {
918 // -1 means "use existing" unless the flag above is specified
919 if ( x != -1 )
920 m_x = x;
921 if ( y != -1 )
922 m_y = y;
923 }
924 else // wxSIZE_ALLOW_MINUS_ONE
925 {
926 m_x = x;
927 m_y = y;
928 }
929
930 if ( m_x != old_x || m_y != old_y )
931 {
932 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
933 }
934
935 const wxSize oldSize(m_width, m_height);
936 if (width >= 0)
937 m_width = width;
938 if (height >= 0)
939 m_height = height;
940 ConstrainSize();
941 if (m_width != oldSize.x || m_height != oldSize.y)
942 {
943 int w, h;
944 GTKDoGetSize(&w, &h);
945 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
946
947 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
948 wxSizeEvent event(GetSize(), GetId());
949 event.SetEventObject(this);
950 HandleWindowEvent(event);
951 }
952 }
953
954 void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
955 {
956 // Since client size is being explicitly set, don't change it later
957 m_deferShowAllowed = false;
958
959 wxTopLevelWindowBase::DoSetClientSize(width, height);
960 }
961
962 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
963 {
964 wxASSERT_MSG(m_widget, wxT("invalid frame"));
965
966 if ( IsIconized() )
967 {
968 // for consistency with wxMSW, client area is supposed to be empty for
969 // the iconized windows
970 if ( width )
971 *width = 0;
972 if ( height )
973 *height = 0;
974 }
975 else
976 {
977 GTKDoGetSize(width, height);
978 }
979 }
980
981 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
982 int maxW, int maxH,
983 int incW, int incH )
984 {
985 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
986
987 const wxSize minSize = GetMinSize();
988 const wxSize maxSize = GetMaxSize();
989 GdkGeometry hints;
990 int hints_mask = 0;
991 if (minSize.x > 0 || minSize.y > 0)
992 {
993 hints_mask |= GDK_HINT_MIN_SIZE;
994 hints.min_width = minSize.x - m_decorSize.x;
995 if (hints.min_width < 0)
996 hints.min_width = 0;
997 hints.min_height = minSize.y - m_decorSize.y;
998 if (hints.min_height < 0)
999 hints.min_height = 0;
1000 }
1001 if (maxSize.x > 0 || maxSize.y > 0)
1002 {
1003 hints_mask |= GDK_HINT_MAX_SIZE;
1004 hints.max_width = maxSize.x - m_decorSize.x;
1005 if (hints.max_width < 0)
1006 hints.max_width = INT_MAX;
1007 hints.max_height = maxSize.y - m_decorSize.y;
1008 if (hints.max_height < 0)
1009 hints.max_height = INT_MAX;
1010 }
1011 if (incW > 0 || incH > 0)
1012 {
1013 hints_mask |= GDK_HINT_RESIZE_INC;
1014 hints.width_inc = incW > 0 ? incW : 1;
1015 hints.height_inc = incH > 0 ? incH : 1;
1016 }
1017 gtk_window_set_geometry_hints(
1018 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1019 }
1020
1021 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
1022 {
1023 if (!IsMaximized() && !IsFullScreen())
1024 GetCachedDecorSize() = decorSize;
1025 if (m_updateDecorSize && m_decorSize != decorSize)
1026 {
1027 const wxSize diff = decorSize - m_decorSize;
1028 m_decorSize = decorSize;
1029 bool resized = false;
1030 if (m_deferShow)
1031 {
1032 // keep overall size unchanged by shrinking m_widget
1033 int w, h;
1034 GTKDoGetSize(&w, &h);
1035 // but not if size would be less than minimum, it won't take effect
1036 const wxSize minSize = GetMinSize();
1037 if (w >= minSize.x && h >= minSize.y)
1038 {
1039 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1040 resized = true;
1041 }
1042 }
1043 if (!resized)
1044 {
1045 // adjust overall size to match change in frame extents
1046 m_width += diff.x;
1047 m_height += diff.y;
1048 if (m_width < 0) m_width = 0;
1049 if (m_height < 0) m_height = 0;
1050 m_oldClientWidth = 0;
1051 gtk_widget_queue_resize(m_wxwindow);
1052 }
1053 }
1054 if (m_deferShow)
1055 {
1056 // gtk_widget_show() was deferred, do it now
1057 m_deferShow = false;
1058 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1059 wxSizeEvent sizeEvent(GetSize(), GetId());
1060 sizeEvent.SetEventObject(this);
1061 HandleWindowEvent(sizeEvent);
1062
1063 gtk_widget_show(m_widget);
1064
1065 wxShowEvent showEvent(GetId(), true);
1066 showEvent.SetEventObject(this);
1067 HandleWindowEvent(showEvent);
1068 }
1069 }
1070
1071 wxSize& wxTopLevelWindowGTK::GetCachedDecorSize()
1072 {
1073 static wxSize size[8];
1074
1075 int index = 0;
1076 // title bar
1077 if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
1078 index = 1;
1079 // border
1080 if (m_gdkDecor & GDK_DECOR_BORDER)
1081 index |= 2;
1082 // utility window decor can be different
1083 if (m_windowStyle & wxFRAME_TOOL_WINDOW)
1084 index |= 4;
1085 return size[index];
1086 }
1087
1088 void wxTopLevelWindowGTK::OnInternalIdle()
1089 {
1090 wxWindow::OnInternalIdle();
1091
1092 // Synthetize activate events.
1093 if ( g_sendActivateEvent != -1 )
1094 {
1095 bool activate = g_sendActivateEvent != 0;
1096
1097 // if (!activate) wxPrintf( wxT("de") );
1098 // wxPrintf( wxT("activate\n") );
1099
1100 // do it only once
1101 g_sendActivateEvent = -1;
1102
1103 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1104 }
1105 }
1106
1107 // ----------------------------------------------------------------------------
1108 // frame title/icon
1109 // ----------------------------------------------------------------------------
1110
1111 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1112 {
1113 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1114
1115 if ( title == m_title )
1116 return;
1117
1118 m_title = title;
1119
1120 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1121 }
1122
1123 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1124 {
1125 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1126
1127 wxTopLevelWindowBase::SetIcons( icons );
1128
1129 // Setting icons before window is realized can cause a GTK assertion if
1130 // another TLW is realized before this one, and it has this one as it's
1131 // transient parent. The life demo exibits this problem.
1132 if (GTK_WIDGET_REALIZED(m_widget))
1133 {
1134 GList* list = NULL;
1135 for (size_t i = icons.GetIconCount(); i--;)
1136 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1137 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1138 g_list_free(list);
1139 }
1140 }
1141
1142 // ----------------------------------------------------------------------------
1143 // frame state: maximized/iconized/normal
1144 // ----------------------------------------------------------------------------
1145
1146 void wxTopLevelWindowGTK::Maximize(bool maximize)
1147 {
1148 if (maximize)
1149 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1150 else
1151 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1152 }
1153
1154 bool wxTopLevelWindowGTK::IsMaximized() const
1155 {
1156 if(!m_widget->window)
1157 return false;
1158
1159 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1160 }
1161
1162 void wxTopLevelWindowGTK::Restore()
1163 {
1164 // "Present" seems similar enough to "restore"
1165 gtk_window_present( GTK_WINDOW( m_widget ) );
1166 }
1167
1168 void wxTopLevelWindowGTK::Iconize( bool iconize )
1169 {
1170 if (iconize)
1171 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1172 else
1173 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1174 }
1175
1176 bool wxTopLevelWindowGTK::IsIconized() const
1177 {
1178 return m_isIconized;
1179 }
1180
1181 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1182 {
1183 if ( iconize != m_isIconized )
1184 {
1185 m_isIconized = iconize;
1186 (void)SendIconizeEvent(iconize);
1187 }
1188 }
1189
1190 void wxTopLevelWindowGTK::AddGrab()
1191 {
1192 if (!m_grabbed)
1193 {
1194 m_grabbed = true;
1195 gtk_grab_add( m_widget );
1196 wxGUIEventLoop().Run();
1197 gtk_grab_remove( m_widget );
1198 }
1199 }
1200
1201 void wxTopLevelWindowGTK::RemoveGrab()
1202 {
1203 if (m_grabbed)
1204 {
1205 gtk_main_quit();
1206 m_grabbed = false;
1207 }
1208 }
1209
1210
1211 // helper
1212 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1213 {
1214 if (window)
1215 {
1216 if (region.IsEmpty())
1217 {
1218 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1219 }
1220 else
1221 {
1222 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1223 return true;
1224 }
1225 }
1226 return false;
1227 }
1228
1229
1230 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1231 {
1232 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1233 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));
1234
1235 if ( GTK_WIDGET_REALIZED(m_widget) )
1236 {
1237 if ( m_wxwindow )
1238 do_shape_combine_region(m_wxwindow->window, region);
1239
1240 return do_shape_combine_region(m_widget->window, region);
1241 }
1242 else // not realized yet
1243 {
1244 // store the shape to set, it will be really set once we're realized
1245 m_shape = region;
1246
1247 // we don't know if we're going to succeed or fail, be optimistic by
1248 // default
1249 return true;
1250 }
1251 }
1252
1253 bool wxTopLevelWindowGTK::IsActive()
1254 {
1255 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1256 }
1257
1258 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1259 {
1260 bool new_hint_value = false;
1261
1262 // FIXME: This is a workaround to focus handling problem
1263 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1264 // hasn't yet been processed, and the internal focus system is not up to date yet.
1265 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1266 // won't have side effects) - MR
1267 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI);
1268
1269 if(m_urgency_hint >= 0)
1270 g_source_remove(m_urgency_hint);
1271
1272 m_urgency_hint = -2;
1273
1274 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1275 {
1276 new_hint_value = true;
1277
1278 if (flags & wxUSER_ATTENTION_INFO)
1279 {
1280 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1281 } else {
1282 m_urgency_hint = -1;
1283 }
1284 }
1285
1286 #if GTK_CHECK_VERSION(2,7,0)
1287 if(!gtk_check_version(2,7,0))
1288 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1289 else
1290 #endif
1291 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1292 }
1293
1294 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1295 {
1296 // Store which styles were changed
1297 long styleChanges = style ^ m_windowStyle;
1298
1299 // Process wxWindow styles. This also updates the internal variable
1300 // Therefore m_windowStyle bits carry now the _new_ style values
1301 wxWindow::SetWindowStyleFlag(style);
1302
1303 // just return for now if widget does not exist yet
1304 if (!m_widget)
1305 return;
1306
1307 if ( styleChanges & wxSTAY_ON_TOP )
1308 {
1309 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1310 m_windowStyle & wxSTAY_ON_TOP);
1311 }
1312
1313 if ( styleChanges & wxFRAME_NO_TASKBAR )
1314 {
1315 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1316 m_windowStyle & wxFRAME_NO_TASKBAR);
1317 }
1318 }
1319
1320 /* Get the X Window between child and the root window.
1321 This should usually be the WM managed XID */
1322 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1323 {
1324 Window root, parent;
1325 Window* children;
1326 unsigned int nchildren;
1327
1328 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1329 XFree(children);
1330
1331 while (parent != root) {
1332 child = parent;
1333 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1334 XFree(children);
1335 }
1336
1337 return child;
1338 }
1339
1340 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1341 {
1342 if (!m_widget || !m_widget->window)
1343 return false;
1344
1345 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1346 // We need to get the X Window that has the root window as the immediate parent
1347 // and m_widget->window as a child. This should be the X Window that the WM manages and
1348 // from which the opacity property is checked from.
1349 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1350
1351
1352 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1353 if (alpha == 0xff)
1354 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1355 else
1356 {
1357 long opacity = alpha * 0x1010101L;
1358 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1359 XA_CARDINAL, 32, PropModeReplace,
1360 (unsigned char *) &opacity, 1L);
1361 }
1362 XSync(dpy, False);
1363 return true;
1364 }
1365
1366 bool wxTopLevelWindowGTK::CanSetTransparent()
1367 {
1368 // allow to override automatic detection as it's far from perfect
1369 static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1370 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1371 {
1372 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1373 }
1374
1375 #if GTK_CHECK_VERSION(2,10,0)
1376 if (!gtk_check_version(2,10,0))
1377 {
1378 return (gtk_widget_is_composited (m_widget));
1379 }
1380 else
1381 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1382 {
1383 return false;
1384 }
1385
1386 #if 0 // Don't be optimistic here for the sake of wxAUI
1387 int opcode, event, error;
1388 // Check for the existence of a RGBA visual instead?
1389 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1390 "Composite", &opcode, &event, &error);
1391 #endif
1392 }