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 wxSize
size(win
->m_widget
->allocation
.width
,
239 win
->m_widget
->allocation
.height
);
240 if (!win
->IsFullScreen())
241 size
+= win
->m_decorSize
;
242 win
->m_width
= size
.x
;
243 win
->m_height
= size
.y
;
245 if (!win
->IsIconized())
247 wxSizeEvent
event(size
, win
->GetId());
248 event
.SetEventObject(win
);
249 win
->GetEventHandler()->ProcessEvent(event
);
251 // else the window is currently unmapped, don't generate size events
256 // ----------------------------------------------------------------------------
258 // ----------------------------------------------------------------------------
262 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
263 GtkRequisition
*requisition
,
264 wxTopLevelWindowGTK
*win
)
266 // we must return the size of the window without WM decorations, otherwise
267 // GTK+ gets confused, so don't call just GetSize() here
268 win
->GTKDoGetSize(&requisition
->width
, &requisition
->height
);
272 //-----------------------------------------------------------------------------
274 //-----------------------------------------------------------------------------
278 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
279 GdkEvent
*WXUNUSED(event
),
280 wxTopLevelWindowGTK
*win
)
282 if (win
->IsEnabled() &&
283 (wxOpenModalDialogsCount
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
292 //-----------------------------------------------------------------------------
294 //-----------------------------------------------------------------------------
298 gtk_frame_configure_callback( GtkWidget
* widget
,
299 GdkEventConfigure
*WXUNUSED(event
),
300 wxTopLevelWindowGTK
*win
)
302 if (!win
->m_hasVMT
|| !win
->IsShown())
306 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
310 wxMoveEvent
mevent(point
, win
->GetId());
311 mevent
.SetEventObject( win
);
312 win
->GetEventHandler()->ProcessEvent( mevent
);
318 //-----------------------------------------------------------------------------
319 // "realize" from m_widget
320 //-----------------------------------------------------------------------------
322 // we cannot MWM hints and icons before the widget has been realized,
323 // so we do this directly after realization
327 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
328 wxTopLevelWindowGTK
*win
)
330 // All this is for Motif Window Manager "hints" and is supposed to be
331 // recognized by other WM as well. Not tested.
332 gdk_window_set_decorations(win
->m_widget
->window
,
333 (GdkWMDecoration
)win
->m_gdkDecor
);
334 gdk_window_set_functions(win
->m_widget
->window
,
335 (GdkWMFunction
)win
->m_gdkFunc
);
337 // GTK's shrinking/growing policy
338 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
339 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
341 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
344 wxIconBundle iconsOld
= win
->GetIcons();
345 if ( !iconsOld
.IsEmpty() )
347 win
->SetIcon( wxNullIcon
);
348 win
->SetIcons( iconsOld
);
353 //-----------------------------------------------------------------------------
354 // "map_event" from m_widget
355 //-----------------------------------------------------------------------------
359 gtk_frame_map_callback( GtkWidget
* widget
,
360 GdkEvent
* WXUNUSED(event
),
361 wxTopLevelWindow
*win
)
363 // Calculate size of WM decorations.
364 // Done here in case WM does not support the _NET_FRAME_EXTENTS property.
365 if (win
->IsDecorCacheable() && !win
->IsFullScreen())
368 gdk_window_get_frame_extents(widget
->window
, &rect
);
370 gdk_drawable_get_size(widget
->window
, &w
, &h
);
371 const wxSize decorSize
= wxSize(rect
.width
- w
, rect
.height
- h
);
372 if (win
->m_decorSize
!= decorSize
)
374 // Update window size and frame extents cache
375 win
->m_width
= rect
.width
;
376 win
->m_height
= rect
.height
;
377 win
->m_decorSize
= decorSize
;
378 GetDecorSize(win
->m_gdkDecor
) = decorSize
;
382 const bool wasIconized
= win
->IsIconized();
384 win
->SetIconizeState(false);
388 // Because GetClientSize() returns (0,0) when IsIconized() is true,
389 // a size event must be generated, just in case GetClientSize() was
390 // called while iconized. This specifically happens when restoring a
391 // tlw that was "rolled up" with some WMs.
392 // Queue a resize rather than sending size event directly to allow
393 // children to be made visible first.
394 win
->m_oldClientWidth
= 0;
395 gtk_widget_queue_resize(win
->m_wxwindow
);
402 //-----------------------------------------------------------------------------
403 // "unmap_event" from m_widget
404 //-----------------------------------------------------------------------------
408 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
409 GdkEvent
* WXUNUSED(event
),
410 wxTopLevelWindow
*win
)
412 win
->SetIconizeState(true);
417 //-----------------------------------------------------------------------------
418 // "property_notify_event" from m_widget
419 //-----------------------------------------------------------------------------
422 static gboolean
property_notify_event(
423 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
425 // Watch for changes to _NET_FRAME_EXTENTS property
426 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
427 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
&&
428 win
->IsDecorCacheable() && !win
->IsFullScreen())
430 Atom xproperty
= gdk_x11_atom_to_xatom_for_display(
431 gdk_drawable_get_display(event
->window
), property
);
434 gulong nitems
, bytes_after
;
436 Status status
= XGetWindowProperty(
437 gdk_x11_drawable_get_xdisplay(event
->window
),
438 gdk_x11_drawable_get_xid(event
->window
),
440 0, 4, false, XA_CARDINAL
,
441 &type
, &format
, &nitems
, &bytes_after
, (guchar
**)&data
);
442 if (status
== Success
&& data
&& nitems
== 4)
444 const wxSize decorSize
=
445 wxSize(int(data
[0] + data
[1]), int(data
[2] + data
[3]));
446 if (win
->m_decorSize
!= decorSize
)
448 // Update window size and frame extents cache
449 win
->m_width
+= decorSize
.x
- win
->m_decorSize
.x
;
450 win
->m_height
+= decorSize
.y
- win
->m_decorSize
.y
;
451 if (win
->m_width
< 0) win
->m_width
= 0;
452 if (win
->m_height
< 0) win
->m_height
= 0;
453 win
->m_decorSize
= decorSize
;
454 GetDecorSize(win
->m_gdkDecor
) = decorSize
;
455 win
->m_oldClientWidth
= 0;
456 gtk_widget_queue_resize(win
->m_wxwindow
);
466 BEGIN_EVENT_TABLE(wxTopLevelWindowGTK
, wxTopLevelWindowBase
)
467 EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged
)
471 // ----------------------------------------------------------------------------
472 // wxTopLevelWindowGTK creation
473 // ----------------------------------------------------------------------------
475 void wxTopLevelWindowGTK::Init()
477 m_mainWidget
= (GtkWidget
*) NULL
;
478 m_isIconized
= false;
479 m_fsIsShowing
= false;
480 m_themeEnabled
= true;
481 m_gdkDecor
= m_gdkFunc
= 0;
487 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
489 const wxString
& title
,
491 const wxSize
& sizeOrig
,
493 const wxString
&name
)
495 // always create a frame of some reasonable, even if arbitrary, size (at
496 // least for MSW compatibility)
497 wxSize size
= sizeOrig
;
498 size
.x
= WidthDefault(size
.x
);
499 size
.y
= HeightDefault(size
.y
);
501 wxTopLevelWindows
.Append( this );
503 if (!PreCreation( parent
, pos
, size
) ||
504 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
506 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
512 // NB: m_widget may be !=NULL if it was created by derived class' Create,
513 // e.g. in wxTaskBarIconAreaGTK
514 if (m_widget
== NULL
)
517 // we must create HildonWindow and not a normal GtkWindow as the latter
518 // doesn't look correctly in Maemo environment and it must also be
519 // registered with the main program object
520 m_widget
= hildon_window_new();
521 hildon_program_add_window(wxTheApp
->GetHildonProgram(),
522 HILDON_WINDOW(m_widget
));
523 #else // !wxUSE_LIBHILDON
524 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
525 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
527 // Tell WM that this is a dialog window and make it center
528 // on parent by default (this is what GtkDialog ctor does):
529 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
530 GDK_WINDOW_TYPE_HINT_DIALOG
);
531 gtk_window_set_position(GTK_WINDOW(m_widget
),
532 GTK_WIN_POS_CENTER_ON_PARENT
);
536 if (style
& wxFRAME_TOOL_WINDOW
)
538 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
539 GDK_WINDOW_TYPE_HINT_UTILITY
);
541 // On some WMs, like KDE, a TOOL_WINDOW will still show
542 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
543 // For consistency between WMs and with Windows, we
544 // should set the NO_TASKBAR flag which will apply
545 // the set_skip_taskbar_hint if it is available,
546 // ensuring no taskbar entry will appear.
547 style
|= wxFRAME_NO_TASKBAR
;
550 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
553 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
554 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
555 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
556 (style
& wxFRAME_FLOAT_ON_PARENT
)))
558 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
559 GTK_WINDOW(topParent
->m_widget
) );
562 if (style
& wxFRAME_NO_TASKBAR
)
564 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
567 if (style
& wxSTAY_ON_TOP
)
569 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
574 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
577 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
578 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
580 g_signal_connect (m_widget
, "delete_event",
581 G_CALLBACK (gtk_frame_delete_callback
), this);
583 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
584 m_mainWidget
= gtk_vbox_new(false, 0);
585 gtk_widget_show( m_mainWidget
);
586 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
587 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
589 // m_wxwindow is the client area
590 m_wxwindow
= wxPizza::New();
591 gtk_widget_show( m_wxwindow
);
592 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
594 // we donm't allow the frame to get the focus as otherwise
595 // the frame will grab it at arbitrary focus changes
596 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
598 if (m_parent
) m_parent
->AddChild( this );
600 g_signal_connect(m_wxwindow
, "size_allocate",
601 G_CALLBACK(size_allocate
), this);
603 g_signal_connect (m_widget
, "size_request",
604 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
607 if ((m_x
!= -1) || (m_y
!= -1))
608 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
610 // we cannot set MWM hints and icons before the widget has
611 // been realized, so we do this directly after realization
612 g_signal_connect (m_widget
, "realize",
613 G_CALLBACK (gtk_frame_realized_callback
), this);
615 // map and unmap for iconized state
616 g_signal_connect (m_widget
, "map_event",
617 G_CALLBACK (gtk_frame_map_callback
), this);
618 g_signal_connect (m_widget
, "unmap_event",
619 G_CALLBACK (gtk_frame_unmap_callback
), this);
622 g_signal_connect (m_widget
, "configure_event",
623 G_CALLBACK (gtk_frame_configure_callback
), this);
626 g_signal_connect_after (m_widget
, "focus_in_event",
627 G_CALLBACK (gtk_frame_focus_in_callback
), this);
628 g_signal_connect_after (m_widget
, "focus_out_event",
629 G_CALLBACK (gtk_frame_focus_out_callback
), this);
631 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
632 g_signal_connect(m_widget
, "property_notify_event",
633 G_CALLBACK(property_notify_event
), this);
636 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
643 m_gdkDecor
= GDK_DECOR_BORDER
;
644 m_gdkFunc
= GDK_FUNC_MOVE
;
646 // All this is for Motif Window Manager "hints" and is supposed to be
647 // recognized by other WMs as well.
648 if ((style
& wxCAPTION
) != 0)
650 m_gdkDecor
|= GDK_DECOR_TITLE
;
652 if ((style
& wxCLOSE_BOX
) != 0)
654 m_gdkFunc
|= GDK_FUNC_CLOSE
;
656 if ((style
& wxSYSTEM_MENU
) != 0)
658 m_gdkDecor
|= GDK_DECOR_MENU
;
660 if ((style
& wxMINIMIZE_BOX
) != 0)
662 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
663 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
665 if ((style
& wxMAXIMIZE_BOX
) != 0)
667 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
668 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
670 if ((style
& wxRESIZE_BORDER
) != 0)
672 m_gdkFunc
|= GDK_FUNC_RESIZE
;
673 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
677 m_decorSize
= GetDecorSize(m_gdkDecor
);
679 // m_sizeDecor needs to be set before calling GTKDoGetSize
681 GTKDoGetSize(&w
, &h
);
682 gtk_window_set_default_size(GTK_WINDOW(m_widget
), w
, h
);
687 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
690 // it can also be a (standard) dialog
691 if ( HILDON_IS_WINDOW(m_widget
) )
693 hildon_program_remove_window(wxTheApp
->GetHildonProgram(),
694 HILDON_WINDOW(m_widget
));
696 #endif // wxUSE_LIBHILDON
700 wxFAIL_MSG(_T("Window still grabbed"));
704 m_isBeingDeleted
= true;
706 // it may also be GtkScrolledWindow in the case of an MDI child
707 if (GTK_IS_WINDOW(m_widget
))
709 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
712 if (g_activeFrame
== this)
713 g_activeFrame
= NULL
;
714 if (g_lastActiveFrame
== this)
715 g_lastActiveFrame
= NULL
;
718 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
721 m_gdkFunc
|= GDK_FUNC_CLOSE
;
723 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
725 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
726 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
731 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long)
733 if (show
== m_fsIsShowing
)
734 return false; // return what?
736 m_fsIsShowing
= show
;
738 wxX11FullScreenMethod method
=
739 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
740 (WXWindow
)GDK_ROOT_WINDOW());
742 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
743 // to switch to fullscreen, which is not always available. We must
744 // check if WM supports the spec and use legacy methods if it
746 if ( method
== wxX11_FS_WMSPEC
)
749 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
751 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
755 GdkWindow
*window
= m_widget
->window
;
759 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
760 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
762 int screen_width
,screen_height
;
763 wxDisplaySize( &screen_width
, &screen_height
);
765 gint client_x
, client_y
, root_x
, root_y
;
768 m_fsSaveGdkFunc
= m_gdkFunc
;
769 m_fsSaveGdkDecor
= m_gdkDecor
;
770 m_gdkFunc
= m_gdkDecor
= 0;
771 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
772 gdk_window_set_functions(window
, (GdkWMFunction
)0);
774 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
775 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
776 &width
, &height
, NULL
);
778 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
779 screen_width
+ 1, screen_height
+ 1);
781 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
782 (WXWindow
)GDK_ROOT_WINDOW(),
783 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
784 show
, &m_fsSaveFrame
, method
);
788 m_gdkFunc
= m_fsSaveGdkFunc
;
789 m_gdkDecor
= m_fsSaveGdkDecor
;
790 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
791 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
793 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
794 (WXWindow
)GDK_ROOT_WINDOW(),
795 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
796 show
, &m_fsSaveFrame
, method
);
798 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
799 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
803 // documented behaviour is to show the window if it's still hidden when
804 // showing it full screen
811 // ----------------------------------------------------------------------------
812 // overridden wxWindow methods
813 // ----------------------------------------------------------------------------
815 bool wxTopLevelWindowGTK::Show( bool show
)
817 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
819 if (show
&& !IsShown())
821 // size_allocate signals occur in reverse order (bottom to top).
822 // Things work better if the initial wxSizeEvents are sent (from the
823 // top down), before the initial size_allocate signals occur.
824 wxSizeEvent
event(GetSize(), GetId());
825 event
.SetEventObject(this);
826 GetEventHandler()->ProcessEvent(event
);
829 bool change
= wxTopLevelWindowBase::Show(show
);
833 // make sure window has a non-default position, so when it is shown
834 // again, it won't be repositioned by WM as if it were a new window
835 // Note that this must be done _after_ the window is hidden.
836 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
842 void wxTopLevelWindowGTK::Raise()
844 gtk_window_present( GTK_WINDOW( m_widget
) );
847 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
849 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
852 // ----------------------------------------------------------------------------
854 // ----------------------------------------------------------------------------
856 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
858 wxSize
size(m_width
, m_height
);
862 if (size
.x
< 0) size
.x
= 0;
863 if (size
.y
< 0) size
.y
= 0;
865 if (width
) *width
= size
.x
;
866 if (height
) *height
= size
.y
;
869 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
871 wxCHECK_RET( m_widget
, wxT("invalid frame") );
873 // deal with the position first
877 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
879 // -1 means "use existing" unless the flag above is specified
885 else // wxSIZE_ALLOW_MINUS_ONE
891 if ( m_x
!= old_x
|| m_y
!= old_y
)
893 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
896 const wxSize
oldSize(m_width
, m_height
);
902 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
905 GTKDoGetSize(&w
, &h
);
906 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
908 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
909 wxSizeEvent
event(GetSize(), GetId());
910 event
.SetEventObject(this);
911 GetEventHandler()->ProcessEvent(event
);
915 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
917 wxASSERT_MSG(m_widget
, wxT("invalid frame"));
921 // for consistency with wxMSW, client area is supposed to be empty for
922 // the iconized windows
930 GTKDoGetSize(width
, height
);
934 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
938 wxTopLevelWindowBase::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
940 const wxSize minSize
= GetMinSize();
941 const wxSize maxSize
= GetMaxSize();
944 if (minSize
.x
> 0 || minSize
.y
> 0)
946 hints_mask
|= GDK_HINT_MIN_SIZE
;
947 hints
.min_width
= minSize
.x
- m_decorSize
.x
;
948 if (hints
.min_width
< 0)
950 hints
.min_height
= minSize
.y
- m_decorSize
.y
;
951 if (hints
.min_height
< 0)
952 hints
.min_height
= 0;
954 if (maxSize
.x
> 0 || maxSize
.y
> 0)
956 hints_mask
|= GDK_HINT_MAX_SIZE
;
957 hints
.max_width
= maxSize
.x
- m_decorSize
.x
;
958 if (hints
.max_width
< 0)
959 hints
.max_width
= INT_MAX
;
960 hints
.max_height
= maxSize
.y
- m_decorSize
.y
;
961 if (hints
.max_height
< 0)
962 hints
.max_height
= INT_MAX
;
964 if (incW
> 0 || incH
> 0)
966 hints_mask
|= GDK_HINT_RESIZE_INC
;
967 hints
.width_inc
= incW
> 0 ? incW
: 1;
968 hints
.height_inc
= incH
> 0 ? incH
: 1;
970 gtk_window_set_geometry_hints(
971 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
974 bool wxTopLevelWindowGTK::IsDecorCacheable() const
979 void wxTopLevelWindowGTK::OnInternalIdle()
981 // set the focus if not done yet and if we can already do it
982 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
984 if ( g_delayedFocus
&&
985 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
987 wxLogTrace(_T("focus"),
988 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
989 g_delayedFocus
->GetClassInfo()->GetClassName(),
990 g_delayedFocus
->GetLabel().c_str());
992 g_delayedFocus
->SetFocus();
993 g_delayedFocus
= NULL
;
997 wxWindow::OnInternalIdle();
999 // Synthetize activate events.
1000 if ( g_sendActivateEvent
!= -1 )
1002 bool activate
= g_sendActivateEvent
!= 0;
1004 // if (!activate) wxPrintf( wxT("de") );
1005 // wxPrintf( wxT("activate\n") );
1008 g_sendActivateEvent
= -1;
1010 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1014 // ----------------------------------------------------------------------------
1016 // ----------------------------------------------------------------------------
1018 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1020 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1022 if ( title
== m_title
)
1027 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1030 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1032 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1034 wxTopLevelWindowBase::SetIcons( icons
);
1038 const size_t numIcons
= icons
.GetIconCount();
1039 for ( size_t i
= 0; i
< numIcons
; i
++ )
1041 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1044 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1048 // ----------------------------------------------------------------------------
1049 // frame state: maximized/iconized/normal
1050 // ----------------------------------------------------------------------------
1052 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1055 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1057 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1060 bool wxTopLevelWindowGTK::IsMaximized() const
1062 if(!m_widget
->window
)
1065 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1068 void wxTopLevelWindowGTK::Restore()
1070 // "Present" seems similar enough to "restore"
1071 gtk_window_present( GTK_WINDOW( m_widget
) );
1074 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1077 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1079 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1082 bool wxTopLevelWindowGTK::IsIconized() const
1084 return m_isIconized
;
1087 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1089 if ( iconize
!= m_isIconized
)
1091 m_isIconized
= iconize
;
1092 (void)SendIconizeEvent(iconize
);
1096 void wxTopLevelWindowGTK::AddGrab()
1101 gtk_grab_add( m_widget
);
1102 wxGUIEventLoop().Run();
1103 gtk_grab_remove( m_widget
);
1107 void wxTopLevelWindowGTK::RemoveGrab()
1118 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1122 if (region
.IsEmpty())
1124 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1128 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1136 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1138 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1139 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1141 GdkWindow
*window
= NULL
;
1144 do_shape_combine_region(m_wxwindow
->window
, region
);
1146 window
= m_widget
->window
;
1147 return do_shape_combine_region(window
, region
);
1150 bool wxTopLevelWindowGTK::IsActive()
1152 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1155 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1157 bool new_hint_value
= false;
1159 // FIXME: This is a workaround to focus handling problem
1160 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1161 // yet been processed, and the internal focus system is not up to date yet.
1162 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1163 ::wxYieldIfNeeded();
1165 if(m_urgency_hint
>= 0)
1166 g_source_remove(m_urgency_hint
);
1168 m_urgency_hint
= -2;
1170 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1172 new_hint_value
= true;
1174 if (flags
& wxUSER_ATTENTION_INFO
)
1176 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1178 m_urgency_hint
= -1;
1182 #if GTK_CHECK_VERSION(2,7,0)
1183 if(!gtk_check_version(2,7,0))
1184 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1187 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1190 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1192 // Store which styles were changed
1193 long styleChanges
= style
^ m_windowStyle
;
1195 // Process wxWindow styles. This also updates the internal variable
1196 // Therefore m_windowStyle bits carry now the _new_ style values
1197 wxWindow::SetWindowStyleFlag(style
);
1199 // just return for now if widget does not exist yet
1203 if ( styleChanges
& wxSTAY_ON_TOP
)
1205 gtk_window_set_keep_above(GTK_WINDOW(m_widget
),
1206 m_windowStyle
& wxSTAY_ON_TOP
);
1209 if ( styleChanges
& wxFRAME_NO_TASKBAR
)
1211 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
),
1212 m_windowStyle
& wxFRAME_NO_TASKBAR
);
1216 /* Get the X Window between child and the root window.
1217 This should usually be the WM managed XID */
1218 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1220 Window root
, parent
;
1222 unsigned int nchildren
;
1224 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1227 while (parent
!= root
) {
1229 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1236 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1238 if (!m_widget
|| !m_widget
->window
)
1241 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1242 // We need to get the X Window that has the root window as the immediate parent
1243 // and m_widget->window as a child. This should be the X Window that the WM manages and
1244 // from which the opacity property is checked from.
1245 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1248 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1250 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1253 long opacity
= alpha
* 0x1010101L
;
1254 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1255 XA_CARDINAL
, 32, PropModeReplace
,
1256 (unsigned char *) &opacity
, 1L);
1262 bool wxTopLevelWindowGTK::CanSetTransparent()
1264 // allow to override automatic detection as it's far from perfect
1265 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1266 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1268 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1271 #if GTK_CHECK_VERSION(2,10,0)
1272 if (!gtk_check_version(2,10,0))
1274 return (gtk_widget_is_composited (m_widget
));
1277 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1282 #if 0 // Don't be optimistic here for the sake of wxAUI
1283 int opcode
, event
, error
;
1284 // Check for the existence of a RGBA visual instead?
1285 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1286 "Composite", &opcode
, &event
, &error
);
1290 void wxTopLevelWindowGTK::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1292 // We don't know the order in which top-level windows will
1293 // be notified, so we need to clear the system objects
1294 // for each top-level window.
1295 extern void wxClearGtkSystemObjects();
1296 wxClearGtkSystemObjects();
1298 // wxWindowBase::OnSysColourChanged will propagate event