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