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>
49 #include <hildon-widgets/hildon-program.h>
50 #include <hildon-widgets/hildon-window.h>
51 #endif // wxUSE_LIBHILDON
53 // ----------------------------------------------------------------------------
55 // ----------------------------------------------------------------------------
57 // this is incremented while a modal dialog is shown
58 int wxOpenModalDialogsCount
= 0;
60 extern wxWindowGTK
*g_delayedFocus
;
62 // the frame that is currently active (i.e. its child has focus). It is
63 // used to generate wxActivateEvents
64 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
65 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
67 // if we detect that the app has got/lost the focus, we set this variable to
68 // either TRUE or FALSE and an activate event will be sent during the next
69 // OnIdle() call and it is reset to -1: this value means that we shouldn't
70 // send any activate events at all
71 static int g_sendActivateEvent
= -1;
73 //-----------------------------------------------------------------------------
74 // RequestUserAttention related functions
75 //-----------------------------------------------------------------------------
78 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
81 wxASSERT_MSG( GTK_WIDGET_REALIZED(win
), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
82 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
85 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
88 wm_hints
= XAllocWMHints();
91 wm_hints
->flags
|= XUrgencyHint
;
93 wm_hints
->flags
&= ~XUrgencyHint
;
95 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
99 static gboolean
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
101 #if GTK_CHECK_VERSION(2,7,0)
102 if(!gtk_check_version(2,7,0))
103 gtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
106 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
108 win
->m_urgency_hint
= -2;
113 //-----------------------------------------------------------------------------
115 //-----------------------------------------------------------------------------
118 static gboolean
gtk_frame_focus_in_callback( GtkWidget
*widget
,
119 GdkEvent
*WXUNUSED(event
),
120 wxTopLevelWindowGTK
*win
)
122 switch ( g_sendActivateEvent
)
125 // we've got focus from outside, synthetize wxActivateEvent
126 g_sendActivateEvent
= 1;
130 // another our window just lost focus, it was already ours before
131 // - don't send any wxActivateEvent
132 g_sendActivateEvent
= -1;
137 g_lastActiveFrame
= g_activeFrame
;
139 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
141 // MR: wxRequestUserAttention related block
142 switch( win
->m_urgency_hint
)
145 g_source_remove( win
->m_urgency_hint
);
146 // no break, fallthrough to remove hint too
148 #if GTK_CHECK_VERSION(2,7,0)
149 if(!gtk_check_version(2,7,0))
150 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
154 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
157 win
->m_urgency_hint
= -2;
163 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
164 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
165 event
.SetEventObject(g_activeFrame
);
166 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
172 //-----------------------------------------------------------------------------
174 //-----------------------------------------------------------------------------
178 gboolean
gtk_frame_focus_out_callback(GtkWidget
* WXUNUSED(widget
),
179 GdkEventFocus
*WXUNUSED(gdk_event
),
180 wxTopLevelWindowGTK
* WXUNUSED(win
))
182 // if the focus goes out of our app alltogether, OnIdle() will send
183 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
184 // g_sendActivateEvent to -1
185 g_sendActivateEvent
= 0;
187 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
189 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
193 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
194 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
195 event
.SetEventObject(g_activeFrame
);
196 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
198 g_activeFrame
= NULL
;
205 //-----------------------------------------------------------------------------
207 // Get cached size of WM decorations for given GdkWMDecoration.
208 static wxSize
& GetDecorSize(int decor
)
210 // In testing, only the title bar and GDK_DECOR_BORDER made a difference.
211 // 4 possible combinations of title bar and border
212 static wxSize size
[4];
216 if (decor
& (GDK_DECOR_MENU
| GDK_DECOR_MINIMIZE
| GDK_DECOR_MAXIMIZE
| GDK_DECOR_TITLE
))
219 if (decor
& GDK_DECOR_BORDER
)
224 //-----------------------------------------------------------------------------
225 // "size_allocate" from m_wxwindow
226 //-----------------------------------------------------------------------------
230 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxTopLevelWindowGTK
* win
)
232 if (win
->m_oldClientWidth
!= alloc
->width
||
233 win
->m_oldClientHeight
!= alloc
->height
)
235 win
->m_oldClientWidth
= alloc
->width
;
236 win
->m_oldClientHeight
= alloc
->height
;
238 if (!win
->IsFullScreen())
239 sizeDecor
= GetDecorSize(win
->m_gdkDecor
);
240 win
->m_width
= win
->m_widget
->allocation
.width
+ sizeDecor
.x
;
241 win
->m_height
= win
->m_widget
->allocation
.height
+ sizeDecor
.y
;
242 if (!win
->IsIconized())
244 wxSizeEvent
event(win
->GetSize(), win
->GetId());
245 event
.SetEventObject(win
);
246 win
->GetEventHandler()->ProcessEvent(event
);
248 // else the window is currently unmapped, don't generate size events
253 // ----------------------------------------------------------------------------
255 // ----------------------------------------------------------------------------
259 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
260 GtkRequisition
*requisition
,
261 wxTopLevelWindowGTK
*win
)
263 // we must return the size of the window without WM decorations, otherwise
264 // GTK+ gets confused, so don't call just GetSize() here
265 win
->GTKDoGetSize(&requisition
->width
, &requisition
->height
);
269 //-----------------------------------------------------------------------------
271 //-----------------------------------------------------------------------------
275 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
276 GdkEvent
*WXUNUSED(event
),
277 wxTopLevelWindowGTK
*win
)
279 if (win
->IsEnabled() &&
280 (wxOpenModalDialogsCount
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
289 //-----------------------------------------------------------------------------
291 //-----------------------------------------------------------------------------
295 gtk_frame_configure_callback( GtkWidget
* widget
,
296 GdkEventConfigure
*WXUNUSED(event
),
297 wxTopLevelWindowGTK
*win
)
299 if (!win
->m_hasVMT
|| !win
->IsShown())
303 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
307 wxMoveEvent
mevent(point
, win
->GetId());
308 mevent
.SetEventObject( win
);
309 win
->GetEventHandler()->ProcessEvent( mevent
);
315 //-----------------------------------------------------------------------------
316 // "realize" from m_widget
317 //-----------------------------------------------------------------------------
319 // we cannot MWM hints and icons before the widget has been realized,
320 // so we do this directly after realization
324 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
325 wxTopLevelWindowGTK
*win
)
327 // All this is for Motif Window Manager "hints" and is supposed to be
328 // recognized by other WM as well. Not tested.
329 gdk_window_set_decorations(win
->m_widget
->window
,
330 (GdkWMDecoration
)win
->m_gdkDecor
);
331 gdk_window_set_functions(win
->m_widget
->window
,
332 (GdkWMFunction
)win
->m_gdkFunc
);
334 // GTK's shrinking/growing policy
335 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
336 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
338 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
341 wxIconBundle iconsOld
= win
->GetIcons();
342 if ( !iconsOld
.IsEmpty() )
344 win
->SetIcon( wxNullIcon
);
345 win
->SetIcons( iconsOld
);
350 //-----------------------------------------------------------------------------
351 // "map_event" from m_widget
352 //-----------------------------------------------------------------------------
356 gtk_frame_map_callback( GtkWidget
* widget
,
357 GdkEvent
* WXUNUSED(event
),
358 wxTopLevelWindow
*win
)
360 // Calculate size of WM decorations.
361 // Done here in case WM does not support the _NET_FRAME_EXTENTS property.
362 if (win
->IsDecorCacheable() && !win
->IsFullScreen())
365 gdk_window_get_frame_extents(widget
->window
, &rect
);
367 gdk_drawable_get_size(widget
->window
, &w
, &h
);
368 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
369 const wxSize size
= wxSize(rect
.width
- w
, rect
.height
- h
);
370 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
372 // Update window size and frame extents cache
373 win
->m_width
= rect
.width
;
374 win
->m_height
= rect
.height
;
379 const bool wasIconized
= win
->IsIconized();
381 win
->SetIconizeState(false);
385 // Because GetClientSize() returns (0,0) when IsIconized() is true,
386 // a size event must be generated, just in case GetClientSize() was
387 // called while iconized. This specifically happens when restoring a
388 // tlw that was "rolled up" with some WMs.
389 // Queue a resize rather than sending size event directly to allow
390 // children to be made visible first.
391 win
->m_oldClientWidth
= 0;
392 gtk_widget_queue_resize(win
->m_wxwindow
);
399 //-----------------------------------------------------------------------------
400 // "unmap_event" from m_widget
401 //-----------------------------------------------------------------------------
405 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
406 GdkEvent
* WXUNUSED(event
),
407 wxTopLevelWindow
*win
)
409 win
->SetIconizeState(true);
414 //-----------------------------------------------------------------------------
415 // "property_notify_event" from m_widget
416 //-----------------------------------------------------------------------------
419 static gboolean
property_notify_event(
420 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
422 // Watch for changes to _NET_FRAME_EXTENTS property
423 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
424 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
&&
425 win
->IsDecorCacheable() && !win
->IsFullScreen())
427 Atom xproperty
= gdk_x11_atom_to_xatom_for_display(
428 gdk_drawable_get_display(event
->window
), property
);
431 gulong nitems
, bytes_after
;
433 Status status
= XGetWindowProperty(
434 gdk_x11_drawable_get_xdisplay(event
->window
),
435 gdk_x11_drawable_get_xid(event
->window
),
437 0, 4, false, XA_CARDINAL
,
438 &type
, &format
, &nitems
, &bytes_after
, (guchar
**)&data
);
439 if (status
== Success
&& data
&& nitems
== 4)
441 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
443 wxSize(int(data
[0] + data
[1]), int(data
[2] + data
[3]));
444 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
446 // Update window size and frame extents cache
447 win
->m_width
+= size
.x
- decorSize
.x
;
448 win
->m_height
+= size
.y
- decorSize
.y
;
449 if (win
->m_width
< 0) win
->m_width
= 0;
450 if (win
->m_height
< 0) win
->m_height
= 0;
452 win
->m_oldClientWidth
= 0;
453 gtk_widget_queue_resize(win
->m_wxwindow
);
463 BEGIN_EVENT_TABLE(wxTopLevelWindowGTK
, wxTopLevelWindowBase
)
464 EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged
)
468 // ----------------------------------------------------------------------------
469 // wxTopLevelWindowGTK creation
470 // ----------------------------------------------------------------------------
472 void wxTopLevelWindowGTK::Init()
474 m_mainWidget
= (GtkWidget
*) NULL
;
475 m_isIconized
= false;
476 m_fsIsShowing
= false;
477 m_themeEnabled
= true;
478 m_gdkDecor
= m_gdkFunc
= 0;
484 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
486 const wxString
& title
,
488 const wxSize
& sizeOrig
,
490 const wxString
&name
)
492 // always create a frame of some reasonable, even if arbitrary, size (at
493 // least for MSW compatibility)
494 wxSize size
= sizeOrig
;
495 size
.x
= WidthDefault(size
.x
);
496 size
.y
= HeightDefault(size
.y
);
498 wxTopLevelWindows
.Append( this );
500 if (!PreCreation( parent
, pos
, size
) ||
501 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
503 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
509 // NB: m_widget may be !=NULL if it was created by derived class' Create,
510 // e.g. in wxTaskBarIconAreaGTK
511 if (m_widget
== NULL
)
514 // we must create HildonWindow and not a normal GtkWindow as the latter
515 // doesn't look correctly in Maemo environment and it must also be
516 // registered with the main program object
517 m_widget
= hildon_window_new();
518 hildon_program_add_window(wxTheApp
->GetHildonProgram(),
519 HILDON_WINDOW(m_widget
));
520 #else // !wxUSE_LIBHILDON
521 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
522 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
524 // Tell WM that this is a dialog window and make it center
525 // on parent by default (this is what GtkDialog ctor does):
526 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
527 GDK_WINDOW_TYPE_HINT_DIALOG
);
528 gtk_window_set_position(GTK_WINDOW(m_widget
),
529 GTK_WIN_POS_CENTER_ON_PARENT
);
533 if (style
& wxFRAME_TOOL_WINDOW
)
535 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
536 GDK_WINDOW_TYPE_HINT_UTILITY
);
538 // On some WMs, like KDE, a TOOL_WINDOW will still show
539 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
540 // For consistency between WMs and with Windows, we
541 // should set the NO_TASKBAR flag which will apply
542 // the set_skip_taskbar_hint if it is available,
543 // ensuring no taskbar entry will appear.
544 style
|= wxFRAME_NO_TASKBAR
;
547 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
550 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
551 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
552 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
553 (style
& wxFRAME_FLOAT_ON_PARENT
)))
555 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
556 GTK_WINDOW(topParent
->m_widget
) );
559 if (style
& wxFRAME_NO_TASKBAR
)
561 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
564 if (style
& wxSTAY_ON_TOP
)
566 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
571 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
574 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
575 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
577 g_signal_connect (m_widget
, "delete_event",
578 G_CALLBACK (gtk_frame_delete_callback
), this);
580 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
581 m_mainWidget
= gtk_vbox_new(false, 0);
582 gtk_widget_show( m_mainWidget
);
583 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
584 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
586 // m_wxwindow is the client area
587 m_wxwindow
= wxPizza::New();
588 gtk_widget_show( m_wxwindow
);
589 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
591 // we donm't allow the frame to get the focus as otherwise
592 // the frame will grab it at arbitrary focus changes
593 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
595 if (m_parent
) m_parent
->AddChild( this );
597 g_signal_connect(m_wxwindow
, "size_allocate",
598 G_CALLBACK(size_allocate
), this);
600 g_signal_connect (m_widget
, "size_request",
601 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
604 if ((m_x
!= -1) || (m_y
!= -1))
605 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
607 // we cannot set MWM hints and icons before the widget has
608 // been realized, so we do this directly after realization
609 g_signal_connect (m_widget
, "realize",
610 G_CALLBACK (gtk_frame_realized_callback
), this);
612 // map and unmap for iconized state
613 g_signal_connect (m_widget
, "map_event",
614 G_CALLBACK (gtk_frame_map_callback
), this);
615 g_signal_connect (m_widget
, "unmap_event",
616 G_CALLBACK (gtk_frame_unmap_callback
), this);
619 g_signal_connect (m_widget
, "configure_event",
620 G_CALLBACK (gtk_frame_configure_callback
), this);
623 g_signal_connect_after (m_widget
, "focus_in_event",
624 G_CALLBACK (gtk_frame_focus_in_callback
), this);
625 g_signal_connect_after (m_widget
, "focus_out_event",
626 G_CALLBACK (gtk_frame_focus_out_callback
), this);
628 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
629 g_signal_connect(m_widget
, "property_notify_event",
630 G_CALLBACK(property_notify_event
), this);
633 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
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()
685 // it can also be a (standard) dialog
686 if ( HILDON_IS_WINDOW(m_widget
) )
688 hildon_program_remove_window(wxTheApp
->GetHildonProgram(),
689 HILDON_WINDOW(m_widget
));
691 #endif // wxUSE_LIBHILDON
695 wxFAIL_MSG(_T("Window still grabbed"));
699 m_isBeingDeleted
= true;
701 // it may also be GtkScrolledWindow in the case of an MDI child
702 if (GTK_IS_WINDOW(m_widget
))
704 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
707 if (g_activeFrame
== this)
708 g_activeFrame
= NULL
;
709 if (g_lastActiveFrame
== this)
710 g_lastActiveFrame
= NULL
;
713 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
716 m_gdkFunc
|= GDK_FUNC_CLOSE
;
718 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
720 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
721 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
726 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long)
728 if (show
== m_fsIsShowing
)
729 return false; // return what?
731 m_fsIsShowing
= show
;
733 wxX11FullScreenMethod method
=
734 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
735 (WXWindow
)GDK_ROOT_WINDOW());
737 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
738 // to switch to fullscreen, which is not always available. We must
739 // check if WM supports the spec and use legacy methods if it
741 if ( method
== wxX11_FS_WMSPEC
)
744 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
746 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
750 GdkWindow
*window
= m_widget
->window
;
754 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
755 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
757 int screen_width
,screen_height
;
758 wxDisplaySize( &screen_width
, &screen_height
);
760 gint client_x
, client_y
, root_x
, root_y
;
763 m_fsSaveGdkFunc
= m_gdkFunc
;
764 m_fsSaveGdkDecor
= m_gdkDecor
;
765 m_gdkFunc
= m_gdkDecor
= 0;
766 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
767 gdk_window_set_functions(window
, (GdkWMFunction
)0);
769 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
770 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
771 &width
, &height
, NULL
);
773 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
774 screen_width
+ 1, screen_height
+ 1);
776 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
777 (WXWindow
)GDK_ROOT_WINDOW(),
778 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
779 show
, &m_fsSaveFrame
, method
);
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
);
788 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
789 (WXWindow
)GDK_ROOT_WINDOW(),
790 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
791 show
, &m_fsSaveFrame
, method
);
793 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
794 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
798 // documented behaviour is to show the window if it's still hidden when
799 // showing it full screen
806 // ----------------------------------------------------------------------------
807 // overridden wxWindow methods
808 // ----------------------------------------------------------------------------
810 bool wxTopLevelWindowGTK::Show( bool show
)
812 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
814 if (show
&& !IsShown())
816 // size_allocate signals occur in reverse order (bottom to top).
817 // Things work better if the initial wxSizeEvents are sent (from the
818 // top down), before the initial size_allocate signals occur.
819 wxSizeEvent
event(GetSize(), GetId());
820 event
.SetEventObject(this);
821 GetEventHandler()->ProcessEvent(event
);
824 bool change
= wxTopLevelWindowBase::Show(show
);
828 // make sure window has a non-default position, so when it is shown
829 // again, it won't be repositioned by WM as if it were a new window
830 // Note that this must be done _after_ the window is hidden.
831 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
837 void wxTopLevelWindowGTK::Raise()
839 gtk_window_present( GTK_WINDOW( m_widget
) );
842 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
844 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
847 // ----------------------------------------------------------------------------
849 // ----------------------------------------------------------------------------
851 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
853 wxSize
size(m_width
, m_height
);
856 size
-= GetDecorSize(m_gdkDecor
);
857 if (size
.x
< 0) size
.x
= 0;
858 if (size
.y
< 0) size
.y
= 0;
860 if (width
) *width
= size
.x
;
861 if (height
) *height
= size
.y
;
864 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
866 wxCHECK_RET( m_widget
, wxT("invalid frame") );
868 // deal with the position first
872 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
874 // -1 means "use existing" unless the flag above is specified
880 else // wxSIZE_ALLOW_MINUS_ONE
886 if ( m_x
!= old_x
|| m_y
!= old_y
)
888 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
891 const wxSize
oldSize(m_width
, m_height
);
897 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
900 GTKDoGetSize(&w
, &h
);
901 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
903 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
904 wxSizeEvent
event(GetSize(), GetId());
905 event
.SetEventObject(this);
906 GetEventHandler()->ProcessEvent(event
);
910 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
912 wxASSERT_MSG(m_widget
, wxT("invalid frame"));
916 // for consistency with wxMSW, client area is supposed to be empty for
917 // the iconized windows
925 GTKDoGetSize(width
, height
);
929 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
933 wxTopLevelWindowBase::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
935 const wxSize minSize
= GetMinSize();
936 const wxSize maxSize
= GetMaxSize();
939 const wxSize sizeDecor
= GetDecorSize(m_gdkDecor
);
940 if (minSize
.x
> 0 || minSize
.y
> 0)
942 hints_mask
|= GDK_HINT_MIN_SIZE
;
943 hints
.min_width
= minSize
.x
- sizeDecor
.x
;
944 if (hints
.min_width
< 0)
946 hints
.min_height
= minSize
.y
- sizeDecor
.y
;
947 if (hints
.min_height
< 0)
948 hints
.min_height
= 0;
950 if (maxSize
.x
> 0 || maxSize
.y
> 0)
952 hints_mask
|= GDK_HINT_MAX_SIZE
;
953 hints
.max_width
= maxSize
.x
- sizeDecor
.x
;
954 if (hints
.max_width
< 0)
955 hints
.max_width
= INT_MAX
;
956 hints
.max_height
= maxSize
.y
- sizeDecor
.y
;
957 if (hints
.max_height
< 0)
958 hints
.max_height
= INT_MAX
;
960 if (incW
> 0 || incH
> 0)
962 hints_mask
|= GDK_HINT_RESIZE_INC
;
963 hints
.width_inc
= incW
> 0 ? incW
: 1;
964 hints
.height_inc
= incH
> 0 ? incH
: 1;
966 gtk_window_set_geometry_hints(
967 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
970 bool wxTopLevelWindowGTK::IsDecorCacheable() const
975 void wxTopLevelWindowGTK::OnInternalIdle()
977 // set the focus if not done yet and if we can already do it
978 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
980 if ( g_delayedFocus
&&
981 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
983 wxLogTrace(_T("focus"),
984 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
985 g_delayedFocus
->GetClassInfo()->GetClassName(),
986 g_delayedFocus
->GetLabel().c_str());
988 g_delayedFocus
->SetFocus();
989 g_delayedFocus
= NULL
;
993 wxWindow::OnInternalIdle();
995 // Synthetize activate events.
996 if ( g_sendActivateEvent
!= -1 )
998 bool activate
= g_sendActivateEvent
!= 0;
1000 // if (!activate) wxPrintf( wxT("de") );
1001 // wxPrintf( wxT("activate\n") );
1004 g_sendActivateEvent
= -1;
1006 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1010 // ----------------------------------------------------------------------------
1012 // ----------------------------------------------------------------------------
1014 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1016 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1018 if ( title
== m_title
)
1023 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1026 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1028 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1030 wxTopLevelWindowBase::SetIcons( icons
);
1034 const size_t numIcons
= icons
.GetIconCount();
1035 for ( size_t i
= 0; i
< numIcons
; i
++ )
1037 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1040 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1044 // ----------------------------------------------------------------------------
1045 // frame state: maximized/iconized/normal
1046 // ----------------------------------------------------------------------------
1048 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1051 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1053 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1056 bool wxTopLevelWindowGTK::IsMaximized() const
1058 if(!m_widget
->window
)
1061 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1064 void wxTopLevelWindowGTK::Restore()
1066 // "Present" seems similar enough to "restore"
1067 gtk_window_present( GTK_WINDOW( m_widget
) );
1070 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1073 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1075 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1078 bool wxTopLevelWindowGTK::IsIconized() const
1080 return m_isIconized
;
1083 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1085 if ( iconize
!= m_isIconized
)
1087 m_isIconized
= iconize
;
1088 (void)SendIconizeEvent(iconize
);
1092 void wxTopLevelWindowGTK::AddGrab()
1097 gtk_grab_add( m_widget
);
1098 wxGUIEventLoop().Run();
1099 gtk_grab_remove( m_widget
);
1103 void wxTopLevelWindowGTK::RemoveGrab()
1114 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1118 if (region
.IsEmpty())
1120 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1124 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1132 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1134 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1135 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1137 GdkWindow
*window
= NULL
;
1140 do_shape_combine_region(m_wxwindow
->window
, region
);
1142 window
= m_widget
->window
;
1143 return do_shape_combine_region(window
, region
);
1146 bool wxTopLevelWindowGTK::IsActive()
1148 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1151 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1153 bool new_hint_value
= false;
1155 // FIXME: This is a workaround to focus handling problem
1156 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1157 // yet been processed, and the internal focus system is not up to date yet.
1158 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1159 ::wxYieldIfNeeded();
1161 if(m_urgency_hint
>= 0)
1162 g_source_remove(m_urgency_hint
);
1164 m_urgency_hint
= -2;
1166 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1168 new_hint_value
= true;
1170 if (flags
& wxUSER_ATTENTION_INFO
)
1172 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1174 m_urgency_hint
= -1;
1178 #if GTK_CHECK_VERSION(2,7,0)
1179 if(!gtk_check_version(2,7,0))
1180 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1183 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1186 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1188 // Store which styles were changed
1189 long styleChanges
= style
^ m_windowStyle
;
1191 // Process wxWindow styles. This also updates the internal variable
1192 // Therefore m_windowStyle bits carry now the _new_ style values
1193 wxWindow::SetWindowStyleFlag(style
);
1195 // just return for now if widget does not exist yet
1199 if ( styleChanges
& wxSTAY_ON_TOP
)
1201 gtk_window_set_keep_above(GTK_WINDOW(m_widget
),
1202 m_windowStyle
& wxSTAY_ON_TOP
);
1205 if ( styleChanges
& wxFRAME_NO_TASKBAR
)
1207 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
),
1208 m_windowStyle
& wxFRAME_NO_TASKBAR
);
1212 /* Get the X Window between child and the root window.
1213 This should usually be the WM managed XID */
1214 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1216 Window root
, parent
;
1218 unsigned int nchildren
;
1220 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1223 while (parent
!= root
) {
1225 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1232 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1234 if (!m_widget
|| !m_widget
->window
)
1237 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1238 // We need to get the X Window that has the root window as the immediate parent
1239 // and m_widget->window as a child. This should be the X Window that the WM manages and
1240 // from which the opacity property is checked from.
1241 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1244 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1246 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1249 long opacity
= alpha
* 0x1010101L
;
1250 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1251 XA_CARDINAL
, 32, PropModeReplace
,
1252 (unsigned char *) &opacity
, 1L);
1258 bool wxTopLevelWindowGTK::CanSetTransparent()
1260 // allow to override automatic detection as it's far from perfect
1261 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1262 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1264 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1267 #if GTK_CHECK_VERSION(2,10,0)
1268 if (!gtk_check_version(2,10,0))
1270 return (gtk_widget_is_composited (m_widget
));
1273 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1278 #if 0 // Don't be optimistic here for the sake of wxAUI
1279 int opcode
, event
, error
;
1280 // Check for the existence of a RGBA visual instead?
1281 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1282 "Composite", &opcode
, &event
, &error
);
1286 void wxTopLevelWindowGTK::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1288 // We don't know the order in which top-level windows will
1289 // be notified, so we need to clear the system objects
1290 // for each top-level window.
1291 extern void wxClearGtkSystemObjects();
1292 wxClearGtkSystemObjects();
1294 // wxWindowBase::OnSysColourChanged will propagate event