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"
41 #include "wx/gtk/win_gtk.h"
43 #include "wx/unix/utilsx11.h"
46 #include <X11/Xatom.h>
48 // ----------------------------------------------------------------------------
50 // ----------------------------------------------------------------------------
52 extern int g_openDialogs
;
53 extern wxWindowGTK
*g_delayedFocus
;
55 // the frame that is currently active (i.e. its child has focus). It is
56 // used to generate wxActivateEvents
57 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
58 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
60 // if we detect that the app has got/lost the focus, we set this variable to
61 // either TRUE or FALSE and an activate event will be sent during the next
62 // OnIdle() call and it is reset to -1: this value means that we shouldn't
63 // send any activate events at all
64 static int g_sendActivateEvent
= -1;
66 //-----------------------------------------------------------------------------
67 // RequestUserAttention related functions
68 //-----------------------------------------------------------------------------
71 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
74 wxASSERT_MSG( GTK_WIDGET_REALIZED(win
), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
75 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
78 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
81 wm_hints
= XAllocWMHints();
84 wm_hints
->flags
|= XUrgencyHint
;
86 wm_hints
->flags
&= ~XUrgencyHint
;
88 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
92 static gboolean
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
94 #if GTK_CHECK_VERSION(2,7,0)
95 if(!gtk_check_version(2,7,0))
96 gtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
99 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
101 win
->m_urgency_hint
= -2;
106 //-----------------------------------------------------------------------------
108 //-----------------------------------------------------------------------------
111 static gboolean
gtk_frame_focus_in_callback( GtkWidget
*widget
,
112 GdkEvent
*WXUNUSED(event
),
113 wxTopLevelWindowGTK
*win
)
115 switch ( g_sendActivateEvent
)
118 // we've got focus from outside, synthetize wxActivateEvent
119 g_sendActivateEvent
= 1;
123 // another our window just lost focus, it was already ours before
124 // - don't send any wxActivateEvent
125 g_sendActivateEvent
= -1;
130 g_lastActiveFrame
= g_activeFrame
;
132 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
134 // MR: wxRequestUserAttention related block
135 switch( win
->m_urgency_hint
)
138 g_source_remove( win
->m_urgency_hint
);
139 // no break, fallthrough to remove hint too
141 #if GTK_CHECK_VERSION(2,7,0)
142 if(!gtk_check_version(2,7,0))
143 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
147 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
150 win
->m_urgency_hint
= -2;
156 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
157 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
158 event
.SetEventObject(g_activeFrame
);
159 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
165 //-----------------------------------------------------------------------------
167 //-----------------------------------------------------------------------------
171 gboolean
gtk_frame_focus_out_callback(GtkWidget
* WXUNUSED(widget
),
172 GdkEventFocus
*WXUNUSED(gdk_event
),
173 wxTopLevelWindowGTK
* WXUNUSED(win
))
175 // if the focus goes out of our app alltogether, OnIdle() will send
176 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
177 // g_sendActivateEvent to -1
178 g_sendActivateEvent
= 0;
180 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
182 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
186 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
187 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
188 event
.SetEventObject(g_activeFrame
);
189 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
191 g_activeFrame
= NULL
;
198 //-----------------------------------------------------------------------------
200 // Get cached size of WM decorations for given GdkWMDecoration.
201 static wxSize
& GetDecorSize(int decor
)
203 // In testing, only the title bar and GDK_DECOR_BORDER made a difference.
204 // 4 possible combinations of title bar and border
205 static wxSize size
[4];
209 if (decor
& (GDK_DECOR_MENU
| GDK_DECOR_MINIMIZE
| GDK_DECOR_MAXIMIZE
| GDK_DECOR_TITLE
))
212 if (decor
& GDK_DECOR_BORDER
)
217 //-----------------------------------------------------------------------------
219 //-----------------------------------------------------------------------------
222 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
228 if (!win
->IsFullScreen())
229 sizeDecor
= GetDecorSize(win
->m_gdkDecor
);
230 const int w
= alloc
->width
+ sizeDecor
.x
;
231 const int h
= alloc
->height
+ sizeDecor
.y
;
233 if (win
->m_width
!= w
|| win
->m_height
!= h
)
238 win
->GtkUpdateSize();
243 // ----------------------------------------------------------------------------
245 // ----------------------------------------------------------------------------
249 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
250 GtkRequisition
*requisition
,
251 wxTopLevelWindowGTK
*win
)
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
);
259 //-----------------------------------------------------------------------------
261 //-----------------------------------------------------------------------------
265 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
266 GdkEvent
*WXUNUSED(event
),
267 wxTopLevelWindowGTK
*win
)
269 if (win
->IsEnabled() &&
270 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
279 //-----------------------------------------------------------------------------
281 //-----------------------------------------------------------------------------
285 gtk_frame_configure_callback( GtkWidget
* widget
,
286 GdkEventConfigure
*WXUNUSED(event
),
287 wxTopLevelWindowGTK
*win
)
289 if (!win
->m_hasVMT
|| !win
->IsShown())
293 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
297 wxMoveEvent
mevent(point
, win
->GetId());
298 mevent
.SetEventObject( win
);
299 win
->GetEventHandler()->ProcessEvent( mevent
);
305 //-----------------------------------------------------------------------------
306 // "realize" from m_widget
307 //-----------------------------------------------------------------------------
309 // we cannot MWM hints and icons before the widget has been realized,
310 // so we do this directly after realization
314 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
315 wxTopLevelWindowGTK
*win
)
317 // All this is for Motif Window Manager "hints" and is supposed to be
318 // recognized by other WM as well. Not tested.
319 gdk_window_set_decorations(win
->m_widget
->window
,
320 (GdkWMDecoration
)win
->m_gdkDecor
);
321 gdk_window_set_functions(win
->m_widget
->window
,
322 (GdkWMFunction
)win
->m_gdkFunc
);
324 // GTK's shrinking/growing policy
325 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
326 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
328 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
331 wxIconBundle iconsOld
= win
->GetIcons();
332 if ( !iconsOld
.IsEmpty() )
334 win
->SetIcon( wxNullIcon
);
335 win
->SetIcons( iconsOld
);
340 //-----------------------------------------------------------------------------
341 // "map_event" from m_widget
342 //-----------------------------------------------------------------------------
346 gtk_frame_map_callback( GtkWidget
* widget
,
347 GdkEvent
* WXUNUSED(event
),
348 wxTopLevelWindow
*win
)
350 // Calculate size of WM decorations.
351 // Done here in case WM does not support the _NET_FRAME_EXTENTS property.
352 if (win
->IsDecorCacheable() && !win
->IsFullScreen())
355 gdk_window_get_frame_extents(widget
->window
, &rect
);
357 gdk_drawable_get_size(widget
->window
, &w
, &h
);
358 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
359 const wxSize size
= wxSize(rect
.width
- w
, rect
.height
- h
);
360 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
362 // Update window size and frame extents cache
363 win
->m_width
= rect
.width
;
364 win
->m_height
= rect
.height
;
365 win
->GtkUpdateSize();
370 win
->SetIconizeState(false);
375 //-----------------------------------------------------------------------------
376 // "unmap_event" from m_widget
377 //-----------------------------------------------------------------------------
381 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
382 GdkEvent
* WXUNUSED(event
),
383 wxTopLevelWindow
*win
)
385 win
->SetIconizeState(true);
390 //-----------------------------------------------------------------------------
391 // "property_notify_event" from m_widget
392 //-----------------------------------------------------------------------------
395 static gboolean
property_notify_event(
396 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
398 // Watch for changes to _NET_FRAME_EXTENTS property
399 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
400 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
&&
401 win
->IsDecorCacheable() && !win
->IsFullScreen())
404 #if GTK_CHECK_VERSION(2, 2, 0)
405 if (gtk_check_version(2, 2, 0) == NULL
)
407 xproperty
= gdk_x11_atom_to_xatom_for_display(
408 gdk_drawable_get_display(event
->window
), property
);
413 xproperty
= gdk_x11_atom_to_xatom(property
);
417 gulong nitems
, bytes_after
;
419 Status status
= XGetWindowProperty(
420 gdk_x11_drawable_get_xdisplay(event
->window
),
421 gdk_x11_drawable_get_xid(event
->window
),
423 0, 4, false, XA_CARDINAL
,
424 &type
, &format
, &nitems
, &bytes_after
, (guchar
**)&data
);
425 if (status
== Success
&& data
&& nitems
== 4)
427 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
429 wxSize(int(data
[0] + data
[1]), int(data
[2] + data
[3]));
430 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
432 // Update window size and frame extents cache
433 win
->m_width
+= size
.x
- decorSize
.x
;
434 win
->m_height
+= size
.y
- decorSize
.y
;
435 if (win
->m_width
< 0) win
->m_width
= 0;
436 if (win
->m_height
< 0) win
->m_height
= 0;
437 win
->GtkUpdateSize();
448 // ----------------------------------------------------------------------------
449 // wxTopLevelWindowGTK creation
450 // ----------------------------------------------------------------------------
452 void wxTopLevelWindowGTK
::Init()
457 m_mainWidget
= (GtkWidget
*) NULL
;
458 m_isIconized
= false;
459 m_fsIsShowing
= false;
460 m_themeEnabled
= true;
461 m_gdkDecor
= m_gdkFunc
= 0;
467 bool wxTopLevelWindowGTK
::Create( wxWindow
*parent
,
469 const wxString
& title
,
471 const wxSize
& sizeOrig
,
473 const wxString
&name
)
475 // always create a frame of some reasonable, even if arbitrary, size (at
476 // least for MSW compatibility)
477 wxSize size
= sizeOrig
;
478 size
.x
= WidthDefault(size
.x
);
479 size
.y
= HeightDefault(size
.y
);
481 wxTopLevelWindows
.Append( this );
483 if (!PreCreation( parent
, pos
, size
) ||
484 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
486 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
492 // NB: m_widget may be !=NULL if it was created by derived class' Create,
493 // e.g. in wxTaskBarIconAreaGTK
494 if (m_widget
== NULL
)
496 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
498 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
499 // Tell WM that this is a dialog window and make it center
500 // on parent by default (this is what GtkDialog ctor does):
501 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
502 GDK_WINDOW_TYPE_HINT_DIALOG
);
503 gtk_window_set_position(GTK_WINDOW(m_widget
),
504 GTK_WIN_POS_CENTER_ON_PARENT
);
508 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
509 #if GTK_CHECK_VERSION(2,1,0)
510 if (!gtk_check_version(2,1,0))
512 if (style
& wxFRAME_TOOL_WINDOW
)
514 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
515 GDK_WINDOW_TYPE_HINT_UTILITY
);
517 // On some WMs, like KDE, a TOOL_WINDOW will still show
518 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
519 // For consistency between WMs and with Windows, we
520 // should set the NO_TASKBAR flag which will apply
521 // the set_skip_taskbar_hint if it is available,
522 // ensuring no taskbar entry will appear.
523 style
|= wxFRAME_NO_TASKBAR
;
530 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
531 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
532 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
533 (style
& wxFRAME_FLOAT_ON_PARENT
)))
535 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
536 GTK_WINDOW(topParent
->m_widget
) );
539 #if GTK_CHECK_VERSION(2,2,0)
540 if (!gtk_check_version(2,2,0))
542 if (style
& wxFRAME_NO_TASKBAR
)
544 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
550 if (!gtk_check_version(2,4,0))
552 if (style
& wxSTAY_ON_TOP
)
554 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
561 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
564 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
565 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
567 g_signal_connect (m_widget
, "delete_event",
568 G_CALLBACK (gtk_frame_delete_callback
), this);
570 // m_mainWidget holds the toolbar, the menubar and the client area
571 m_mainWidget
= gtk_pizza_new();
572 gtk_widget_show( m_mainWidget
);
573 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
574 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
576 // m_wxwindow only represents the client area without toolbar and menubar
577 m_wxwindow
= gtk_pizza_new();
578 gtk_widget_show( m_wxwindow
);
579 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
581 // we donm't allow the frame to get the focus as otherwise
582 // the frame will grab it at arbitrary focus changes
583 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
585 if (m_parent
) m_parent
->AddChild( this );
587 // the user resized the frame by dragging etc.
588 g_signal_connect (m_widget
, "size_allocate",
589 G_CALLBACK (gtk_frame_size_callback
), this);
591 g_signal_connect (m_widget
, "size_request",
592 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
595 if ((m_x
!= -1) || (m_y
!= -1))
596 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
598 // we cannot set MWM hints and icons before the widget has
599 // been realized, so we do this directly after realization
600 g_signal_connect (m_widget
, "realize",
601 G_CALLBACK (gtk_frame_realized_callback
), this);
603 // map and unmap for iconized state
604 g_signal_connect (m_widget
, "map_event",
605 G_CALLBACK (gtk_frame_map_callback
), this);
606 g_signal_connect (m_widget
, "unmap_event",
607 G_CALLBACK (gtk_frame_unmap_callback
), this);
610 g_signal_connect (m_widget
, "configure_event",
611 G_CALLBACK (gtk_frame_configure_callback
), this);
614 g_signal_connect_after (m_widget
, "focus_in_event",
615 G_CALLBACK (gtk_frame_focus_in_callback
), this);
616 g_signal_connect_after (m_widget
, "focus_out_event",
617 G_CALLBACK (gtk_frame_focus_out_callback
), this);
619 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
620 g_signal_connect(m_widget
, "property_notify_event",
621 G_CALLBACK(property_notify_event
), this);
624 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
635 if ((style
& wxRESIZE_BORDER
) != 0)
636 m_gdkFunc
|= GDK_FUNC_RESIZE
;
640 m_gdkDecor
= GDK_DECOR_BORDER
;
641 m_gdkFunc
= GDK_FUNC_MOVE
;
643 // All this is for Motif Window Manager "hints" and is supposed to be
644 // recognized by other WMs as well.
645 if ((style
& wxCAPTION
) != 0)
647 m_gdkDecor
|= GDK_DECOR_TITLE
;
649 if ((style
& wxCLOSE_BOX
) != 0)
651 m_gdkFunc
|= GDK_FUNC_CLOSE
;
653 if ((style
& wxSYSTEM_MENU
) != 0)
655 m_gdkDecor
|= GDK_DECOR_MENU
;
657 if ((style
& wxMINIMIZE_BOX
) != 0)
659 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
660 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
662 if ((style
& wxMAXIMIZE_BOX
) != 0)
664 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
665 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
667 if ((style
& wxRESIZE_BORDER
) != 0)
669 m_gdkFunc
|= GDK_FUNC_RESIZE
;
670 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
674 // m_gdkDecor needs to be set before calling GTKDoGetSize
676 GTKDoGetSize(&w
, &h
);
677 gtk_window_set_default_size(GTK_WINDOW(m_widget
), w
, h
);
682 wxTopLevelWindowGTK
::~wxTopLevelWindowGTK()
686 wxFAIL_MSG(_T("Window still grabbed"));
690 m_isBeingDeleted
= true;
692 // it may also be GtkScrolledWindow in the case of an MDI child
693 if (GTK_IS_WINDOW(m_widget
))
695 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
698 if (g_activeFrame
== this)
699 g_activeFrame
= NULL
;
700 if (g_lastActiveFrame
== this)
701 g_lastActiveFrame
= NULL
;
704 bool wxTopLevelWindowGTK
::EnableCloseButton( bool enable
)
707 m_gdkFunc
|= GDK_FUNC_CLOSE
;
709 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
711 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
712 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
717 bool wxTopLevelWindowGTK
::ShowFullScreen(bool show
, long)
719 if (show
== m_fsIsShowing
)
720 return false; // return what?
722 m_fsIsShowing
= show
;
724 wxX11FullScreenMethod method
=
725 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
726 (WXWindow
)GDK_ROOT_WINDOW());
728 #if GTK_CHECK_VERSION(2,2,0)
729 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
730 // to switch to fullscreen, which is not always available. We must
731 // check if WM supports the spec and use legacy methods if it
733 if ( (method
== wxX11_FS_WMSPEC
) && !gtk_check_version(2,2,0) )
736 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
738 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
741 #endif // GTK+ >= 2.2.0
743 GdkWindow
*window
= m_widget
->window
;
747 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
748 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
750 int screen_width
,screen_height
;
751 wxDisplaySize( &screen_width
, &screen_height
);
753 gint client_x
, client_y
, root_x
, root_y
;
756 if (method
!= wxX11_FS_WMSPEC
)
758 // don't do it always, Metacity hates it
759 m_fsSaveGdkFunc
= m_gdkFunc
;
760 m_fsSaveGdkDecor
= m_gdkDecor
;
761 m_gdkFunc
= m_gdkDecor
= 0;
762 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
763 gdk_window_set_functions(window
, (GdkWMFunction
)0);
766 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
767 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
768 &width
, &height
, NULL
);
770 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
771 screen_width
+ 1, screen_height
+ 1);
773 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
774 (WXWindow
)GDK_ROOT_WINDOW(),
775 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
776 show
, &m_fsSaveFrame
, method
);
780 if (method
!= wxX11_FS_WMSPEC
)
782 // don't do it always, Metacity hates it
783 m_gdkFunc
= m_fsSaveGdkFunc
;
784 m_gdkDecor
= m_fsSaveGdkDecor
;
785 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
786 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
789 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
790 (WXWindow
)GDK_ROOT_WINDOW(),
791 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
792 show
, &m_fsSaveFrame
, method
);
794 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
795 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
799 // documented behaviour is to show the window if it's still hidden when
800 // showing it full screen
807 // ----------------------------------------------------------------------------
808 // overridden wxWindow methods
809 // ----------------------------------------------------------------------------
811 bool wxTopLevelWindowGTK
::Show( bool show
)
813 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
815 if (show
== IsShown())
818 if (show
&& !m_sizeSet
)
820 /* by calling GtkOnSize here, we don't have to call
821 either after showing the frame, which would entail
822 much ugly flicker or from within the size_allocate
823 handler, because GTK 1.1.X forbids that. */
828 wxTopLevelWindowBase
::Show(show
);
832 // make sure window has a non-default position, so when it is shown
833 // again, it won't be repositioned by WM as if it were a new window
834 // Note that this must be done _after_ the window is hidden.
835 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
841 void wxTopLevelWindowGTK
::Raise()
843 gtk_window_present( GTK_WINDOW( m_widget
) );
846 void wxTopLevelWindowGTK
::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
848 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
851 // ----------------------------------------------------------------------------
853 // ----------------------------------------------------------------------------
855 void wxTopLevelWindowGTK
::GTKDoGetSize(int *width
, int *height
) const
857 wxSize
size(m_width
, m_height
);
860 size
-= GetDecorSize(m_gdkDecor
);
861 if (size
.x
< 0) size
.x
= 0;
862 if (size
.y
< 0) size
.y
= 0;
864 if (width
) *width
= size
.x
;
865 if (height
) *height
= size
.y
;
868 void wxTopLevelWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
870 wxCHECK_RET( m_widget
, wxT("invalid frame") );
872 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
873 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
876 // deal with the position first
880 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
882 // -1 means "use existing" unless the flag above is specified
888 else // wxSIZE_ALLOW_MINUS_ONE
894 if ( m_x
!= old_x
|| m_y
!= old_y
)
896 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
901 const wxSize
oldSize(m_width
, m_height
);
907 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
910 GTKDoGetSize(&w
, &h
);
911 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
917 void wxTopLevelWindowGTK
::DoGetClientSize( int *width
, int *height
) const
921 // for consistency with wxMSW, client area is supposed to be empty for
922 // the iconized windows
931 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
934 GTKDoGetSize(&w
, &h
);
937 *width
= w
- 2 * m_miniEdge
;
943 *height
= h
- 2 * m_miniEdge
- m_miniTitle
;
949 void wxTopLevelWindowGTK
::DoSetSizeHints( int minW
, int minH
,
953 wxTopLevelWindowBase
::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
955 const wxSize minSize
= GetMinSize();
956 const wxSize maxSize
= GetMaxSize();
959 const wxSize sizeDecor
= GetDecorSize(m_gdkDecor
);
960 if (minSize
.x
> 0 || minSize
.y
> 0)
962 hints_mask
|= GDK_HINT_MIN_SIZE
;
963 hints
.min_width
= minSize
.x
- sizeDecor
.x
;
964 if (hints
.min_width
< 0)
966 hints
.min_height
= minSize
.y
- sizeDecor
.y
;
967 if (hints
.min_height
< 0)
968 hints
.min_height
= 0;
970 if (maxSize
.x
> 0 || maxSize
.y
> 0)
972 hints_mask
|= GDK_HINT_MAX_SIZE
;
973 hints
.max_width
= maxSize
.x
- sizeDecor
.x
;
974 if (hints
.max_width
< 0)
975 hints
.max_width
= INT_MAX
;
976 hints
.max_height
= maxSize
.y
- sizeDecor
.y
;
977 if (hints
.max_height
< 0)
978 hints
.max_height
= INT_MAX
;
980 if (incW
> 0 || incH
> 0)
982 hints_mask
|= GDK_HINT_RESIZE_INC
;
983 hints
.width_inc
= incW
> 0 ? incW
: 1;
984 hints
.height_inc
= incH
> 0 ? incH
: 1;
986 gtk_window_set_geometry_hints(
987 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
990 void wxTopLevelWindowGTK
::GtkOnSize()
993 if (m_resizing
) return;
996 if ( m_wxwindow
== NULL
) return;
1003 GTKDoGetSize(&w
, &h
);
1004 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
1011 // send size event to frame
1012 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1013 event
.SetEventObject( this );
1014 GetEventHandler()->ProcessEvent( event
);
1019 bool wxTopLevelWindowGTK
::IsDecorCacheable() const
1024 void wxTopLevelWindowGTK
::OnInternalIdle()
1026 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
1030 // we'll come back later
1034 // set the focus if not done yet and if we can already do it
1035 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
1037 if ( g_delayedFocus
&&
1038 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
1040 wxLogTrace(_T("focus"),
1041 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1042 g_delayedFocus
->GetClassInfo()->GetClassName(),
1043 g_delayedFocus
->GetLabel().c_str());
1045 g_delayedFocus
->SetFocus();
1046 g_delayedFocus
= NULL
;
1050 wxWindow
::OnInternalIdle();
1052 // Synthetize activate events.
1053 if ( g_sendActivateEvent
!= -1 )
1055 bool activate
= g_sendActivateEvent
!= 0;
1057 // if (!activate) wxPrintf( wxT("de") );
1058 // wxPrintf( wxT("activate\n") );
1061 g_sendActivateEvent
= -1;
1063 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1067 // ----------------------------------------------------------------------------
1069 // ----------------------------------------------------------------------------
1071 void wxTopLevelWindowGTK
::SetTitle( const wxString
&title
)
1073 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1075 if ( title
== m_title
)
1080 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1083 void wxTopLevelWindowGTK
::SetIcons( const wxIconBundle
&icons
)
1085 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1087 wxTopLevelWindowBase
::SetIcons( icons
);
1091 const size_t numIcons
= icons
.GetIconCount();
1092 for ( size_t i
= 0; i
< numIcons
; i
++ )
1094 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1097 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1101 // ----------------------------------------------------------------------------
1102 // frame state: maximized/iconized/normal
1103 // ----------------------------------------------------------------------------
1105 void wxTopLevelWindowGTK
::Maximize(bool maximize
)
1108 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1110 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1113 bool wxTopLevelWindowGTK
::IsMaximized() const
1115 if(!m_widget
->window
)
1118 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1121 void wxTopLevelWindowGTK
::Restore()
1123 // "Present" seems similar enough to "restore"
1124 gtk_window_present( GTK_WINDOW( m_widget
) );
1127 void wxTopLevelWindowGTK
::Iconize( bool iconize
)
1130 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1132 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1135 bool wxTopLevelWindowGTK
::IsIconized() const
1137 return m_isIconized
;
1140 void wxTopLevelWindowGTK
::SetIconizeState(bool iconize
)
1142 if ( iconize
!= m_isIconized
)
1144 m_isIconized
= iconize
;
1145 (void)SendIconizeEvent(iconize
);
1149 void wxTopLevelWindowGTK
::AddGrab()
1154 gtk_grab_add( m_widget
);
1155 wxGUIEventLoop().Run();
1156 gtk_grab_remove( m_widget
);
1160 void wxTopLevelWindowGTK
::RemoveGrab()
1171 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1175 if (region
.IsEmpty())
1177 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1181 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1189 bool wxTopLevelWindowGTK
::SetShape(const wxRegion
& region
)
1191 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1192 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1194 GdkWindow
*window
= NULL
;
1197 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1198 do_shape_combine_region(window
, region
);
1200 window
= m_widget
->window
;
1201 return do_shape_combine_region(window
, region
);
1204 bool wxTopLevelWindowGTK
::IsActive()
1206 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1209 void wxTopLevelWindowGTK
::RequestUserAttention(int flags
)
1211 bool new_hint_value
= false;
1213 // FIXME: This is a workaround to focus handling problem
1214 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1215 // yet been processed, and the internal focus system is not up to date yet.
1216 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1217 ::wxYieldIfNeeded();
1219 if(m_urgency_hint
>= 0)
1220 g_source_remove(m_urgency_hint
);
1222 m_urgency_hint
= -2;
1224 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1226 new_hint_value
= true;
1228 if (flags
& wxUSER_ATTENTION_INFO
)
1230 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1232 m_urgency_hint
= -1;
1236 #if GTK_CHECK_VERSION(2,7,0)
1237 if(!gtk_check_version(2,7,0))
1238 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1241 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1244 void wxTopLevelWindowGTK
::SetWindowStyleFlag( long style
)
1246 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1247 // Store which styles were changed
1248 long styleChanges
= style
^ m_windowStyle
;
1251 // Process wxWindow styles. This also updates the internal variable
1252 // Therefore m_windowStyle bits carry now the _new_ style values
1253 wxWindow
::SetWindowStyleFlag(style
);
1255 // just return for now if widget does not exist yet
1260 if ( (styleChanges
& wxSTAY_ON_TOP
) && !gtk_check_version(2,4,0) )
1261 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), m_windowStyle
& wxSTAY_ON_TOP
);
1263 #if GTK_CHECK_VERSION(2,2,0)
1264 if ( (styleChanges
& wxFRAME_NO_TASKBAR
) && !gtk_check_version(2,2,0) )
1266 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), m_windowStyle
& wxFRAME_NO_TASKBAR
);
1271 /* Get the X Window between child and the root window.
1272 This should usually be the WM managed XID */
1273 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1275 Window root
, parent
;
1277 unsigned int nchildren
;
1279 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1282 while (parent
!= root
) {
1284 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1291 bool wxTopLevelWindowGTK
::SetTransparent(wxByte alpha
)
1293 if (!m_widget
|| !m_widget
->window
)
1296 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1297 // We need to get the X Window that has the root window as the immediate parent
1298 // and m_widget->window as a child. This should be the X Window that the WM manages and
1299 // from which the opacity property is checked from.
1300 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1303 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1305 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1308 long opacity
= alpha
* 0x1010101L
;
1309 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1310 XA_CARDINAL
, 32, PropModeReplace
,
1311 (unsigned char *) &opacity
, 1L);
1317 bool wxTopLevelWindowGTK
::CanSetTransparent()
1319 // allow to override automatic detection as it's far from perfect
1320 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1321 if ( wxSystemOptions
::HasOption(SYSOPT_TRANSPARENT
) )
1323 return wxSystemOptions
::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1326 #if GTK_CHECK_VERSION(2,10,0)
1327 if (!gtk_check_version(2,10,0))
1329 return (gtk_widget_is_composited (m_widget
));
1332 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1337 #if 0 // Don't be optimistic here for the sake of wxAUI
1338 int opcode
, event
, error
;
1339 // Check for the existence of a RGBA visual instead?
1340 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1341 "Composite", &opcode
, &event
, &error
);