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


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