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/private/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
54 #include <hildon/hildon.h>
55 #endif // wxUSE_LIBHILDON2
57 // ----------------------------------------------------------------------------
59 // ----------------------------------------------------------------------------
61 // this is incremented while a modal dialog is shown
62 int wxOpenModalDialogsCount
= 0;
64 // the frame that is currently active (i.e. its child has focus). It is
65 // used to generate wxActivateEvents
66 static wxTopLevelWindowGTK
*g_activeFrame
= NULL
;
67 static wxTopLevelWindowGTK
*g_lastActiveFrame
= NULL
;
69 // if we detect that the app has got/lost the focus, we set this variable to
70 // either TRUE or FALSE and an activate event will be sent during the next
71 // OnIdle() call and it is reset to -1: this value means that we shouldn't
72 // send any activate events at all
73 static int g_sendActivateEvent
= -1;
75 //-----------------------------------------------------------------------------
76 // RequestUserAttention related functions
77 //-----------------------------------------------------------------------------
80 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
83 wxASSERT_MSG( gtk_widget_get_realized(GTK_WIDGET(win
)),
84 wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
85 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
88 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
91 wm_hints
= XAllocWMHints();
94 wm_hints
->flags
|= XUrgencyHint
;
96 wm_hints
->flags
&= ~XUrgencyHint
;
98 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
102 static gboolean
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
104 #if GTK_CHECK_VERSION(2,7,0)
105 if(!gtk_check_version(2,7,0))
106 gtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
109 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
111 win
->m_urgency_hint
= -2;
116 //-----------------------------------------------------------------------------
118 //-----------------------------------------------------------------------------
121 static gboolean
gtk_frame_focus_in_callback( GtkWidget
*widget
,
122 GdkEvent
*WXUNUSED(event
),
123 wxTopLevelWindowGTK
*win
)
125 switch ( g_sendActivateEvent
)
128 // we've got focus from outside, synthetize wxActivateEvent
129 g_sendActivateEvent
= 1;
133 // another our window just lost focus, it was already ours before
134 // - don't send any wxActivateEvent
135 g_sendActivateEvent
= -1;
140 g_lastActiveFrame
= g_activeFrame
;
142 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
144 // MR: wxRequestUserAttention related block
145 switch( win
->m_urgency_hint
)
148 g_source_remove( win
->m_urgency_hint
);
149 // no break, fallthrough to remove hint too
151 #if GTK_CHECK_VERSION(2,7,0)
152 if(!gtk_check_version(2,7,0))
153 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
157 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
160 win
->m_urgency_hint
= -2;
166 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
167 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
168 event
.SetEventObject(g_activeFrame
);
169 g_activeFrame
->HandleWindowEvent(event
);
175 //-----------------------------------------------------------------------------
177 //-----------------------------------------------------------------------------
181 gboolean
gtk_frame_focus_out_callback(GtkWidget
* WXUNUSED(widget
),
182 GdkEventFocus
*WXUNUSED(gdk_event
),
183 wxTopLevelWindowGTK
* WXUNUSED(win
))
185 // if the focus goes out of our app alltogether, OnIdle() will send
186 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
187 // g_sendActivateEvent to -1
188 g_sendActivateEvent
= 0;
190 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
192 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
196 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
197 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
198 event
.SetEventObject(g_activeFrame
);
199 g_activeFrame
->HandleWindowEvent(event
);
201 g_activeFrame
= NULL
;
208 //-----------------------------------------------------------------------------
209 // "size_allocate" from m_wxwindow
210 //-----------------------------------------------------------------------------
214 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxTopLevelWindowGTK
* win
)
216 if (win
->m_oldClientWidth
!= alloc
->width
||
217 win
->m_oldClientHeight
!= alloc
->height
)
219 win
->m_oldClientWidth
= alloc
->width
;
220 win
->m_oldClientHeight
= alloc
->height
;
222 wxSize
size(win
->m_widget
->allocation
.width
,
223 win
->m_widget
->allocation
.height
);
224 size
+= win
->m_decorSize
;
225 win
->m_width
= size
.x
;
226 win
->m_height
= size
.y
;
228 if (!win
->IsIconized())
230 wxSizeEvent
event(size
, win
->GetId());
231 event
.SetEventObject(win
);
232 win
->HandleWindowEvent(event
);
234 // else the window is currently unmapped, don't generate size events
239 // ----------------------------------------------------------------------------
241 // ----------------------------------------------------------------------------
245 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
246 GtkRequisition
*requisition
,
247 wxTopLevelWindowGTK
*win
)
249 // we must return the size of the window without WM decorations, otherwise
250 // GTK+ gets confused, so don't call just GetSize() here
251 win
->GTKDoGetSize(&requisition
->width
, &requisition
->height
);
255 //-----------------------------------------------------------------------------
257 //-----------------------------------------------------------------------------
261 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
262 GdkEvent
*WXUNUSED(event
),
263 wxTopLevelWindowGTK
*win
)
265 if (win
->IsEnabled() &&
266 (wxOpenModalDialogsCount
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
274 //-----------------------------------------------------------------------------
276 //-----------------------------------------------------------------------------
280 gtk_frame_configure_callback( GtkWidget
* widget
,
281 GdkEventConfigure
*WXUNUSED(event
),
282 wxTopLevelWindowGTK
*win
)
284 if (!win
->m_hasVMT
|| !win
->IsShown())
288 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
292 wxMoveEvent
mevent(point
, win
->GetId());
293 mevent
.SetEventObject( win
);
294 win
->HandleWindowEvent( mevent
);
300 //-----------------------------------------------------------------------------
301 // "realize" from m_widget
302 //-----------------------------------------------------------------------------
304 // we cannot the WM hints and icons before the widget has been realized,
305 // so we do this directly after realization
309 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
310 wxTopLevelWindowGTK
*win
)
312 gdk_window_set_decorations(win
->m_widget
->window
,
313 (GdkWMDecoration
)win
->m_gdkDecor
);
314 gdk_window_set_functions(win
->m_widget
->window
,
315 (GdkWMFunction
)win
->m_gdkFunc
);
317 // GTK's shrinking/growing policy
318 if ( !(win
->m_gdkFunc
& GDK_FUNC_RESIZE
) )
319 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
321 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
323 const wxIconBundle
& icons
= win
->GetIcons();
324 if (icons
.GetIconCount())
325 win
->SetIcons(icons
);
327 if (win
->HasFlag(wxFRAME_SHAPED
))
328 win
->SetShape(win
->m_shape
); // it will really set the window shape now
332 //-----------------------------------------------------------------------------
333 // "map_event" from m_widget
334 //-----------------------------------------------------------------------------
338 gtk_frame_map_callback( GtkWidget
*,
339 GdkEvent
* WXUNUSED(event
),
340 wxTopLevelWindow
*win
)
342 const bool wasIconized
= win
->IsIconized();
345 // Because GetClientSize() returns (0,0) when IsIconized() is true,
346 // a size event must be generated, just in case GetClientSize() was
347 // called while iconized. This specifically happens when restoring a
348 // tlw that was "rolled up" with some WMs.
349 // Queue a resize rather than sending size event directly to allow
350 // children to be made visible first.
351 win
->m_oldClientWidth
= 0;
352 gtk_widget_queue_resize(win
->m_wxwindow
);
354 // it is possible for m_isShown to be false here, see bug #9909
355 if (win
->wxWindowBase::Show(true))
357 wxShowEvent
eventShow(win
->GetId(), true);
358 eventShow
.SetEventObject(win
);
359 win
->GetEventHandler()->ProcessEvent(eventShow
);
362 #if GTK_CHECK_VERSION(2,6,0)
363 if (!gtk_check_version(2,6,0))
365 // restore focus-on-map setting in case ShowWithoutActivating() was called
366 gtk_window_set_focus_on_map(GTK_WINDOW(win
->m_widget
), true);
374 //-----------------------------------------------------------------------------
375 // "window-state-event" from m_widget
376 //-----------------------------------------------------------------------------
380 gtk_frame_window_state_callback( GtkWidget
* WXUNUSED(widget
),
381 GdkEventWindowState
*event
,
382 wxTopLevelWindow
*win
)
384 if (event
->changed_mask
& GDK_WINDOW_STATE_ICONIFIED
)
385 win
->SetIconizeState((event
->new_window_state
& GDK_WINDOW_STATE_ICONIFIED
) != 0);
387 // if maximized bit changed and it is now set
388 if (event
->changed_mask
& event
->new_window_state
& GDK_WINDOW_STATE_MAXIMIZED
)
390 wxMaximizeEvent
event(win
->GetId());
391 event
.SetEventObject(win
);
392 win
->HandleWindowEvent(event
);
399 //-----------------------------------------------------------------------------
401 bool wxGetFrameExtents(GdkWindow
* window
, int* left
, int* right
, int* top
, int* bottom
)
403 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
404 Atom xproperty
= gdk_x11_atom_to_xatom_for_display(
405 gdk_drawable_get_display(window
), property
);
408 gulong nitems
, bytes_after
;
410 Status status
= XGetWindowProperty(
411 gdk_x11_drawable_get_xdisplay(window
),
412 gdk_x11_drawable_get_xid(window
),
414 0, 4, false, XA_CARDINAL
,
415 &type
, &format
, &nitems
, &bytes_after
, &data
);
416 const bool success
= status
== Success
&& data
&& nitems
== 4;
419 long* p
= (long*)data
;
420 if (left
) *left
= int(p
[0]);
421 if (right
) *right
= int(p
[1]);
422 if (top
) *top
= int(p
[2]);
423 if (bottom
) *bottom
= int(p
[3]);
430 //-----------------------------------------------------------------------------
431 // "property_notify_event" from m_widget
432 //-----------------------------------------------------------------------------
435 static gboolean
property_notify_event(
436 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
438 // Watch for changes to _NET_FRAME_EXTENTS property
439 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
440 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
)
442 wxSize decorSize
= win
->m_decorSize
;
443 int left
, right
, top
, bottom
;
444 if (wxGetFrameExtents(event
->window
, &left
, &right
, &top
, &bottom
))
445 decorSize
.Set(left
+ right
, top
+ bottom
);
447 win
->GTKUpdateDecorSize(decorSize
);
453 // ----------------------------------------------------------------------------
454 // wxTopLevelWindowGTK creation
455 // ----------------------------------------------------------------------------
457 void wxTopLevelWindowGTK::Init()
460 m_isIconized
= false;
461 m_fsIsShowing
= false;
462 m_themeEnabled
= true;
467 m_deferShowAllowed
= true;
468 m_updateDecorSize
= true;
473 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
475 const wxString
& title
,
477 const wxSize
& sizeOrig
,
479 const wxString
&name
)
481 // always create a frame of some reasonable, even if arbitrary, size (at
482 // least for MSW compatibility)
483 wxSize size
= sizeOrig
;
484 size
.x
= WidthDefault(size
.x
);
485 size
.y
= HeightDefault(size
.y
);
487 wxTopLevelWindows
.Append( this );
489 if (!PreCreation( parent
, pos
, size
) ||
490 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
492 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
498 // NB: m_widget may be !=NULL if it was created by derived class' Create,
499 // e.g. in wxTaskBarIconAreaGTK
500 if (m_widget
== NULL
)
502 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
503 // we must create HildonWindow and not a normal GtkWindow as the latter
504 // doesn't look correctly in Maemo environment and it must also be
505 // registered with the main program object
506 m_widget
= hildon_window_new();
507 hildon_program_add_window(wxTheApp
->GetHildonProgram(),
508 HILDON_WINDOW(m_widget
));
509 #else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
510 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
511 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
513 // Tell WM that this is a dialog window and make it center
514 // on parent by default (this is what GtkDialog ctor does):
515 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
516 GDK_WINDOW_TYPE_HINT_DIALOG
);
517 gtk_window_set_position(GTK_WINDOW(m_widget
),
518 GTK_WIN_POS_CENTER_ON_PARENT
);
522 if (style
& wxFRAME_TOOL_WINDOW
)
524 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
525 GDK_WINDOW_TYPE_HINT_UTILITY
);
527 // On some WMs, like KDE, a TOOL_WINDOW will still show
528 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
529 // For consistency between WMs and with Windows, we
530 // should set the NO_TASKBAR flag which will apply
531 // the set_skip_taskbar_hint if it is available,
532 // ensuring no taskbar entry will appear.
533 style
|= wxFRAME_NO_TASKBAR
;
536 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
538 g_object_ref(m_widget
);
541 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
542 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
543 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
544 (style
& wxFRAME_FLOAT_ON_PARENT
)))
546 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
547 GTK_WINDOW(topParent
->m_widget
) );
550 if (style
& wxFRAME_NO_TASKBAR
)
552 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
555 if (style
& wxSTAY_ON_TOP
)
557 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
559 if (style
& wxMAXIMIZE
)
560 gtk_window_maximize(GTK_WINDOW(m_widget
));
564 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
567 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
568 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
570 g_signal_connect (m_widget
, "delete_event",
571 G_CALLBACK (gtk_frame_delete_callback
), this);
573 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
574 m_mainWidget
= gtk_vbox_new(false, 0);
575 gtk_widget_show( m_mainWidget
);
576 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
577 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
579 // m_wxwindow is the client area
580 m_wxwindow
= wxPizza::New();
581 gtk_widget_show( m_wxwindow
);
582 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
584 // we donm't allow the frame to get the focus as otherwise
585 // the frame will grab it at arbitrary focus changes
586 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
588 if (m_parent
) m_parent
->AddChild( this );
590 g_signal_connect(m_wxwindow
, "size_allocate",
591 G_CALLBACK(size_allocate
), this);
593 g_signal_connect (m_widget
, "size_request",
594 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
597 if ((m_x
!= -1) || (m_y
!= -1))
598 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
600 // we cannot set MWM hints and icons before the widget has
601 // been realized, so we do this directly after realization
602 g_signal_connect (m_widget
, "realize",
603 G_CALLBACK (gtk_frame_realized_callback
), this);
605 // for some reported size corrections
606 g_signal_connect (m_widget
, "map_event",
607 G_CALLBACK (gtk_frame_map_callback
), this);
609 // for iconized state
610 g_signal_connect (m_widget
, "window_state_event",
611 G_CALLBACK (gtk_frame_window_state_callback
), this);
615 g_signal_connect (m_widget
, "configure_event",
616 G_CALLBACK (gtk_frame_configure_callback
), this);
619 g_signal_connect_after (m_widget
, "focus_in_event",
620 G_CALLBACK (gtk_frame_focus_in_callback
), this);
621 g_signal_connect_after (m_widget
, "focus_out_event",
622 G_CALLBACK (gtk_frame_focus_out_callback
), this);
624 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
625 g_signal_connect(m_widget
, "property_notify_event",
626 G_CALLBACK(property_notify_event
), this);
628 // translate wx decorations styles into Motif WM hints (they are recognized
629 // by other WMs as well)
631 // always enable moving the window as we have no separate flag for enabling
633 m_gdkFunc
= GDK_FUNC_MOVE
;
635 if ( style
& wxCLOSE_BOX
)
636 m_gdkFunc
|= GDK_FUNC_CLOSE
;
638 if ( style
& wxMINIMIZE_BOX
)
639 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
641 if ( style
& wxMAXIMIZE_BOX
)
642 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
644 if ( (style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
) )
650 m_gdkDecor
= GDK_DECOR_BORDER
;
652 if ( style
& wxCAPTION
)
653 m_gdkDecor
|= GDK_DECOR_TITLE
;
655 if ( style
& wxSYSTEM_MENU
)
656 m_gdkDecor
|= GDK_DECOR_MENU
;
658 if ( style
& wxMINIMIZE_BOX
)
659 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
661 if ( style
& wxMAXIMIZE_BOX
)
662 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
664 if ( style
& wxRESIZE_BORDER
)
666 m_gdkFunc
|= GDK_FUNC_RESIZE
;
667 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
671 m_decorSize
= GetCachedDecorSize();
673 GTKDoGetSize(&w
, &h
);
674 gtk_window_set_default_size(GTK_WINDOW(m_widget
), w
, h
);
679 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
681 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
682 // it can also be a (standard) dialog
683 if ( HILDON_IS_WINDOW(m_widget
) )
685 hildon_program_remove_window(wxTheApp
->GetHildonProgram(),
686 HILDON_WINDOW(m_widget
));
688 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2
692 wxFAIL_MSG(wxT("Window still grabbed"));
698 // it may also be GtkScrolledWindow in the case of an MDI child
699 if (GTK_IS_WINDOW(m_widget
))
701 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
704 if (g_activeFrame
== this)
705 g_activeFrame
= NULL
;
706 if (g_lastActiveFrame
== this)
707 g_lastActiveFrame
= NULL
;
710 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
713 m_gdkFunc
|= GDK_FUNC_CLOSE
;
715 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
717 if (gtk_widget_get_realized(m_widget
) && (m_widget
->window
))
718 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
723 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long)
725 if (show
== m_fsIsShowing
)
726 return false; // return what?
728 m_fsIsShowing
= show
;
730 wxX11FullScreenMethod method
=
731 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
732 (WXWindow
)GDK_ROOT_WINDOW());
734 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
735 // to switch to fullscreen, which is not always available. We must
736 // check if WM supports the spec and use legacy methods if it
738 if ( method
== wxX11_FS_WMSPEC
)
741 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
743 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
747 GdkWindow
*window
= m_widget
->window
;
751 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
752 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
754 int screen_width
,screen_height
;
755 wxDisplaySize( &screen_width
, &screen_height
);
757 gint client_x
, client_y
, root_x
, root_y
;
760 m_fsSaveGdkFunc
= m_gdkFunc
;
761 m_fsSaveGdkDecor
= m_gdkDecor
;
762 m_gdkFunc
= m_gdkDecor
= 0;
763 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
764 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 m_gdkFunc
= m_fsSaveGdkFunc
;
781 m_gdkDecor
= m_fsSaveGdkDecor
;
782 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
783 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
785 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
786 (WXWindow
)GDK_ROOT_WINDOW(),
787 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
788 show
, &m_fsSaveFrame
, method
);
790 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
791 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
795 // documented behaviour is to show the window if it's still hidden when
796 // showing it full screen
803 // ----------------------------------------------------------------------------
804 // overridden wxWindow methods
805 // ----------------------------------------------------------------------------
807 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground
), const wxRect
*WXUNUSED(rect
) )
809 wxCHECK_RET( m_widget
, wxT("invalid frame") );
811 gtk_widget_queue_draw( m_widget
);
813 if (m_wxwindow
&& m_wxwindow
->window
)
814 gdk_window_invalidate_rect( m_wxwindow
->window
, NULL
, TRUE
);
817 bool wxTopLevelWindowGTK::Show( bool show
)
819 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
821 bool deferShow
= show
&& !m_isShown
&& m_deferShow
;
824 deferShow
= m_deferShowAllowed
&& !gtk_widget_get_realized(m_widget
);
827 deferShow
= g_signal_handler_find(m_widget
,
828 GSignalMatchType(G_SIGNAL_MATCH_ID
| G_SIGNAL_MATCH_DATA
),
829 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET
),
830 0, NULL
, NULL
, this) != 0;
832 GdkScreen
* screen
= NULL
;
835 screen
= gtk_widget_get_screen(m_widget
);
836 GdkAtom atom
= gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
837 deferShow
= gdk_x11_screen_supports_net_wm_hint(screen
, atom
) != 0;
838 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
839 // to m_decorSize, it breaks saving/restoring window size with
840 // GetSize()/SetSize() because it makes window bigger between each
842 m_updateDecorSize
= deferShow
;
846 // Fluxbox support for _NET_REQUEST_FRAME_EXTENTS is broken
847 const char* name
= gdk_x11_screen_get_window_manager_name(screen
);
848 deferShow
= strcmp(name
, "Fluxbox") != 0;
849 m_updateDecorSize
= deferShow
;
852 m_deferShow
= deferShow
;
856 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
857 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
858 // notification is received, so correct frame extents are known.
859 // This allows resizing m_widget to keep the overall size in sync with
860 // what wxWidgets expects it to be without an obvious change in the
861 // window size immediately after it becomes visible.
863 // Realize m_widget, so m_widget->window can be used. Realizing normally
864 // causes the widget tree to be size_allocated, which generates size
865 // events in the wrong order. However, the size_allocates will not be
866 // done if the allocation is not the default (1,1).
867 const int alloc_width
= m_widget
->allocation
.width
;
868 if (alloc_width
== 1)
869 m_widget
->allocation
.width
= 2;
870 gtk_widget_realize(m_widget
);
871 if (alloc_width
== 1)
872 m_widget
->allocation
.width
= 1;
874 // send _NET_REQUEST_FRAME_EXTENTS
875 XClientMessageEvent xevent
;
876 memset(&xevent
, 0, sizeof(xevent
));
877 xevent
.type
= ClientMessage
;
878 xevent
.window
= gdk_x11_drawable_get_xid(m_widget
->window
);
879 xevent
.message_type
= gdk_x11_atom_to_xatom_for_display(
880 gdk_drawable_get_display(m_widget
->window
),
881 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
883 Display
* display
= gdk_x11_drawable_get_xdisplay(m_widget
->window
);
884 XSendEvent(display
, DefaultRootWindow(display
), false,
885 SubstructureNotifyMask
| SubstructureRedirectMask
,
888 // defer calling gtk_widget_show()
893 if (show
&& !gtk_widget_get_realized(m_widget
))
895 // size_allocate signals occur in reverse order (bottom to top).
896 // Things work better if the initial wxSizeEvents are sent (from the
897 // top down), before the initial size_allocate signals occur.
898 wxSizeEvent
event(GetSize(), GetId());
899 event
.SetEventObject(this);
900 HandleWindowEvent(event
);
903 bool change
= base_type::Show(show
);
907 // make sure window has a non-default position, so when it is shown
908 // again, it won't be repositioned by WM as if it were a new window
909 // Note that this must be done _after_ the window is hidden.
910 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
916 void wxTopLevelWindowGTK::ShowWithoutActivating()
920 #if GTK_CHECK_VERSION(2,6,0)
921 if (!gtk_check_version(2,6,0))
922 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget
), false);
929 void wxTopLevelWindowGTK::Raise()
931 gtk_window_present( GTK_WINDOW( m_widget
) );
934 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
936 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
939 // ----------------------------------------------------------------------------
941 // ----------------------------------------------------------------------------
943 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
945 wxSize
size(m_width
, m_height
);
947 if (size
.x
< 0) size
.x
= 0;
948 if (size
.y
< 0) size
.y
= 0;
959 else if (size
.y
== 270)
964 #else // wxUSE_LIBHILDON2
965 if (width
) *width
= size
.x
;
966 if (height
) *height
= size
.y
;
967 #endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
970 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
972 wxCHECK_RET( m_widget
, wxT("invalid frame") );
974 m_deferShowAllowed
= true;
976 // deal with the position first
980 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
982 // -1 means "use existing" unless the flag above is specified
988 else // wxSIZE_ALLOW_MINUS_ONE
994 if ( m_x
!= old_x
|| m_y
!= old_y
)
996 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
999 const wxSize
oldSize(m_width
, m_height
);
1005 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
1008 GTKDoGetSize(&w
, &h
);
1009 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
1011 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
1012 wxSizeEvent
event(GetSize(), GetId());
1013 event
.SetEventObject(this);
1014 HandleWindowEvent(event
);
1018 void wxTopLevelWindowGTK::DoSetClientSize(int width
, int height
)
1020 base_type::DoSetClientSize(width
, height
);
1022 // Since client size is being explicitly set, don't change it later
1023 // Has to be done after calling base because it calls SetSize,
1024 // which sets this true
1025 m_deferShowAllowed
= false;
1028 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
1030 wxASSERT_MSG(m_widget
, wxT("invalid frame"));
1034 // for consistency with wxMSW, client area is supposed to be empty for
1035 // the iconized windows
1043 GTKDoGetSize(width
, height
);
1047 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
1049 int incW
, int incH
)
1051 base_type::DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
);
1053 const wxSize minSize
= GetMinSize();
1054 const wxSize maxSize
= GetMaxSize();
1057 if (minSize
.x
> 0 || minSize
.y
> 0)
1059 hints_mask
|= GDK_HINT_MIN_SIZE
;
1060 hints
.min_width
= minSize
.x
- m_decorSize
.x
;
1061 if (hints
.min_width
< 0)
1062 hints
.min_width
= 0;
1063 hints
.min_height
= minSize
.y
- m_decorSize
.y
;
1064 if (hints
.min_height
< 0)
1065 hints
.min_height
= 0;
1067 if (maxSize
.x
> 0 || maxSize
.y
> 0)
1069 hints_mask
|= GDK_HINT_MAX_SIZE
;
1070 hints
.max_width
= maxSize
.x
- m_decorSize
.x
;
1071 if (hints
.max_width
< 0)
1072 hints
.max_width
= INT_MAX
;
1073 hints
.max_height
= maxSize
.y
- m_decorSize
.y
;
1074 if (hints
.max_height
< 0)
1075 hints
.max_height
= INT_MAX
;
1077 if (incW
> 0 || incH
> 0)
1079 hints_mask
|= GDK_HINT_RESIZE_INC
;
1080 hints
.width_inc
= incW
> 0 ? incW
: 1;
1081 hints
.height_inc
= incH
> 0 ? incH
: 1;
1083 gtk_window_set_geometry_hints(
1084 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
1087 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize
& decorSize
)
1089 if (!IsMaximized() && !IsFullScreen())
1090 GetCachedDecorSize() = decorSize
;
1091 if (m_updateDecorSize
&& m_decorSize
!= decorSize
)
1093 const wxSize diff
= decorSize
- m_decorSize
;
1094 m_decorSize
= decorSize
;
1095 bool resized
= false;
1098 // keep overall size unchanged by shrinking m_widget
1100 GTKDoGetSize(&w
, &h
);
1101 // but not if size would be less than minimum, it won't take effect
1102 const wxSize minSize
= GetMinSize();
1103 if (w
>= minSize
.x
&& h
>= minSize
.y
)
1105 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
1111 // adjust overall size to match change in frame extents
1114 if (m_width
< 0) m_width
= 0;
1115 if (m_height
< 0) m_height
= 0;
1116 m_oldClientWidth
= 0;
1117 gtk_widget_queue_resize(m_wxwindow
);
1122 // gtk_widget_show() was deferred, do it now
1123 m_deferShow
= false;
1124 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
1125 wxSizeEvent
sizeEvent(GetSize(), GetId());
1126 sizeEvent
.SetEventObject(this);
1127 HandleWindowEvent(sizeEvent
);
1129 gtk_widget_show(m_widget
);
1131 wxShowEvent
showEvent(GetId(), true);
1132 showEvent
.SetEventObject(this);
1133 HandleWindowEvent(showEvent
);
1137 wxSize
& wxTopLevelWindowGTK::GetCachedDecorSize()
1139 static wxSize size
[8];
1143 if (m_gdkDecor
& (GDK_DECOR_MENU
| GDK_DECOR_MINIMIZE
| GDK_DECOR_MAXIMIZE
| GDK_DECOR_TITLE
))
1146 if (m_gdkDecor
& GDK_DECOR_BORDER
)
1148 // utility window decor can be different
1149 if (m_windowStyle
& wxFRAME_TOOL_WINDOW
)
1154 void wxTopLevelWindowGTK::OnInternalIdle()
1156 wxTopLevelWindowBase::OnInternalIdle();
1158 // Synthetize activate events.
1159 if ( g_sendActivateEvent
!= -1 )
1161 bool activate
= g_sendActivateEvent
!= 0;
1163 // if (!activate) wxPrintf( wxT("de") );
1164 // wxPrintf( wxT("activate\n") );
1167 g_sendActivateEvent
= -1;
1169 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1173 // ----------------------------------------------------------------------------
1175 // ----------------------------------------------------------------------------
1177 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1179 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1181 if ( title
== m_title
)
1186 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1189 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1191 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1193 base_type::SetIcons(icons
);
1195 // Setting icons before window is realized can cause a GTK assertion if
1196 // another TLW is realized before this one, and it has this one as it's
1197 // transient parent. The life demo exibits this problem.
1198 if (gtk_widget_get_realized(m_widget
))
1201 for (size_t i
= icons
.GetIconCount(); i
--;)
1202 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1203 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1208 // ----------------------------------------------------------------------------
1209 // frame state: maximized/iconized/normal
1210 // ----------------------------------------------------------------------------
1212 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1215 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1217 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1220 bool wxTopLevelWindowGTK::IsMaximized() const
1222 return m_widget
->window
&&
1223 (gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
);
1226 void wxTopLevelWindowGTK::Restore()
1228 // "Present" seems similar enough to "restore"
1229 gtk_window_present( GTK_WINDOW( m_widget
) );
1232 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1235 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1237 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1240 bool wxTopLevelWindowGTK::IsIconized() const
1242 return m_isIconized
;
1245 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1247 if ( iconize
!= m_isIconized
)
1249 m_isIconized
= iconize
;
1250 (void)SendIconizeEvent(iconize
);
1254 void wxTopLevelWindowGTK::AddGrab()
1259 gtk_grab_add( m_widget
);
1260 wxGUIEventLoop().Run();
1261 gtk_grab_remove( m_widget
);
1265 void wxTopLevelWindowGTK::RemoveGrab()
1276 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1280 if (region
.IsEmpty())
1282 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1286 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1294 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1296 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1297 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));
1299 if ( gtk_widget_get_realized(m_widget
) )
1302 do_shape_combine_region(m_wxwindow
->window
, region
);
1304 return do_shape_combine_region(m_widget
->window
, region
);
1306 else // not realized yet
1308 // store the shape to set, it will be really set once we're realized
1311 // we don't know if we're going to succeed or fail, be optimistic by
1317 bool wxTopLevelWindowGTK::IsActive()
1319 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1322 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1324 bool new_hint_value
= false;
1326 // FIXME: This is a workaround to focus handling problem
1327 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1328 // hasn't yet been processed, and the internal focus system is not up to date yet.
1329 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1330 // won't have side effects) - MR
1331 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI
);
1333 if(m_urgency_hint
>= 0)
1334 g_source_remove(m_urgency_hint
);
1336 m_urgency_hint
= -2;
1338 if( gtk_widget_get_realized(m_widget
) && !IsActive() )
1340 new_hint_value
= true;
1342 if (flags
& wxUSER_ATTENTION_INFO
)
1344 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1346 m_urgency_hint
= -1;
1350 #if GTK_CHECK_VERSION(2,7,0)
1351 if(!gtk_check_version(2,7,0))
1352 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1355 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1358 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1360 // Store which styles were changed
1361 long styleChanges
= style
^ m_windowStyle
;
1363 // Process wxWindow styles. This also updates the internal variable
1364 // Therefore m_windowStyle bits carry now the _new_ style values
1365 wxWindow::SetWindowStyleFlag(style
);
1367 // just return for now if widget does not exist yet
1371 if ( styleChanges
& wxSTAY_ON_TOP
)
1373 gtk_window_set_keep_above(GTK_WINDOW(m_widget
),
1374 m_windowStyle
& wxSTAY_ON_TOP
);
1377 if ( styleChanges
& wxFRAME_NO_TASKBAR
)
1379 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
),
1380 m_windowStyle
& wxFRAME_NO_TASKBAR
);
1384 /* Get the X Window between child and the root window.
1385 This should usually be the WM managed XID */
1386 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1388 Window root
, parent
;
1390 unsigned int nchildren
;
1392 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1395 while (parent
!= root
) {
1397 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1404 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1406 if (!m_widget
|| !m_widget
->window
)
1409 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1410 // We need to get the X Window that has the root window as the immediate parent
1411 // and m_widget->window as a child. This should be the X Window that the WM manages and
1412 // from which the opacity property is checked from.
1413 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1416 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1418 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1421 long opacity
= alpha
* 0x1010101L
;
1422 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1423 XA_CARDINAL
, 32, PropModeReplace
,
1424 (unsigned char *) &opacity
, 1L);
1430 bool wxTopLevelWindowGTK::CanSetTransparent()
1432 // allow to override automatic detection as it's far from perfect
1433 const wxString SYSOPT_TRANSPARENT
= "gtk.tlw.can-set-transparent";
1434 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1436 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1439 #if GTK_CHECK_VERSION(2,10,0)
1440 if (!gtk_check_version(2,10,0))
1442 return (gtk_widget_is_composited (m_widget
));
1445 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1450 #if 0 // Don't be optimistic here for the sake of wxAUI
1451 int opcode
, event
, error
;
1452 // Check for the existence of a RGBA visual instead?
1453 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1454 "Composite", &opcode
, &event
, &error
);