1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/toplevel.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
22 #define XIconifyWindow XICONIFYWINDOW
25 #include "wx/toplevel.h"
34 #include "wx/gtk/private.h"
35 #include "wx/evtloop.h"
36 #include "wx/sysopt.h"
39 #ifdef GDK_WINDOWING_X11
43 #include "wx/gtk/private/win_gtk.h"
45 #ifdef GDK_WINDOWING_X11
47 #include "wx/unix/utilsx11.h"
50 #include <X11/Xatom.h>
52 #endif // GDK_WINDOWING_X11
55 #include <hildon-widgets/hildon-program.h>
56 #include <hildon-widgets/hildon-window.h>
57 #endif // wxUSE_LIBHILDON
60 #include <hildon/hildon.h>
61 #endif // wxUSE_LIBHILDON2
63 // ----------------------------------------------------------------------------
65 // ----------------------------------------------------------------------------
67 // this is incremented while a modal dialog is shown
68 int wxOpenModalDialogsCount
= 0;
70 // the frame that is currently active (i.e. its child has focus). It is
71 // used to generate wxActivateEvents
72 static wxTopLevelWindowGTK
*g_activeFrame
= NULL
;
73 static wxTopLevelWindowGTK
*g_lastActiveFrame
= NULL
;
75 // if we detect that the app has got/lost the focus, we set this variable to
76 // either TRUE or FALSE and an activate event will be sent during the next
77 // OnIdle() call and it is reset to -1: this value means that we shouldn't
78 // send any activate events at all
79 static int g_sendActivateEvent
= -1;
81 // Whether _NET_REQUEST_FRAME_EXTENTS support is working
82 // 0 == not tested yet, 1 == working, 2 == broken
83 static int gs_requestFrameExtentsStatus
;
85 //-----------------------------------------------------------------------------
86 // RequestUserAttention related functions
87 //-----------------------------------------------------------------------------
90 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
93 #if GTK_CHECK_VERSION(2,7,0)
94 if (gtk_check_version(2,7,0) == NULL
)
95 gtk_window_set_urgency_hint(win
, setting
);
99 #ifdef GDK_WINDOWING_X11
100 GdkWindow
* window
= gtk_widget_get_window(GTK_WIDGET(win
));
101 wxCHECK_RET(window
, "wxgtk_window_set_urgency_hint: GdkWindow not realized");
103 Display
* dpy
= GDK_WINDOW_XDISPLAY(window
);
104 Window xid
= GDK_WINDOW_XID(window
);
105 XWMHints
* wm_hints
= XGetWMHints(dpy
, xid
);
108 wm_hints
= XAllocWMHints();
111 wm_hints
->flags
|= XUrgencyHint
;
113 wm_hints
->flags
&= ~XUrgencyHint
;
115 XSetWMHints(dpy
, xid
, wm_hints
);
117 #endif // GDK_WINDOWING_X11
120 #define gtk_window_set_urgency_hint wxgtk_window_set_urgency_hint
124 static gboolean
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
126 gtk_window_set_urgency_hint(GTK_WINDOW(win
->m_widget
), false);
128 win
->m_urgency_hint
= -2;
133 //-----------------------------------------------------------------------------
135 //-----------------------------------------------------------------------------
138 static gboolean
gtk_frame_focus_in_callback( GtkWidget
*widget
,
139 GdkEvent
*WXUNUSED(event
),
140 wxTopLevelWindowGTK
*win
)
142 switch ( g_sendActivateEvent
)
145 // we've got focus from outside, synthetize wxActivateEvent
146 g_sendActivateEvent
= 1;
150 // another our window just lost focus, it was already ours before
151 // - don't send any wxActivateEvent
152 g_sendActivateEvent
= -1;
157 g_lastActiveFrame
= g_activeFrame
;
159 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
161 // MR: wxRequestUserAttention related block
162 switch( win
->m_urgency_hint
)
165 g_source_remove( win
->m_urgency_hint
);
166 // no break, fallthrough to remove hint too
168 gtk_window_set_urgency_hint(GTK_WINDOW(widget
), false);
169 win
->m_urgency_hint
= -2;
175 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
176 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
177 event
.SetEventObject(g_activeFrame
);
178 g_activeFrame
->HandleWindowEvent(event
);
184 //-----------------------------------------------------------------------------
186 //-----------------------------------------------------------------------------
190 gboolean
gtk_frame_focus_out_callback(GtkWidget
* WXUNUSED(widget
),
191 GdkEventFocus
*WXUNUSED(gdk_event
),
192 wxTopLevelWindowGTK
* WXUNUSED(win
))
194 // if the focus goes out of our app altogether, OnIdle() will send
195 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
196 // g_sendActivateEvent to -1
197 g_sendActivateEvent
= 0;
199 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
201 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
205 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
206 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
207 event
.SetEventObject(g_activeFrame
);
208 g_activeFrame
->HandleWindowEvent(event
);
210 g_activeFrame
= NULL
;
217 //-----------------------------------------------------------------------------
218 // "size_allocate" from m_wxwindow
219 //-----------------------------------------------------------------------------
223 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxTopLevelWindowGTK
* win
)
225 if (win
->m_oldClientWidth
!= alloc
->width
||
226 win
->m_oldClientHeight
!= alloc
->height
)
228 win
->m_oldClientWidth
= alloc
->width
;
229 win
->m_oldClientHeight
= alloc
->height
;
232 gtk_widget_get_allocation(win
->m_widget
, &a
);
233 wxSize
size(a
.width
, a
.height
);
234 size
+= win
->m_decorSize
;
235 win
->m_width
= size
.x
;
236 win
->m_height
= size
.y
;
238 if (!win
->IsIconized())
240 wxSizeEvent
event(size
, win
->GetId());
241 event
.SetEventObject(win
);
242 win
->HandleWindowEvent(event
);
244 // else the window is currently unmapped, don't generate size events
249 //-----------------------------------------------------------------------------
251 //-----------------------------------------------------------------------------
255 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
256 GdkEvent
*WXUNUSED(event
),
257 wxTopLevelWindowGTK
*win
)
259 if (win
->IsEnabled() &&
260 (wxOpenModalDialogsCount
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
268 //-----------------------------------------------------------------------------
270 //-----------------------------------------------------------------------------
274 gtk_frame_configure_callback( GtkWidget
* widget
,
275 GdkEventConfigure
*WXUNUSED(event
),
276 wxTopLevelWindowGTK
*win
)
278 if (!win
->m_hasVMT
|| !win
->IsShown())
282 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
286 wxMoveEvent
mevent(point
, win
->GetId());
287 mevent
.SetEventObject( win
);
288 win
->HandleWindowEvent( mevent
);
294 //-----------------------------------------------------------------------------
295 // "realize" from m_widget
296 //-----------------------------------------------------------------------------
298 // we cannot the WM hints and icons before the widget has been realized,
299 // so we do this directly after realization
301 void wxTopLevelWindowGTK::GTKHandleRealized()
303 wxNonOwnedWindow::GTKHandleRealized();
305 gdk_window_set_decorations(gtk_widget_get_window(m_widget
),
306 (GdkWMDecoration
)m_gdkDecor
);
307 gdk_window_set_functions(gtk_widget_get_window(m_widget
),
308 (GdkWMFunction
)m_gdkFunc
);
310 // GTK's shrinking/growing policy
311 if ( !(m_gdkFunc
& GDK_FUNC_RESIZE
) )
312 gtk_window_set_resizable(GTK_WINDOW(m_widget
), FALSE
);
313 #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
315 gtk_window_set_policy(GTK_WINDOW(m_widget
), 1, 1, 1);
318 const wxIconBundle
& icons
= GetIcons();
319 if (icons
.GetIconCount())
323 //-----------------------------------------------------------------------------
324 // "map_event" from m_widget
325 //-----------------------------------------------------------------------------
329 gtk_frame_map_callback( GtkWidget
*,
330 GdkEvent
* WXUNUSED(event
),
331 wxTopLevelWindow
*win
)
333 const bool wasIconized
= win
->IsIconized();
336 // Because GetClientSize() returns (0,0) when IsIconized() is true,
337 // a size event must be generated, just in case GetClientSize() was
338 // called while iconized. This specifically happens when restoring a
339 // tlw that was "rolled up" with some WMs.
340 // Queue a resize rather than sending size event directly to allow
341 // children to be made visible first.
342 win
->m_oldClientWidth
= 0;
343 gtk_widget_queue_resize(win
->m_wxwindow
);
345 // it is possible for m_isShown to be false here, see bug #9909
346 if (win
->wxWindowBase::Show(true))
348 wxShowEvent
eventShow(win
->GetId(), true);
349 eventShow
.SetEventObject(win
);
350 win
->GetEventHandler()->ProcessEvent(eventShow
);
353 #if GTK_CHECK_VERSION(2,6,0)
354 if (!gtk_check_version(2,6,0))
356 // restore focus-on-map setting in case ShowWithoutActivating() was called
357 gtk_window_set_focus_on_map(GTK_WINDOW(win
->m_widget
), true);
365 //-----------------------------------------------------------------------------
366 // "window-state-event" from m_widget
367 //-----------------------------------------------------------------------------
371 gtk_frame_window_state_callback( GtkWidget
* WXUNUSED(widget
),
372 GdkEventWindowState
*event
,
373 wxTopLevelWindow
*win
)
375 if (event
->changed_mask
& GDK_WINDOW_STATE_ICONIFIED
)
376 win
->SetIconizeState((event
->new_window_state
& GDK_WINDOW_STATE_ICONIFIED
) != 0);
378 // if maximized bit changed and it is now set
379 if (event
->changed_mask
& event
->new_window_state
& GDK_WINDOW_STATE_MAXIMIZED
)
381 wxMaximizeEvent
event(win
->GetId());
382 event
.SetEventObject(win
);
383 win
->HandleWindowEvent(event
);
390 //-----------------------------------------------------------------------------
392 bool wxGetFrameExtents(GdkWindow
* window
, int* left
, int* right
, int* top
, int* bottom
)
394 #ifdef GDK_WINDOWING_X11
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
);
400 gulong nitems
, bytes_after
;
402 Status status
= XGetWindowProperty(
403 gdk_x11_drawable_get_xdisplay(window
),
404 gdk_x11_drawable_get_xid(window
),
406 0, 4, false, XA_CARDINAL
,
407 &type
, &format
, &nitems
, &bytes_after
, &data
);
408 const bool success
= status
== Success
&& data
&& nitems
== 4;
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]);
425 //-----------------------------------------------------------------------------
426 // "property_notify_event" from m_widget
427 //-----------------------------------------------------------------------------
430 static gboolean
property_notify_event(
431 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
433 // Watch for changes to _NET_FRAME_EXTENTS property
434 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
435 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
)
437 if (win
->m_netFrameExtentsTimerId
)
439 // WM support for _NET_REQUEST_FRAME_EXTENTS is working
440 gs_requestFrameExtentsStatus
= 1;
441 g_source_remove(win
->m_netFrameExtentsTimerId
);
442 win
->m_netFrameExtentsTimerId
= 0;
445 wxSize decorSize
= win
->m_decorSize
;
446 int left
, right
, top
, bottom
;
447 if (wxGetFrameExtents(event
->window
, &left
, &right
, &top
, &bottom
))
448 decorSize
.Set(left
+ right
, top
+ bottom
);
450 win
->GTKUpdateDecorSize(decorSize
);
457 static gboolean
request_frame_extents_timeout(void* data
)
459 // WM support for _NET_REQUEST_FRAME_EXTENTS is broken
460 gs_requestFrameExtentsStatus
= 2;
462 wxTopLevelWindowGTK
* win
= static_cast<wxTopLevelWindowGTK
*>(data
);
463 win
->m_netFrameExtentsTimerId
= 0;
464 wxSize decorSize
= win
->m_decorSize
;
465 int left
, right
, top
, bottom
;
466 if (wxGetFrameExtents(gtk_widget_get_window(win
->m_widget
), &left
, &right
, &top
, &bottom
))
467 decorSize
.Set(left
+ right
, top
+ bottom
);
468 win
->GTKUpdateDecorSize(decorSize
);
474 // ----------------------------------------------------------------------------
475 // wxTopLevelWindowGTK creation
476 // ----------------------------------------------------------------------------
478 void wxTopLevelWindowGTK::Init()
481 m_isIconized
= false;
482 m_fsIsShowing
= false;
483 m_themeEnabled
= true;
488 m_deferShowAllowed
= true;
489 m_updateDecorSize
= true;
490 m_netFrameExtentsTimerId
= 0;
491 m_incWidth
= m_incHeight
= 0;
496 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
498 const wxString
& title
,
500 const wxSize
& sizeOrig
,
502 const wxString
&name
)
504 // always create a frame of some reasonable, even if arbitrary, size (at
505 // least for MSW compatibility)
506 wxSize size
= sizeOrig
;
507 size
.x
= WidthDefault(size
.x
);
508 size
.y
= HeightDefault(size
.y
);
510 wxTopLevelWindows
.Append( this );
512 if (!PreCreation( parent
, pos
, size
) ||
513 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
515 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
521 // NB: m_widget may be !=NULL if it was created by derived class' Create,
522 // e.g. in wxTaskBarIconAreaGTK
523 if (m_widget
== NULL
)
525 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
526 // we must create HildonWindow and not a normal GtkWindow as the latter
527 // doesn't look correctly in Maemo environment and it must also be
528 // registered with the main program object
529 m_widget
= hildon_window_new();
530 hildon_program_add_window(wxTheApp
->GetHildonProgram(),
531 HILDON_WINDOW(m_widget
));
532 #else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
533 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
534 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
536 // Tell WM that this is a dialog window and make it center
537 // on parent by default (this is what GtkDialog ctor does):
538 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
539 GDK_WINDOW_TYPE_HINT_DIALOG
);
540 gtk_window_set_position(GTK_WINDOW(m_widget
),
541 GTK_WIN_POS_CENTER_ON_PARENT
);
545 if (style
& wxFRAME_TOOL_WINDOW
)
547 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
548 GDK_WINDOW_TYPE_HINT_UTILITY
);
550 // On some WMs, like KDE, a TOOL_WINDOW will still show
551 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
552 // For consistency between WMs and with Windows, we
553 // should set the NO_TASKBAR flag which will apply
554 // the set_skip_taskbar_hint if it is available,
555 // ensuring no taskbar entry will appear.
556 style
|= wxFRAME_NO_TASKBAR
;
559 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
561 g_object_ref(m_widget
);
564 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
565 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
566 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
567 (style
& wxFRAME_FLOAT_ON_PARENT
)))
569 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
570 GTK_WINDOW(topParent
->m_widget
) );
573 if (style
& wxFRAME_NO_TASKBAR
)
575 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
578 if (style
& wxSTAY_ON_TOP
)
580 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
582 if (style
& wxMAXIMIZE
)
583 gtk_window_maximize(GTK_WINDOW(m_widget
));
587 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
590 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
591 gtk_widget_set_can_focus(m_widget
, false);
593 g_signal_connect (m_widget
, "delete_event",
594 G_CALLBACK (gtk_frame_delete_callback
), this);
596 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
597 m_mainWidget
= gtk_vbox_new(false, 0);
598 gtk_widget_show( m_mainWidget
);
599 gtk_widget_set_can_focus(m_mainWidget
, false);
600 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
602 // m_wxwindow is the client area
603 m_wxwindow
= wxPizza::New();
604 gtk_widget_show( m_wxwindow
);
605 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
607 // we donm't allow the frame to get the focus as otherwise
608 // the frame will grab it at arbitrary focus changes
609 gtk_widget_set_can_focus(m_wxwindow
, false);
611 if (m_parent
) m_parent
->AddChild( this );
613 g_signal_connect(m_wxwindow
, "size_allocate",
614 G_CALLBACK(size_allocate
), this);
618 #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
619 if ((m_x
!= -1) || (m_y
!= -1))
620 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
623 // for some reported size corrections
624 g_signal_connect (m_widget
, "map_event",
625 G_CALLBACK (gtk_frame_map_callback
), this);
627 // for iconized state
628 g_signal_connect (m_widget
, "window_state_event",
629 G_CALLBACK (gtk_frame_window_state_callback
), this);
633 g_signal_connect (m_widget
, "configure_event",
634 G_CALLBACK (gtk_frame_configure_callback
), this);
637 g_signal_connect_after (m_widget
, "focus_in_event",
638 G_CALLBACK (gtk_frame_focus_in_callback
), this);
639 g_signal_connect_after (m_widget
, "focus_out_event",
640 G_CALLBACK (gtk_frame_focus_out_callback
), this);
642 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
643 g_signal_connect(m_widget
, "property_notify_event",
644 G_CALLBACK(property_notify_event
), this);
646 // translate wx decorations styles into Motif WM hints (they are recognized
647 // by other WMs as well)
649 // always enable moving the window as we have no separate flag for enabling
651 m_gdkFunc
= GDK_FUNC_MOVE
;
653 if ( style
& wxCLOSE_BOX
)
654 m_gdkFunc
|= GDK_FUNC_CLOSE
;
656 if ( style
& wxMINIMIZE_BOX
)
657 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
659 if ( style
& wxMAXIMIZE_BOX
)
660 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
662 if ( (style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
) )
668 m_gdkDecor
= GDK_DECOR_BORDER
;
670 if ( style
& wxCAPTION
)
671 m_gdkDecor
|= GDK_DECOR_TITLE
;
673 if ( style
& wxSYSTEM_MENU
)
674 m_gdkDecor
|= GDK_DECOR_MENU
;
676 if ( style
& wxMINIMIZE_BOX
)
677 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
679 if ( style
& wxMAXIMIZE_BOX
)
680 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
682 if ( style
& wxRESIZE_BORDER
)
684 m_gdkFunc
|= GDK_FUNC_RESIZE
;
685 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
689 // GTK sometimes chooses very small size if max size hint is not explicitly set
690 DoSetSizeHints(m_minWidth
, m_minHeight
, m_maxWidth
, m_maxHeight
, m_incWidth
, m_incHeight
);
692 m_decorSize
= GetCachedDecorSize();
694 GTKDoGetSize(&w
, &h
);
695 gtk_window_set_default_size(GTK_WINDOW(m_widget
), w
, h
);
700 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
702 if ( m_netFrameExtentsTimerId
)
704 // Don't let the timer callback fire as the window pointer passed to it
705 // will become invalid very soon.
706 g_source_remove(m_netFrameExtentsTimerId
);
709 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
710 // it can also be a (standard) dialog
711 if ( HILDON_IS_WINDOW(m_widget
) )
713 hildon_program_remove_window(wxTheApp
->GetHildonProgram(),
714 HILDON_WINDOW(m_widget
));
716 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2
720 wxFAIL_MSG(wxT("Window still grabbed"));
726 // it may also be GtkScrolledWindow in the case of an MDI child
727 if (GTK_IS_WINDOW(m_widget
))
729 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
732 if (g_activeFrame
== this)
733 g_activeFrame
= NULL
;
734 if (g_lastActiveFrame
== this)
735 g_lastActiveFrame
= NULL
;
738 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
741 m_gdkFunc
|= GDK_FUNC_CLOSE
;
743 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
745 GdkWindow
* window
= gtk_widget_get_window(m_widget
);
747 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
752 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long)
754 if (show
== m_fsIsShowing
)
755 return false; // return what?
757 m_fsIsShowing
= show
;
759 #ifdef GDK_WINDOWING_X11
760 wxX11FullScreenMethod method
=
761 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
762 (WXWindow
)GDK_ROOT_WINDOW());
764 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
765 // to switch to fullscreen, which is not always available. We must
766 // check if WM supports the spec and use legacy methods if it
768 if ( method
== wxX11_FS_WMSPEC
)
769 #endif // GDK_WINDOWING_X11
772 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
774 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
776 #ifdef GDK_WINDOWING_X11
779 GdkWindow
* window
= gtk_widget_get_window(m_widget
);
783 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
784 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
786 int screen_width
,screen_height
;
787 wxDisplaySize( &screen_width
, &screen_height
);
789 gint client_x
, client_y
, root_x
, root_y
;
792 m_fsSaveGdkFunc
= m_gdkFunc
;
793 m_fsSaveGdkDecor
= m_gdkDecor
;
794 m_gdkFunc
= m_gdkDecor
= 0;
795 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
796 gdk_window_set_functions(window
, (GdkWMFunction
)0);
798 gdk_window_get_origin(window
, &root_x
, &root_y
);
799 gdk_window_get_geometry(window
, &client_x
, &client_y
, &width
, &height
, NULL
);
801 gdk_window_move_resize(
802 window
, -client_x
, -client_y
, screen_width
+ 1, screen_height
+ 1);
804 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
805 (WXWindow
)GDK_ROOT_WINDOW(),
806 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
807 show
, &m_fsSaveFrame
, method
);
811 m_gdkFunc
= m_fsSaveGdkFunc
;
812 m_gdkDecor
= m_fsSaveGdkDecor
;
813 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
814 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
816 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
817 (WXWindow
)GDK_ROOT_WINDOW(),
818 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
819 show
, &m_fsSaveFrame
, method
);
821 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
822 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
825 #endif // GDK_WINDOWING_X11
827 // documented behaviour is to show the window if it's still hidden when
828 // showing it full screen
835 // ----------------------------------------------------------------------------
836 // overridden wxWindow methods
837 // ----------------------------------------------------------------------------
839 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground
), const wxRect
*WXUNUSED(rect
) )
841 wxCHECK_RET( m_widget
, wxT("invalid frame") );
843 gtk_widget_queue_draw( m_widget
);
845 GdkWindow
* window
= NULL
;
847 window
= gtk_widget_get_window(m_wxwindow
);
849 gdk_window_invalidate_rect(window
, NULL
, true);
852 bool wxTopLevelWindowGTK::Show( bool show
)
854 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
856 bool deferShow
= show
&& !m_isShown
&& m_deferShow
;
859 deferShow
= gs_requestFrameExtentsStatus
!= 2 &&
860 m_deferShowAllowed
&& !gtk_widget_get_realized(m_widget
);
863 deferShow
= g_signal_handler_find(m_widget
,
864 GSignalMatchType(G_SIGNAL_MATCH_ID
| G_SIGNAL_MATCH_DATA
),
865 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET
),
866 0, NULL
, NULL
, this) != 0;
868 GdkScreen
* screen
= NULL
;
871 #ifdef GDK_WINDOWING_X11
872 screen
= gtk_widget_get_screen(m_widget
);
873 GdkAtom atom
= gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
874 deferShow
= gdk_x11_screen_supports_net_wm_hint(screen
, atom
) != 0;
878 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
879 // to m_decorSize, it breaks saving/restoring window size with
880 // GetSize()/SetSize() because it makes window bigger between each
882 m_updateDecorSize
= deferShow
;
885 m_deferShow
= deferShow
;
889 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
890 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
891 // notification is received, so correct frame extents are known.
892 // This allows resizing m_widget to keep the overall size in sync with
893 // what wxWidgets expects it to be without an obvious change in the
894 // window size immediately after it becomes visible.
896 // Realize m_widget, so m_widget->window can be used. Realizing normally
897 // causes the widget tree to be size_allocated, which generates size
898 // events in the wrong order. However, the size_allocates will not be
899 // done if the allocation is not the default (1,1).
901 gtk_widget_get_allocation(m_widget
, &alloc
);
902 const int alloc_width
= alloc
.width
;
903 if (alloc_width
== 1)
906 gtk_widget_set_allocation(m_widget
, &alloc
);
908 gtk_widget_realize(m_widget
);
909 if (alloc_width
== 1)
912 gtk_widget_set_allocation(m_widget
, &alloc
);
915 #ifdef GDK_WINDOWING_X11
916 // send _NET_REQUEST_FRAME_EXTENTS
917 XClientMessageEvent xevent
;
918 memset(&xevent
, 0, sizeof(xevent
));
919 xevent
.type
= ClientMessage
;
920 GdkWindow
* window
= gtk_widget_get_window(m_widget
);
921 xevent
.window
= gdk_x11_drawable_get_xid(window
);
922 xevent
.message_type
= gdk_x11_atom_to_xatom_for_display(
923 gdk_drawable_get_display(window
),
924 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
926 Display
* display
= gdk_x11_drawable_get_xdisplay(window
);
927 XSendEvent(display
, DefaultRootWindow(display
), false,
928 SubstructureNotifyMask
| SubstructureRedirectMask
,
930 #endif // GDK_WINDOWING_X11
932 if (gs_requestFrameExtentsStatus
== 0)
934 // if WM does not respond to request within 1 second,
935 // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
936 m_netFrameExtentsTimerId
=
937 g_timeout_add(1000, request_frame_extents_timeout
, this);
940 // defer calling gtk_widget_show()
945 if (show
&& !gtk_widget_get_realized(m_widget
))
947 // size_allocate signals occur in reverse order (bottom to top).
948 // Things work better if the initial wxSizeEvents are sent (from the
949 // top down), before the initial size_allocate signals occur.
950 wxSizeEvent
event(GetSize(), GetId());
951 event
.SetEventObject(this);
952 HandleWindowEvent(event
);
955 bool change
= base_type::Show(show
);
959 // make sure window has a non-default position, so when it is shown
960 // again, it won't be repositioned by WM as if it were a new window
961 // Note that this must be done _after_ the window is hidden.
962 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
968 void wxTopLevelWindowGTK::ShowWithoutActivating()
972 #if GTK_CHECK_VERSION(2,6,0)
973 if (!gtk_check_version(2,6,0))
974 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget
), false);
981 void wxTopLevelWindowGTK::Raise()
983 gtk_window_present( GTK_WINDOW( m_widget
) );
986 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
988 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
991 // ----------------------------------------------------------------------------
993 // ----------------------------------------------------------------------------
995 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
997 wxSize
size(m_width
, m_height
);
999 if (size
.x
< 0) size
.x
= 0;
1000 if (size
.y
< 0) size
.y
= 0;
1001 #if wxUSE_LIBHILDON2
1011 else if (size
.y
== 270)
1016 #else // wxUSE_LIBHILDON2
1017 if (width
) *width
= size
.x
;
1018 if (height
) *height
= size
.y
;
1019 #endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
1022 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
1024 wxCHECK_RET( m_widget
, wxT("invalid frame") );
1026 m_deferShowAllowed
= true;
1028 // deal with the position first
1032 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1034 // -1 means "use existing" unless the flag above is specified
1040 else // wxSIZE_ALLOW_MINUS_ONE
1046 if ( m_x
!= old_x
|| m_y
!= old_y
)
1048 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
1051 const wxSize
oldSize(m_width
, m_height
);
1057 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
1060 GTKDoGetSize(&w
, &h
);
1061 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
1063 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
1064 wxSizeEvent
event(GetSize(), GetId());
1065 event
.SetEventObject(this);
1066 HandleWindowEvent(event
);
1070 void wxTopLevelWindowGTK::DoSetClientSize(int width
, int height
)
1072 base_type::DoSetClientSize(width
, height
);
1074 // Since client size is being explicitly set, don't change it later
1075 // Has to be done after calling base because it calls SetSize,
1076 // which sets this true
1077 m_deferShowAllowed
= false;
1080 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
1082 wxASSERT_MSG(m_widget
, wxT("invalid frame"));
1086 // for consistency with wxMSW, client area is supposed to be empty for
1087 // the iconized windows
1095 GTKDoGetSize(width
, height
);
1099 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
1101 int incW
, int incH
)
1103 base_type::DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
);
1107 const wxSize minSize
= GetMinSize();
1108 const wxSize maxSize
= GetMaxSize();
1110 // always set both min and max hints, otherwise GTK will
1111 // make assumptions we don't want about the unset values
1112 int hints_mask
= GDK_HINT_MIN_SIZE
| GDK_HINT_MAX_SIZE
;
1113 hints
.min_width
= 1;
1114 hints
.min_height
= 1;
1115 hints
.max_width
= INT_MAX
;
1116 hints
.max_height
= INT_MAX
;
1117 if (minSize
.x
> m_decorSize
.x
)
1118 hints
.min_width
= minSize
.x
- m_decorSize
.x
;
1119 if (minSize
.y
> m_decorSize
.y
)
1120 hints
.min_height
= minSize
.y
- m_decorSize
.y
;
1123 hints
.max_width
= maxSize
.x
- m_decorSize
.x
;
1124 if (hints
.max_width
< hints
.min_width
)
1125 hints
.max_width
= hints
.min_width
;
1129 hints
.max_height
= maxSize
.y
- m_decorSize
.y
;
1130 if (hints
.max_height
< hints
.min_height
)
1131 hints
.max_height
= hints
.min_height
;
1133 if (incW
> 0 || incH
> 0)
1135 hints_mask
|= GDK_HINT_RESIZE_INC
;
1136 hints
.width_inc
= incW
> 0 ? incW
: 1;
1137 hints
.height_inc
= incH
> 0 ? incH
: 1;
1139 gtk_window_set_geometry_hints(
1140 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
1143 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize
& decorSize
)
1145 if (!IsMaximized() && !IsFullScreen())
1146 GetCachedDecorSize() = decorSize
;
1147 if (m_updateDecorSize
&& m_decorSize
!= decorSize
)
1149 const wxSize diff
= decorSize
- m_decorSize
;
1150 m_decorSize
= decorSize
;
1151 bool resized
= false;
1152 if (m_minWidth
> 0 || m_minHeight
> 0 || m_maxWidth
> 0 || m_maxHeight
> 0)
1154 // update size hints, they depend on m_decorSize
1155 DoSetSizeHints(m_minWidth
, m_minHeight
, m_maxWidth
, m_maxHeight
, m_incWidth
, m_incHeight
);
1159 // keep overall size unchanged by shrinking m_widget
1161 GTKDoGetSize(&w
, &h
);
1162 // but not if size would be less than minimum, it won't take effect
1163 if (w
>= m_minWidth
- decorSize
.x
&& h
>= m_minHeight
- decorSize
.y
)
1165 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
1171 // adjust overall size to match change in frame extents
1174 if (m_width
< 0) m_width
= 0;
1175 if (m_height
< 0) m_height
= 0;
1176 m_oldClientWidth
= 0;
1177 gtk_widget_queue_resize(m_wxwindow
);
1182 // gtk_widget_show() was deferred, do it now
1183 m_deferShow
= false;
1184 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
1185 wxSizeEvent
sizeEvent(GetSize(), GetId());
1186 sizeEvent
.SetEventObject(this);
1187 HandleWindowEvent(sizeEvent
);
1189 gtk_widget_show(m_widget
);
1191 wxShowEvent
showEvent(GetId(), true);
1192 showEvent
.SetEventObject(this);
1193 HandleWindowEvent(showEvent
);
1197 wxSize
& wxTopLevelWindowGTK::GetCachedDecorSize()
1199 static wxSize size
[8];
1203 if (m_gdkDecor
& (GDK_DECOR_MENU
| GDK_DECOR_MINIMIZE
| GDK_DECOR_MAXIMIZE
| GDK_DECOR_TITLE
))
1206 if (m_gdkDecor
& GDK_DECOR_BORDER
)
1208 // utility window decor can be different
1209 if (m_windowStyle
& wxFRAME_TOOL_WINDOW
)
1214 void wxTopLevelWindowGTK::OnInternalIdle()
1216 wxTopLevelWindowBase::OnInternalIdle();
1218 // Synthetize activate events.
1219 if ( g_sendActivateEvent
!= -1 )
1221 bool activate
= g_sendActivateEvent
!= 0;
1223 // if (!activate) wxPrintf( wxT("de") );
1224 // wxPrintf( wxT("activate\n") );
1227 g_sendActivateEvent
= -1;
1229 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1233 // ----------------------------------------------------------------------------
1235 // ----------------------------------------------------------------------------
1237 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1239 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1241 if ( title
== m_title
)
1246 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1249 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1251 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1253 base_type::SetIcons(icons
);
1255 // Setting icons before window is realized can cause a GTK assertion if
1256 // another TLW is realized before this one, and it has this one as it's
1257 // transient parent. The life demo exibits this problem.
1258 if (gtk_widget_get_realized(m_widget
))
1261 for (size_t i
= icons
.GetIconCount(); i
--;)
1262 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1263 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1268 // ----------------------------------------------------------------------------
1269 // frame state: maximized/iconized/normal
1270 // ----------------------------------------------------------------------------
1272 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1275 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1277 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1280 bool wxTopLevelWindowGTK::IsMaximized() const
1282 GdkWindow
* window
= NULL
;
1284 window
= gtk_widget_get_window(m_widget
);
1285 return window
&& (gdk_window_get_state(window
) & GDK_WINDOW_STATE_MAXIMIZED
);
1288 void wxTopLevelWindowGTK::Restore()
1290 // "Present" seems similar enough to "restore"
1291 gtk_window_present( GTK_WINDOW( m_widget
) );
1294 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1297 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1299 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1302 bool wxTopLevelWindowGTK::IsIconized() const
1304 return m_isIconized
;
1307 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1309 if ( iconize
!= m_isIconized
)
1311 m_isIconized
= iconize
;
1312 (void)SendIconizeEvent(iconize
);
1316 void wxTopLevelWindowGTK::AddGrab()
1321 gtk_grab_add( m_widget
);
1322 wxGUIEventLoop().Run();
1323 gtk_grab_remove( m_widget
);
1327 void wxTopLevelWindowGTK::RemoveGrab()
1336 bool wxTopLevelWindowGTK::IsActive()
1338 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1341 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1343 bool new_hint_value
= false;
1345 // FIXME: This is a workaround to focus handling problem
1346 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1347 // hasn't yet been processed, and the internal focus system is not up to date yet.
1348 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1349 // won't have side effects) - MR
1350 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI
);
1352 if(m_urgency_hint
>= 0)
1353 g_source_remove(m_urgency_hint
);
1355 m_urgency_hint
= -2;
1357 if( gtk_widget_get_realized(m_widget
) && !IsActive() )
1359 new_hint_value
= true;
1361 if (flags
& wxUSER_ATTENTION_INFO
)
1363 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1365 m_urgency_hint
= -1;
1369 gtk_window_set_urgency_hint(GTK_WINDOW(m_widget
), new_hint_value
);
1372 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1374 // Store which styles were changed
1375 long styleChanges
= style
^ m_windowStyle
;
1377 // Process wxWindow styles. This also updates the internal variable
1378 // Therefore m_windowStyle bits carry now the _new_ style values
1379 wxWindow::SetWindowStyleFlag(style
);
1381 // just return for now if widget does not exist yet
1385 if ( styleChanges
& wxSTAY_ON_TOP
)
1387 gtk_window_set_keep_above(GTK_WINDOW(m_widget
),
1388 m_windowStyle
& wxSTAY_ON_TOP
);
1391 if ( styleChanges
& wxFRAME_NO_TASKBAR
)
1393 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
),
1394 m_windowStyle
& wxFRAME_NO_TASKBAR
);
1398 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1400 GdkWindow
* window
= NULL
;
1402 window
= gtk_widget_get_window(m_widget
);
1406 #ifdef GDK_WINDOWING_X11
1407 Display
* dpy
= GDK_WINDOW_XDISPLAY(window
);
1408 Window win
= GDK_WINDOW_XID(window
);
1410 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1412 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1415 long opacity
= alpha
* 0x1010101L
;
1416 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1417 XA_CARDINAL
, 32, PropModeReplace
,
1418 (unsigned char *) &opacity
, 1L);
1422 #else // !GDK_WINDOWING_X11
1424 #endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11
1427 bool wxTopLevelWindowGTK::CanSetTransparent()
1429 // allow to override automatic detection as it's far from perfect
1430 const wxString SYSOPT_TRANSPARENT
= "gtk.tlw.can-set-transparent";
1431 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1433 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1436 #if GTK_CHECK_VERSION(2,10,0)
1437 if (!gtk_check_version(2,10,0))
1439 return gtk_widget_is_composited(m_widget
) != 0;
1442 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1447 #if 0 // Don't be optimistic here for the sake of wxAUI
1448 int opcode
, event
, error
;
1449 // Check for the existence of a RGBA visual instead?
1450 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1451 "Composite", &opcode
, &event
, &error
);