]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/toplevel.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Also update focus rect when changing selection in single selection mode, fixes #11332
[wxWidgets.git] / src / gtk / toplevel.cpp
... / ...
CommitLineData
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#if wxUSE_LIBHILDON2
54 #include <hildon/hildon.h>
55#endif // wxUSE_LIBHILDON2
56
57// ----------------------------------------------------------------------------
58// data
59// ----------------------------------------------------------------------------
60
61// this is incremented while a modal dialog is shown
62int wxOpenModalDialogsCount = 0;
63
64// the frame that is currently active (i.e. its child has focus). It is
65// used to generate wxActivateEvents
66static wxTopLevelWindowGTK *g_activeFrame = NULL;
67static wxTopLevelWindowGTK *g_lastActiveFrame = NULL;
68
69// if we detect that the app has got/lost the focus, we set this variable to
70// either TRUE or FALSE and an activate event will be sent during the next
71// OnIdle() call and it is reset to -1: this value means that we shouldn't
72// send any activate events at all
73static int g_sendActivateEvent = -1;
74
75//-----------------------------------------------------------------------------
76// RequestUserAttention related functions
77//-----------------------------------------------------------------------------
78
79extern "C" {
80static void wxgtk_window_set_urgency_hint (GtkWindow *win,
81 gboolean setting)
82{
83 wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
84 GdkWindow *window = GTK_WIDGET(win)->window;
85 XWMHints *wm_hints;
86
87 wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
88
89 if (!wm_hints)
90 wm_hints = XAllocWMHints();
91
92 if (setting)
93 wm_hints->flags |= XUrgencyHint;
94 else
95 wm_hints->flags &= ~XUrgencyHint;
96
97 XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
98 XFree(wm_hints);
99}
100
101static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
102{
103#if GTK_CHECK_VERSION(2,7,0)
104 if(!gtk_check_version(2,7,0))
105 gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
106 else
107#endif
108 wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
109
110 win->m_urgency_hint = -2;
111 return FALSE;
112}
113}
114
115//-----------------------------------------------------------------------------
116// "focus_in_event"
117//-----------------------------------------------------------------------------
118
119extern "C" {
120static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
121 GdkEvent *WXUNUSED(event),
122 wxTopLevelWindowGTK *win )
123{
124 switch ( g_sendActivateEvent )
125 {
126 case -1:
127 // we've got focus from outside, synthetize wxActivateEvent
128 g_sendActivateEvent = 1;
129 break;
130
131 case 0:
132 // another our window just lost focus, it was already ours before
133 // - don't send any wxActivateEvent
134 g_sendActivateEvent = -1;
135 break;
136 }
137
138 g_activeFrame = win;
139 g_lastActiveFrame = g_activeFrame;
140
141 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
142
143 // MR: wxRequestUserAttention related block
144 switch( win->m_urgency_hint )
145 {
146 default:
147 g_source_remove( win->m_urgency_hint );
148 // no break, fallthrough to remove hint too
149 case -1:
150#if GTK_CHECK_VERSION(2,7,0)
151 if(!gtk_check_version(2,7,0))
152 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
153 else
154#endif
155 {
156 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
157 }
158
159 win->m_urgency_hint = -2;
160 break;
161
162 case -2: break;
163 }
164
165 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
166 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
167 event.SetEventObject(g_activeFrame);
168 g_activeFrame->HandleWindowEvent(event);
169
170 return FALSE;
171}
172}
173
174//-----------------------------------------------------------------------------
175// "focus_out_event"
176//-----------------------------------------------------------------------------
177
178extern "C" {
179static
180gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget),
181 GdkEventFocus *WXUNUSED(gdk_event),
182 wxTopLevelWindowGTK * WXUNUSED(win))
183{
184 // if the focus goes out of our app alltogether, OnIdle() will send
185 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
186 // g_sendActivateEvent to -1
187 g_sendActivateEvent = 0;
188
189 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
190
191 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
192
193 if (g_activeFrame)
194 {
195 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
196 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
197 event.SetEventObject(g_activeFrame);
198 g_activeFrame->HandleWindowEvent(event);
199
200 g_activeFrame = NULL;
201 }
202
203 return FALSE;
204}
205}
206
207//-----------------------------------------------------------------------------
208// "size_allocate" from m_wxwindow
209//-----------------------------------------------------------------------------
210
211extern "C" {
212static void
213size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
214{
215 if (win->m_oldClientWidth != alloc->width ||
216 win->m_oldClientHeight != alloc->height)
217 {
218 win->m_oldClientWidth = alloc->width;
219 win->m_oldClientHeight = alloc->height;
220
221 wxSize size(win->m_widget->allocation.width,
222 win->m_widget->allocation.height);
223 size += win->m_decorSize;
224 win->m_width = size.x;
225 win->m_height = size.y;
226
227 if (!win->IsIconized())
228 {
229 wxSizeEvent event(size, win->GetId());
230 event.SetEventObject(win);
231 win->HandleWindowEvent(event);
232 }
233 // else the window is currently unmapped, don't generate size events
234 }
235}
236}
237
238// ----------------------------------------------------------------------------
239// "size_request"
240// ----------------------------------------------------------------------------
241
242extern "C" {
243static
244void 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
258extern "C" {
259static gboolean
260gtk_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
277extern "C" {
278static gboolean
279gtk_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
306extern "C" {
307static void
308gtk_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
335extern "C" {
336static gboolean
337gtk_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 // restore focus-on-map setting in case ShowWithoutActivating() was called
362 gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true);
363 return false;
364}
365}
366
367//-----------------------------------------------------------------------------
368// "unmap_event" from m_widget
369//-----------------------------------------------------------------------------
370
371extern "C" {
372static gboolean
373gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
374 GdkEvent * WXUNUSED(event),
375 wxTopLevelWindow *win )
376{
377 win->SetIconizeState(true);
378 return false;
379}
380}
381
382//-----------------------------------------------------------------------------
383
384bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
385{
386 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
387 Atom xproperty = gdk_x11_atom_to_xatom_for_display(
388 gdk_drawable_get_display(window), property);
389 Atom type;
390 int format;
391 gulong nitems, bytes_after;
392 guchar* data;
393 Status status = XGetWindowProperty(
394 gdk_x11_drawable_get_xdisplay(window),
395 gdk_x11_drawable_get_xid(window),
396 xproperty,
397 0, 4, false, XA_CARDINAL,
398 &type, &format, &nitems, &bytes_after, &data);
399 const bool success = status == Success && data && nitems == 4;
400 if (success)
401 {
402 long* p = (long*)data;
403 if (left) *left = int(p[0]);
404 if (right) *right = int(p[1]);
405 if (top) *top = int(p[2]);
406 if (bottom) *bottom = int(p[3]);
407 }
408 if (data)
409 XFree(data);
410 return success;
411}
412
413//-----------------------------------------------------------------------------
414// "property_notify_event" from m_widget
415//-----------------------------------------------------------------------------
416
417extern "C" {
418static gboolean property_notify_event(
419 GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win)
420{
421 // Watch for changes to _NET_FRAME_EXTENTS property
422 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
423 if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
424 {
425 wxSize decorSize = win->m_decorSize;
426 int left, right, top, bottom;
427 if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom))
428 decorSize.Set(left + right, top + bottom);
429
430 win->GTKUpdateDecorSize(decorSize);
431 }
432 return false;
433}
434}
435
436// ----------------------------------------------------------------------------
437// wxTopLevelWindowGTK creation
438// ----------------------------------------------------------------------------
439
440void wxTopLevelWindowGTK::Init()
441{
442 m_mainWidget = NULL;
443 m_isIconized = false;
444 m_fsIsShowing = false;
445 m_themeEnabled = true;
446 m_gdkDecor =
447 m_gdkFunc = 0;
448 m_grabbed = false;
449 m_deferShow = true;
450 m_deferShowAllowed = true;
451 m_updateDecorSize = true;
452
453 m_urgency_hint = -2;
454}
455
456bool 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 || wxUSE_LIBHILDON2
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 || !wxUSE_LIBHILDON2
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_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
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(0,this);
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
657wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
658{
659#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
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 || wxUSE_LIBHILDON2
667
668 if (m_grabbed)
669 {
670 wxFAIL_MSG(wxT("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
688bool 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
701bool 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
785void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) )
786{
787 wxCHECK_RET( m_widget, wxT("invalid frame") );
788
789 gtk_widget_queue_draw( m_widget );
790
791 if (m_wxwindow && m_wxwindow->window)
792 gdk_window_invalidate_rect( m_wxwindow->window, NULL, TRUE );
793}
794
795bool wxTopLevelWindowGTK::Show( bool show )
796{
797 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
798
799 bool deferShow = show && !m_isShown && m_deferShow;
800 if (deferShow)
801 {
802 deferShow = m_deferShowAllowed && !GTK_WIDGET_REALIZED(m_widget);
803 if (deferShow)
804 {
805 deferShow = g_signal_handler_find(m_widget,
806 GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
807 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
808 0, NULL, NULL, this) != 0;
809 }
810 GdkScreen* screen = NULL;
811 if (deferShow)
812 {
813 screen = gtk_widget_get_screen(m_widget);
814 GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
815 deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
816 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
817 // to m_decorSize, it breaks saving/restoring window size with
818 // GetSize()/SetSize() because it makes window bigger between each
819 // restore and save.
820 m_updateDecorSize = deferShow;
821 }
822 if (deferShow)
823 {
824 // Fluxbox support for _NET_REQUEST_FRAME_EXTENTS is broken
825 const char* name = gdk_x11_screen_get_window_manager_name(screen);
826 deferShow = strcmp(name, "Fluxbox") != 0;
827 m_updateDecorSize = deferShow;
828 }
829
830 m_deferShow = deferShow;
831 }
832 if (deferShow)
833 {
834 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
835 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
836 // notification is received, so correct frame extents are known.
837 // This allows resizing m_widget to keep the overall size in sync with
838 // what wxWidgets expects it to be without an obvious change in the
839 // window size immediately after it becomes visible.
840
841 // Realize m_widget, so m_widget->window can be used. Realizing normally
842 // causes the widget tree to be size_allocated, which generates size
843 // events in the wrong order. However, the size_allocates will not be
844 // done if the allocation is not the default (1,1).
845 const int alloc_width = m_widget->allocation.width;
846 if (alloc_width == 1)
847 m_widget->allocation.width = 2;
848 gtk_widget_realize(m_widget);
849 if (alloc_width == 1)
850 m_widget->allocation.width = 1;
851
852 // send _NET_REQUEST_FRAME_EXTENTS
853 XClientMessageEvent xevent;
854 memset(&xevent, 0, sizeof(xevent));
855 xevent.type = ClientMessage;
856 xevent.window = gdk_x11_drawable_get_xid(m_widget->window);
857 xevent.message_type = gdk_x11_atom_to_xatom_for_display(
858 gdk_drawable_get_display(m_widget->window),
859 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
860 xevent.format = 32;
861 Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window);
862 XSendEvent(display, DefaultRootWindow(display), false,
863 SubstructureNotifyMask | SubstructureRedirectMask,
864 (XEvent*)&xevent);
865
866 // defer calling gtk_widget_show()
867 m_isShown = true;
868 return true;
869 }
870
871 if (show && !GTK_WIDGET_REALIZED(m_widget))
872 {
873 // size_allocate signals occur in reverse order (bottom to top).
874 // Things work better if the initial wxSizeEvents are sent (from the
875 // top down), before the initial size_allocate signals occur.
876 wxSizeEvent event(GetSize(), GetId());
877 event.SetEventObject(this);
878 HandleWindowEvent(event);
879 }
880
881 bool change = wxTopLevelWindowBase::Show(show);
882
883 if (change && !show)
884 {
885 // make sure window has a non-default position, so when it is shown
886 // again, it won't be repositioned by WM as if it were a new window
887 // Note that this must be done _after_ the window is hidden.
888 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
889 }
890
891 return change;
892}
893
894void wxTopLevelWindowGTK::ShowWithoutActivating()
895{
896 if (!m_isShown)
897 {
898 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
899 Show(true);
900 }
901}
902
903void wxTopLevelWindowGTK::Raise()
904{
905 gtk_window_present( GTK_WINDOW( m_widget ) );
906}
907
908void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
909{
910 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
911}
912
913// ----------------------------------------------------------------------------
914// window geometry
915// ----------------------------------------------------------------------------
916
917void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
918{
919 wxSize size(m_width, m_height);
920 size -= m_decorSize;
921 if (size.x < 0) size.x = 0;
922 if (size.y < 0) size.y = 0;
923#if wxUSE_LIBHILDON2
924 if (width) {
925 if (size.x == 720)
926 *width = 696;
927 else
928 *width = size.x;
929 }
930 if (height) {
931 if (size.y == 420)
932 *height = 396;
933 else if (size.y == 270)
934 *height = 246;
935 else
936 *height = size.y;
937 }
938#else // wxUSE_LIBHILDON2
939 if (width) *width = size.x;
940 if (height) *height = size.y;
941#endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
942}
943
944void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
945{
946 wxCHECK_RET( m_widget, wxT("invalid frame") );
947
948 m_deferShowAllowed = true;
949
950 // deal with the position first
951 int old_x = m_x;
952 int old_y = m_y;
953
954 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
955 {
956 // -1 means "use existing" unless the flag above is specified
957 if ( x != -1 )
958 m_x = x;
959 if ( y != -1 )
960 m_y = y;
961 }
962 else // wxSIZE_ALLOW_MINUS_ONE
963 {
964 m_x = x;
965 m_y = y;
966 }
967
968 if ( m_x != old_x || m_y != old_y )
969 {
970 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
971 }
972
973 const wxSize oldSize(m_width, m_height);
974 if (width >= 0)
975 m_width = width;
976 if (height >= 0)
977 m_height = height;
978 ConstrainSize();
979 if (m_width != oldSize.x || m_height != oldSize.y)
980 {
981 int w, h;
982 GTKDoGetSize(&w, &h);
983 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
984
985 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
986 wxSizeEvent event(GetSize(), GetId());
987 event.SetEventObject(this);
988 HandleWindowEvent(event);
989 }
990}
991
992void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
993{
994 // Since client size is being explicitly set, don't change it later
995 m_deferShowAllowed = false;
996
997 wxTopLevelWindowBase::DoSetClientSize(width, height);
998}
999
1000void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
1001{
1002 wxASSERT_MSG(m_widget, wxT("invalid frame"));
1003
1004 if ( IsIconized() )
1005 {
1006 // for consistency with wxMSW, client area is supposed to be empty for
1007 // the iconized windows
1008 if ( width )
1009 *width = 0;
1010 if ( height )
1011 *height = 0;
1012 }
1013 else
1014 {
1015 GTKDoGetSize(width, height);
1016 }
1017}
1018
1019void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
1020 int maxW, int maxH,
1021 int incW, int incH )
1022{
1023 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
1024
1025 const wxSize minSize = GetMinSize();
1026 const wxSize maxSize = GetMaxSize();
1027 GdkGeometry hints;
1028 int hints_mask = 0;
1029 if (minSize.x > 0 || minSize.y > 0)
1030 {
1031 hints_mask |= GDK_HINT_MIN_SIZE;
1032 hints.min_width = minSize.x - m_decorSize.x;
1033 if (hints.min_width < 0)
1034 hints.min_width = 0;
1035 hints.min_height = minSize.y - m_decorSize.y;
1036 if (hints.min_height < 0)
1037 hints.min_height = 0;
1038 }
1039 if (maxSize.x > 0 || maxSize.y > 0)
1040 {
1041 hints_mask |= GDK_HINT_MAX_SIZE;
1042 hints.max_width = maxSize.x - m_decorSize.x;
1043 if (hints.max_width < 0)
1044 hints.max_width = INT_MAX;
1045 hints.max_height = maxSize.y - m_decorSize.y;
1046 if (hints.max_height < 0)
1047 hints.max_height = INT_MAX;
1048 }
1049 if (incW > 0 || incH > 0)
1050 {
1051 hints_mask |= GDK_HINT_RESIZE_INC;
1052 hints.width_inc = incW > 0 ? incW : 1;
1053 hints.height_inc = incH > 0 ? incH : 1;
1054 }
1055 gtk_window_set_geometry_hints(
1056 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1057}
1058
1059void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
1060{
1061 if (!IsMaximized() && !IsFullScreen())
1062 GetCachedDecorSize() = decorSize;
1063 if (m_updateDecorSize && m_decorSize != decorSize)
1064 {
1065 const wxSize diff = decorSize - m_decorSize;
1066 m_decorSize = decorSize;
1067 bool resized = false;
1068 if (m_deferShow)
1069 {
1070 // keep overall size unchanged by shrinking m_widget
1071 int w, h;
1072 GTKDoGetSize(&w, &h);
1073 // but not if size would be less than minimum, it won't take effect
1074 const wxSize minSize = GetMinSize();
1075 if (w >= minSize.x && h >= minSize.y)
1076 {
1077 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1078 resized = true;
1079 }
1080 }
1081 if (!resized)
1082 {
1083 // adjust overall size to match change in frame extents
1084 m_width += diff.x;
1085 m_height += diff.y;
1086 if (m_width < 0) m_width = 0;
1087 if (m_height < 0) m_height = 0;
1088 m_oldClientWidth = 0;
1089 gtk_widget_queue_resize(m_wxwindow);
1090 }
1091 }
1092 if (m_deferShow)
1093 {
1094 // gtk_widget_show() was deferred, do it now
1095 m_deferShow = false;
1096 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1097 wxSizeEvent sizeEvent(GetSize(), GetId());
1098 sizeEvent.SetEventObject(this);
1099 HandleWindowEvent(sizeEvent);
1100
1101 gtk_widget_show(m_widget);
1102
1103 wxShowEvent showEvent(GetId(), true);
1104 showEvent.SetEventObject(this);
1105 HandleWindowEvent(showEvent);
1106 }
1107}
1108
1109wxSize& wxTopLevelWindowGTK::GetCachedDecorSize()
1110{
1111 static wxSize size[8];
1112
1113 int index = 0;
1114 // title bar
1115 if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
1116 index = 1;
1117 // border
1118 if (m_gdkDecor & GDK_DECOR_BORDER)
1119 index |= 2;
1120 // utility window decor can be different
1121 if (m_windowStyle & wxFRAME_TOOL_WINDOW)
1122 index |= 4;
1123 return size[index];
1124}
1125
1126void wxTopLevelWindowGTK::OnInternalIdle()
1127{
1128 wxWindow::OnInternalIdle();
1129
1130 // Synthetize activate events.
1131 if ( g_sendActivateEvent != -1 )
1132 {
1133 bool activate = g_sendActivateEvent != 0;
1134
1135 // if (!activate) wxPrintf( wxT("de") );
1136 // wxPrintf( wxT("activate\n") );
1137
1138 // do it only once
1139 g_sendActivateEvent = -1;
1140
1141 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1142 }
1143}
1144
1145// ----------------------------------------------------------------------------
1146// frame title/icon
1147// ----------------------------------------------------------------------------
1148
1149void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1150{
1151 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1152
1153 if ( title == m_title )
1154 return;
1155
1156 m_title = title;
1157
1158 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1159}
1160
1161void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1162{
1163 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1164
1165 wxTopLevelWindowBase::SetIcons( icons );
1166
1167 // Setting icons before window is realized can cause a GTK assertion if
1168 // another TLW is realized before this one, and it has this one as it's
1169 // transient parent. The life demo exibits this problem.
1170 if (GTK_WIDGET_REALIZED(m_widget))
1171 {
1172 GList* list = NULL;
1173 for (size_t i = icons.GetIconCount(); i--;)
1174 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1175 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1176 g_list_free(list);
1177 }
1178}
1179
1180// ----------------------------------------------------------------------------
1181// frame state: maximized/iconized/normal
1182// ----------------------------------------------------------------------------
1183
1184void wxTopLevelWindowGTK::Maximize(bool maximize)
1185{
1186 if (maximize)
1187 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1188 else
1189 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1190}
1191
1192bool wxTopLevelWindowGTK::IsMaximized() const
1193{
1194 if(!m_widget->window)
1195 return false;
1196
1197 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1198}
1199
1200void wxTopLevelWindowGTK::Restore()
1201{
1202 // "Present" seems similar enough to "restore"
1203 gtk_window_present( GTK_WINDOW( m_widget ) );
1204}
1205
1206void wxTopLevelWindowGTK::Iconize( bool iconize )
1207{
1208 if (iconize)
1209 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1210 else
1211 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1212}
1213
1214bool wxTopLevelWindowGTK::IsIconized() const
1215{
1216 return m_isIconized;
1217}
1218
1219void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1220{
1221 if ( iconize != m_isIconized )
1222 {
1223 m_isIconized = iconize;
1224 (void)SendIconizeEvent(iconize);
1225 }
1226}
1227
1228void wxTopLevelWindowGTK::AddGrab()
1229{
1230 if (!m_grabbed)
1231 {
1232 m_grabbed = true;
1233 gtk_grab_add( m_widget );
1234 wxGUIEventLoop().Run();
1235 gtk_grab_remove( m_widget );
1236 }
1237}
1238
1239void wxTopLevelWindowGTK::RemoveGrab()
1240{
1241 if (m_grabbed)
1242 {
1243 gtk_main_quit();
1244 m_grabbed = false;
1245 }
1246}
1247
1248
1249// helper
1250static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1251{
1252 if (window)
1253 {
1254 if (region.IsEmpty())
1255 {
1256 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1257 }
1258 else
1259 {
1260 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1261 return true;
1262 }
1263 }
1264 return false;
1265}
1266
1267
1268bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1269{
1270 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1271 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));
1272
1273 if ( GTK_WIDGET_REALIZED(m_widget) )
1274 {
1275 if ( m_wxwindow )
1276 do_shape_combine_region(m_wxwindow->window, region);
1277
1278 return do_shape_combine_region(m_widget->window, region);
1279 }
1280 else // not realized yet
1281 {
1282 // store the shape to set, it will be really set once we're realized
1283 m_shape = region;
1284
1285 // we don't know if we're going to succeed or fail, be optimistic by
1286 // default
1287 return true;
1288 }
1289}
1290
1291bool wxTopLevelWindowGTK::IsActive()
1292{
1293 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1294}
1295
1296void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1297{
1298 bool new_hint_value = false;
1299
1300 // FIXME: This is a workaround to focus handling problem
1301 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1302 // hasn't yet been processed, and the internal focus system is not up to date yet.
1303 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1304 // won't have side effects) - MR
1305 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI);
1306
1307 if(m_urgency_hint >= 0)
1308 g_source_remove(m_urgency_hint);
1309
1310 m_urgency_hint = -2;
1311
1312 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1313 {
1314 new_hint_value = true;
1315
1316 if (flags & wxUSER_ATTENTION_INFO)
1317 {
1318 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1319 } else {
1320 m_urgency_hint = -1;
1321 }
1322 }
1323
1324#if GTK_CHECK_VERSION(2,7,0)
1325 if(!gtk_check_version(2,7,0))
1326 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1327 else
1328#endif
1329 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1330}
1331
1332void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1333{
1334 // Store which styles were changed
1335 long styleChanges = style ^ m_windowStyle;
1336
1337 // Process wxWindow styles. This also updates the internal variable
1338 // Therefore m_windowStyle bits carry now the _new_ style values
1339 wxWindow::SetWindowStyleFlag(style);
1340
1341 // just return for now if widget does not exist yet
1342 if (!m_widget)
1343 return;
1344
1345 if ( styleChanges & wxSTAY_ON_TOP )
1346 {
1347 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1348 m_windowStyle & wxSTAY_ON_TOP);
1349 }
1350
1351 if ( styleChanges & wxFRAME_NO_TASKBAR )
1352 {
1353 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1354 m_windowStyle & wxFRAME_NO_TASKBAR);
1355 }
1356}
1357
1358/* Get the X Window between child and the root window.
1359 This should usually be the WM managed XID */
1360static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1361{
1362 Window root, parent;
1363 Window* children;
1364 unsigned int nchildren;
1365
1366 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1367 XFree(children);
1368
1369 while (parent != root) {
1370 child = parent;
1371 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1372 XFree(children);
1373 }
1374
1375 return child;
1376}
1377
1378bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1379{
1380 if (!m_widget || !m_widget->window)
1381 return false;
1382
1383 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1384 // We need to get the X Window that has the root window as the immediate parent
1385 // and m_widget->window as a child. This should be the X Window that the WM manages and
1386 // from which the opacity property is checked from.
1387 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1388
1389
1390 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1391 if (alpha == 0xff)
1392 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1393 else
1394 {
1395 long opacity = alpha * 0x1010101L;
1396 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1397 XA_CARDINAL, 32, PropModeReplace,
1398 (unsigned char *) &opacity, 1L);
1399 }
1400 XSync(dpy, False);
1401 return true;
1402}
1403
1404bool wxTopLevelWindowGTK::CanSetTransparent()
1405{
1406 // allow to override automatic detection as it's far from perfect
1407 static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1408 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1409 {
1410 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1411 }
1412
1413#if GTK_CHECK_VERSION(2,10,0)
1414 if (!gtk_check_version(2,10,0))
1415 {
1416 return (gtk_widget_is_composited (m_widget));
1417 }
1418 else
1419#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1420 {
1421 return false;
1422 }
1423
1424#if 0 // Don't be optimistic here for the sake of wxAUI
1425 int opcode, event, error;
1426 // Check for the existence of a RGBA visual instead?
1427 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1428 "Composite", &opcode, &event, &error);
1429#endif
1430}
wxWidgets (Impactor)