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