1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/toplevel.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
22 #define XIconifyWindow XICONIFYWINDOW
25 #include "wx/toplevel.h"
34 #include "wx/gtk/private.h"
35 #include "wx/evtloop.h"
36 #include "wx/sysopt.h"
41 #include "wx/gtk/win_gtk.h"
43 #include "wx/unix/utilsx11.h"
46 #include <X11/Xatom.h>
48 // ----------------------------------------------------------------------------
50 // ----------------------------------------------------------------------------
52 extern int g_openDialogs
;
53 extern wxWindowGTK
*g_delayedFocus
;
55 // the frame that is currently active (i.e. its child has focus). It is
56 // used to generate wxActivateEvents
57 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
58 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
60 // if we detect that the app has got/lost the focus, we set this variable to
61 // either TRUE or FALSE and an activate event will be sent during the next
62 // OnIdle() call and it is reset to -1: this value means that we shouldn't
63 // send any activate events at all
64 static int g_sendActivateEvent
= -1;
66 //-----------------------------------------------------------------------------
67 // RequestUserAttention related functions
68 //-----------------------------------------------------------------------------
71 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
74 wxASSERT_MSG( GTK_WIDGET_REALIZED(win
), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
75 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
78 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
81 wm_hints
= XAllocWMHints();
84 wm_hints
->flags
|= XUrgencyHint
;
86 wm_hints
->flags
&= ~XUrgencyHint
;
88 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
92 static gboolean
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
94 #if GTK_CHECK_VERSION(2,7,0)
95 if(!gtk_check_version(2,7,0))
96 gtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
99 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
101 win
->m_urgency_hint
= -2;
106 //-----------------------------------------------------------------------------
108 //-----------------------------------------------------------------------------
111 static gboolean
gtk_frame_focus_in_callback( GtkWidget
*widget
,
112 GdkEvent
*WXUNUSED(event
),
113 wxTopLevelWindowGTK
*win
)
115 switch ( g_sendActivateEvent
)
118 // we've got focus from outside, synthetize wxActivateEvent
119 g_sendActivateEvent
= 1;
123 // another our window just lost focus, it was already ours before
124 // - don't send any wxActivateEvent
125 g_sendActivateEvent
= -1;
130 g_lastActiveFrame
= g_activeFrame
;
132 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
134 // MR: wxRequestUserAttention related block
135 switch( win
->m_urgency_hint
)
138 g_source_remove( win
->m_urgency_hint
);
139 // no break, fallthrough to remove hint too
141 #if GTK_CHECK_VERSION(2,7,0)
142 if(!gtk_check_version(2,7,0))
143 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
147 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
150 win
->m_urgency_hint
= -2;
156 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
157 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
158 event
.SetEventObject(g_activeFrame
);
159 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
165 //-----------------------------------------------------------------------------
167 //-----------------------------------------------------------------------------
171 gboolean
gtk_frame_focus_out_callback(GtkWidget
* WXUNUSED(widget
),
172 GdkEventFocus
*WXUNUSED(gdk_event
),
173 wxTopLevelWindowGTK
* WXUNUSED(win
))
175 // if the focus goes out of our app alltogether, OnIdle() will send
176 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
177 // g_sendActivateEvent to -1
178 g_sendActivateEvent
= 0;
180 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
182 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
186 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
187 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
188 event
.SetEventObject(g_activeFrame
);
189 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
191 g_activeFrame
= NULL
;
198 //-----------------------------------------------------------------------------
200 // Get cached size of WM decorations for given GdkWMDecoration.
201 static wxSize
& GetDecorSize(int decor
)
203 // In testing, only the title bar and GDK_DECOR_BORDER made a difference.
204 // 4 possible combinations of title bar and border
205 static wxSize size
[4];
209 if (decor
& (GDK_DECOR_MENU
| GDK_DECOR_MINIMIZE
| GDK_DECOR_MAXIMIZE
| GDK_DECOR_TITLE
))
212 if (decor
& GDK_DECOR_BORDER
)
217 //-----------------------------------------------------------------------------
218 // "size_allocate" from m_wxwindow
219 //-----------------------------------------------------------------------------
223 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxTopLevelWindowGTK
* win
)
225 if (win
->m_oldClientWidth
!= alloc
->width
||
226 win
->m_oldClientHeight
!= alloc
->height
)
228 win
->m_oldClientWidth
= alloc
->width
;
229 win
->m_oldClientHeight
= alloc
->height
;
231 if (!win
->IsFullScreen())
232 sizeDecor
= GetDecorSize(win
->m_gdkDecor
);
233 win
->m_width
= win
->m_widget
->allocation
.width
+ sizeDecor
.x
;
234 win
->m_height
= win
->m_widget
->allocation
.height
+ sizeDecor
.y
;
235 if (!win
->IsIconized())
237 wxSizeEvent
event(win
->GetSize(), win
->GetId());
238 event
.SetEventObject(win
);
239 win
->GetEventHandler()->ProcessEvent(event
);
241 // else the window is currently unmapped, don't generate size events
246 // ----------------------------------------------------------------------------
248 // ----------------------------------------------------------------------------
252 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
253 GtkRequisition
*requisition
,
254 wxTopLevelWindowGTK
*win
)
256 // we must return the size of the window without WM decorations, otherwise
257 // GTK+ gets confused, so don't call just GetSize() here
258 win
->GTKDoGetSize(&requisition
->width
, &requisition
->height
);
262 //-----------------------------------------------------------------------------
264 //-----------------------------------------------------------------------------
268 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
269 GdkEvent
*WXUNUSED(event
),
270 wxTopLevelWindowGTK
*win
)
272 if (win
->IsEnabled() &&
273 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
282 //-----------------------------------------------------------------------------
284 //-----------------------------------------------------------------------------
288 gtk_frame_configure_callback( GtkWidget
* widget
,
289 GdkEventConfigure
*WXUNUSED(event
),
290 wxTopLevelWindowGTK
*win
)
292 if (!win
->m_hasVMT
|| !win
->IsShown())
296 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
300 wxMoveEvent
mevent(point
, win
->GetId());
301 mevent
.SetEventObject( win
);
302 win
->GetEventHandler()->ProcessEvent( mevent
);
308 //-----------------------------------------------------------------------------
309 // "realize" from m_widget
310 //-----------------------------------------------------------------------------
312 // we cannot MWM hints and icons before the widget has been realized,
313 // so we do this directly after realization
317 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
318 wxTopLevelWindowGTK
*win
)
320 // All this is for Motif Window Manager "hints" and is supposed to be
321 // recognized by other WM as well. Not tested.
322 gdk_window_set_decorations(win
->m_widget
->window
,
323 (GdkWMDecoration
)win
->m_gdkDecor
);
324 gdk_window_set_functions(win
->m_widget
->window
,
325 (GdkWMFunction
)win
->m_gdkFunc
);
327 // GTK's shrinking/growing policy
328 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
329 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
331 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
334 wxIconBundle iconsOld
= win
->GetIcons();
335 if ( !iconsOld
.IsEmpty() )
337 win
->SetIcon( wxNullIcon
);
338 win
->SetIcons( iconsOld
);
343 //-----------------------------------------------------------------------------
344 // "map_event" from m_widget
345 //-----------------------------------------------------------------------------
349 gtk_frame_map_callback( GtkWidget
* widget
,
350 GdkEvent
* WXUNUSED(event
),
351 wxTopLevelWindow
*win
)
353 // Calculate size of WM decorations.
354 // Done here in case WM does not support the _NET_FRAME_EXTENTS property.
355 if (win
->IsDecorCacheable() && !win
->IsFullScreen())
358 gdk_window_get_frame_extents(widget
->window
, &rect
);
360 gdk_drawable_get_size(widget
->window
, &w
, &h
);
361 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
362 const wxSize size
= wxSize(rect
.width
- w
, rect
.height
- h
);
363 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
365 // Update window size and frame extents cache
366 win
->m_width
= rect
.width
;
367 win
->m_height
= rect
.height
;
372 win
->SetIconizeState(false);
374 // Because GetClientSize() returns (0,0) when IsIconized() is true,
375 // a size event must be sent here, just in case GetClientSize() was
376 // called while iconized.
377 // This specifically happens when restoring a tlw that was "rolled up"
379 wxSizeEvent
event(win
->GetSize(), win
->GetId());
380 event
.SetEventObject(win
);
381 win
->GetEventHandler()->ProcessEvent(event
);
387 //-----------------------------------------------------------------------------
388 // "unmap_event" from m_widget
389 //-----------------------------------------------------------------------------
393 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
394 GdkEvent
* WXUNUSED(event
),
395 wxTopLevelWindow
*win
)
397 win
->SetIconizeState(true);
402 //-----------------------------------------------------------------------------
403 // "property_notify_event" from m_widget
404 //-----------------------------------------------------------------------------
407 static gboolean
property_notify_event(
408 GtkWidget
*, GdkEventProperty
* event
, wxTopLevelWindowGTK
* win
)
410 // Watch for changes to _NET_FRAME_EXTENTS property
411 static GdkAtom property
= gdk_atom_intern("_NET_FRAME_EXTENTS", false);
412 if (event
->state
== GDK_PROPERTY_NEW_VALUE
&& event
->atom
== property
&&
413 win
->IsDecorCacheable() && !win
->IsFullScreen())
415 Atom xproperty
= gdk_x11_atom_to_xatom_for_display(
416 gdk_drawable_get_display(event
->window
), property
);
419 gulong nitems
, bytes_after
;
421 Status status
= XGetWindowProperty(
422 gdk_x11_drawable_get_xdisplay(event
->window
),
423 gdk_x11_drawable_get_xid(event
->window
),
425 0, 4, false, XA_CARDINAL
,
426 &type
, &format
, &nitems
, &bytes_after
, (guchar
**)&data
);
427 if (status
== Success
&& data
&& nitems
== 4)
429 wxSize
& decorSize
= GetDecorSize(win
->m_gdkDecor
);
431 wxSize(int(data
[0] + data
[1]), int(data
[2] + data
[3]));
432 if (decorSize
.x
!= size
.x
|| decorSize
.y
!= size
.y
)
434 // Update window size and frame extents cache
435 win
->m_width
+= size
.x
- decorSize
.x
;
436 win
->m_height
+= size
.y
- decorSize
.y
;
437 if (win
->m_width
< 0) win
->m_width
= 0;
438 if (win
->m_height
< 0) win
->m_height
= 0;
440 wxSizeEvent
event(win
->GetSize(), win
->GetId());
441 event
.SetEventObject(win
);
442 win
->GetEventHandler()->ProcessEvent(event
);
452 BEGIN_EVENT_TABLE(wxTopLevelWindowGTK
, wxTopLevelWindowBase
)
453 EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK
::OnSysColourChanged
)
457 // ----------------------------------------------------------------------------
458 // wxTopLevelWindowGTK creation
459 // ----------------------------------------------------------------------------
461 void wxTopLevelWindowGTK
::Init()
463 m_mainWidget
= (GtkWidget
*) NULL
;
464 m_isIconized
= false;
465 m_fsIsShowing
= false;
466 m_themeEnabled
= true;
467 m_gdkDecor
= m_gdkFunc
= 0;
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 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
503 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
505 // Tell WM that this is a dialog window and make it center
506 // on parent by default (this is what GtkDialog ctor does):
507 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
508 GDK_WINDOW_TYPE_HINT_DIALOG
);
509 gtk_window_set_position(GTK_WINDOW(m_widget
),
510 GTK_WIN_POS_CENTER_ON_PARENT
);
514 if (style
& wxFRAME_TOOL_WINDOW
)
516 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
517 GDK_WINDOW_TYPE_HINT_UTILITY
);
519 // On some WMs, like KDE, a TOOL_WINDOW will still show
520 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
521 // For consistency between WMs and with Windows, we
522 // should set the NO_TASKBAR flag which will apply
523 // the set_skip_taskbar_hint if it is available,
524 // ensuring no taskbar entry will appear.
525 style
|= wxFRAME_NO_TASKBAR
;
530 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
531 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
532 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
533 (style
& wxFRAME_FLOAT_ON_PARENT
)))
535 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
536 GTK_WINDOW(topParent
->m_widget
) );
539 if (style
& wxFRAME_NO_TASKBAR
)
541 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
544 if (style
& wxSTAY_ON_TOP
)
546 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
551 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
554 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
555 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
557 g_signal_connect (m_widget
, "delete_event",
558 G_CALLBACK (gtk_frame_delete_callback
), this);
560 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
561 m_mainWidget
= gtk_vbox_new(false, 0);
562 gtk_widget_show( m_mainWidget
);
563 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
564 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
566 // m_wxwindow is the client area
567 m_wxwindow
= wxPizza
::New();
568 gtk_widget_show( m_wxwindow
);
569 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
571 // we donm't allow the frame to get the focus as otherwise
572 // the frame will grab it at arbitrary focus changes
573 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
575 if (m_parent
) m_parent
->AddChild( this );
577 g_signal_connect(m_wxwindow
, "size_allocate",
578 G_CALLBACK(size_allocate
), this);
580 g_signal_connect (m_widget
, "size_request",
581 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
584 if ((m_x
!= -1) || (m_y
!= -1))
585 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
587 // we cannot set MWM hints and icons before the widget has
588 // been realized, so we do this directly after realization
589 g_signal_connect (m_widget
, "realize",
590 G_CALLBACK (gtk_frame_realized_callback
), this);
592 // map and unmap for iconized state
593 g_signal_connect (m_widget
, "map_event",
594 G_CALLBACK (gtk_frame_map_callback
), this);
595 g_signal_connect (m_widget
, "unmap_event",
596 G_CALLBACK (gtk_frame_unmap_callback
), this);
599 g_signal_connect (m_widget
, "configure_event",
600 G_CALLBACK (gtk_frame_configure_callback
), this);
603 g_signal_connect_after (m_widget
, "focus_in_event",
604 G_CALLBACK (gtk_frame_focus_in_callback
), this);
605 g_signal_connect_after (m_widget
, "focus_out_event",
606 G_CALLBACK (gtk_frame_focus_out_callback
), this);
608 gtk_widget_add_events(m_widget
, GDK_PROPERTY_CHANGE_MASK
);
609 g_signal_connect(m_widget
, "property_notify_event",
610 G_CALLBACK(property_notify_event
), this);
613 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
620 m_gdkDecor
= GDK_DECOR_BORDER
;
621 m_gdkFunc
= GDK_FUNC_MOVE
;
623 // All this is for Motif Window Manager "hints" and is supposed to be
624 // recognized by other WMs as well.
625 if ((style
& wxCAPTION
) != 0)
627 m_gdkDecor
|= GDK_DECOR_TITLE
;
629 if ((style
& wxCLOSE_BOX
) != 0)
631 m_gdkFunc
|= GDK_FUNC_CLOSE
;
633 if ((style
& wxSYSTEM_MENU
) != 0)
635 m_gdkDecor
|= GDK_DECOR_MENU
;
637 if ((style
& wxMINIMIZE_BOX
) != 0)
639 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
640 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
642 if ((style
& wxMAXIMIZE_BOX
) != 0)
644 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
645 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
647 if ((style
& wxRESIZE_BORDER
) != 0)
649 m_gdkFunc
|= GDK_FUNC_RESIZE
;
650 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
654 // m_gdkDecor needs to be set before calling GTKDoGetSize
656 GTKDoGetSize(&w
, &h
);
657 gtk_window_set_default_size(GTK_WINDOW(m_widget
), w
, h
);
662 wxTopLevelWindowGTK
::~wxTopLevelWindowGTK()
666 wxFAIL_MSG(_T("Window still grabbed"));
670 m_isBeingDeleted
= true;
672 // it may also be GtkScrolledWindow in the case of an MDI child
673 if (GTK_IS_WINDOW(m_widget
))
675 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
678 if (g_activeFrame
== this)
679 g_activeFrame
= NULL
;
680 if (g_lastActiveFrame
== this)
681 g_lastActiveFrame
= NULL
;
684 bool wxTopLevelWindowGTK
::EnableCloseButton( bool enable
)
687 m_gdkFunc
|= GDK_FUNC_CLOSE
;
689 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
691 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
692 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
697 bool wxTopLevelWindowGTK
::ShowFullScreen(bool show
, long)
699 if (show
== m_fsIsShowing
)
700 return false; // return what?
702 m_fsIsShowing
= show
;
704 wxX11FullScreenMethod method
=
705 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
706 (WXWindow
)GDK_ROOT_WINDOW());
708 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
709 // to switch to fullscreen, which is not always available. We must
710 // check if WM supports the spec and use legacy methods if it
712 if ( method
== wxX11_FS_WMSPEC
)
715 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
717 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
721 GdkWindow
*window
= m_widget
->window
;
725 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
726 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
728 int screen_width
,screen_height
;
729 wxDisplaySize( &screen_width
, &screen_height
);
731 gint client_x
, client_y
, root_x
, root_y
;
734 m_fsSaveGdkFunc
= m_gdkFunc
;
735 m_fsSaveGdkDecor
= m_gdkDecor
;
736 m_gdkFunc
= m_gdkDecor
= 0;
737 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
738 gdk_window_set_functions(window
, (GdkWMFunction
)0);
740 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
741 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
742 &width
, &height
, NULL
);
744 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
745 screen_width
+ 1, screen_height
+ 1);
747 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
748 (WXWindow
)GDK_ROOT_WINDOW(),
749 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
750 show
, &m_fsSaveFrame
, method
);
754 m_gdkFunc
= m_fsSaveGdkFunc
;
755 m_gdkDecor
= m_fsSaveGdkDecor
;
756 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
757 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
759 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
760 (WXWindow
)GDK_ROOT_WINDOW(),
761 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
762 show
, &m_fsSaveFrame
, method
);
764 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
765 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
769 // documented behaviour is to show the window if it's still hidden when
770 // showing it full screen
777 // ----------------------------------------------------------------------------
778 // overridden wxWindow methods
779 // ----------------------------------------------------------------------------
781 bool wxTopLevelWindowGTK
::Show( bool show
)
783 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
785 if (show
&& !IsShown())
787 // size_allocate signals occur in reverse order (bottom to top).
788 // Things work better if the initial wxSizeEvents are sent (from the
789 // top down), before the initial size_allocate signals occur.
790 wxSizeEvent
event(GetSize(), GetId());
791 event
.SetEventObject(this);
792 GetEventHandler()->ProcessEvent(event
);
795 bool change
= wxTopLevelWindowBase
::Show(show
);
799 // make sure window has a non-default position, so when it is shown
800 // again, it won't be repositioned by WM as if it were a new window
801 // Note that this must be done _after_ the window is hidden.
802 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
808 void wxTopLevelWindowGTK
::Raise()
810 gtk_window_present( GTK_WINDOW( m_widget
) );
813 void wxTopLevelWindowGTK
::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
815 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
818 // ----------------------------------------------------------------------------
820 // ----------------------------------------------------------------------------
822 void wxTopLevelWindowGTK
::GTKDoGetSize(int *width
, int *height
) const
824 wxSize
size(m_width
, m_height
);
827 size
-= GetDecorSize(m_gdkDecor
);
828 if (size
.x
< 0) size
.x
= 0;
829 if (size
.y
< 0) size
.y
= 0;
831 if (width
) *width
= size
.x
;
832 if (height
) *height
= size
.y
;
835 void wxTopLevelWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
837 wxCHECK_RET( m_widget
, wxT("invalid frame") );
839 // deal with the position first
843 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
845 // -1 means "use existing" unless the flag above is specified
851 else // wxSIZE_ALLOW_MINUS_ONE
857 if ( m_x
!= old_x
|| m_y
!= old_y
)
859 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
862 const wxSize
oldSize(m_width
, m_height
);
868 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
871 GTKDoGetSize(&w
, &h
);
872 gtk_window_resize(GTK_WINDOW(m_widget
), w
, h
);
874 GetClientSize(&m_oldClientWidth
, &m_oldClientHeight
);
875 wxSizeEvent
event(GetSize(), GetId());
876 event
.SetEventObject(this);
877 GetEventHandler()->ProcessEvent(event
);
881 void wxTopLevelWindowGTK
::DoGetClientSize( int *width
, int *height
) const
883 wxASSERT_MSG(m_widget
, wxT("invalid frame"));
887 // for consistency with wxMSW, client area is supposed to be empty for
888 // the iconized windows
896 GTKDoGetSize(width
, height
);
900 void wxTopLevelWindowGTK
::DoSetSizeHints( int minW
, int minH
,
904 wxTopLevelWindowBase
::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
906 const wxSize minSize
= GetMinSize();
907 const wxSize maxSize
= GetMaxSize();
910 const wxSize sizeDecor
= GetDecorSize(m_gdkDecor
);
911 if (minSize
.x
> 0 || minSize
.y
> 0)
913 hints_mask
|= GDK_HINT_MIN_SIZE
;
914 hints
.min_width
= minSize
.x
- sizeDecor
.x
;
915 if (hints
.min_width
< 0)
917 hints
.min_height
= minSize
.y
- sizeDecor
.y
;
918 if (hints
.min_height
< 0)
919 hints
.min_height
= 0;
921 if (maxSize
.x
> 0 || maxSize
.y
> 0)
923 hints_mask
|= GDK_HINT_MAX_SIZE
;
924 hints
.max_width
= maxSize
.x
- sizeDecor
.x
;
925 if (hints
.max_width
< 0)
926 hints
.max_width
= INT_MAX
;
927 hints
.max_height
= maxSize
.y
- sizeDecor
.y
;
928 if (hints
.max_height
< 0)
929 hints
.max_height
= INT_MAX
;
931 if (incW
> 0 || incH
> 0)
933 hints_mask
|= GDK_HINT_RESIZE_INC
;
934 hints
.width_inc
= incW
> 0 ? incW
: 1;
935 hints
.height_inc
= incH
> 0 ? incH
: 1;
937 gtk_window_set_geometry_hints(
938 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
941 bool wxTopLevelWindowGTK
::IsDecorCacheable() const
946 void wxTopLevelWindowGTK
::OnInternalIdle()
948 // set the focus if not done yet and if we can already do it
949 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
951 if ( g_delayedFocus
&&
952 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
954 wxLogTrace(_T("focus"),
955 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
956 g_delayedFocus
->GetClassInfo()->GetClassName(),
957 g_delayedFocus
->GetLabel().c_str());
959 g_delayedFocus
->SetFocus();
960 g_delayedFocus
= NULL
;
964 wxWindow
::OnInternalIdle();
966 // Synthetize activate events.
967 if ( g_sendActivateEvent
!= -1 )
969 bool activate
= g_sendActivateEvent
!= 0;
971 // if (!activate) wxPrintf( wxT("de") );
972 // wxPrintf( wxT("activate\n") );
975 g_sendActivateEvent
= -1;
977 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
981 // ----------------------------------------------------------------------------
983 // ----------------------------------------------------------------------------
985 void wxTopLevelWindowGTK
::SetTitle( const wxString
&title
)
987 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
989 if ( title
== m_title
)
994 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
997 void wxTopLevelWindowGTK
::SetIcons( const wxIconBundle
&icons
)
999 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1001 wxTopLevelWindowBase
::SetIcons( icons
);
1005 const size_t numIcons
= icons
.GetIconCount();
1006 for ( size_t i
= 0; i
< numIcons
; i
++ )
1008 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1011 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1015 // ----------------------------------------------------------------------------
1016 // frame state: maximized/iconized/normal
1017 // ----------------------------------------------------------------------------
1019 void wxTopLevelWindowGTK
::Maximize(bool maximize
)
1022 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1024 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1027 bool wxTopLevelWindowGTK
::IsMaximized() const
1029 if(!m_widget
->window
)
1032 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1035 void wxTopLevelWindowGTK
::Restore()
1037 // "Present" seems similar enough to "restore"
1038 gtk_window_present( GTK_WINDOW( m_widget
) );
1041 void wxTopLevelWindowGTK
::Iconize( bool iconize
)
1044 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1046 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1049 bool wxTopLevelWindowGTK
::IsIconized() const
1051 return m_isIconized
;
1054 void wxTopLevelWindowGTK
::SetIconizeState(bool iconize
)
1056 if ( iconize
!= m_isIconized
)
1058 m_isIconized
= iconize
;
1059 (void)SendIconizeEvent(iconize
);
1063 void wxTopLevelWindowGTK
::AddGrab()
1068 gtk_grab_add( m_widget
);
1069 wxGUIEventLoop().Run();
1070 gtk_grab_remove( m_widget
);
1074 void wxTopLevelWindowGTK
::RemoveGrab()
1085 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1089 if (region
.IsEmpty())
1091 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1095 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1103 bool wxTopLevelWindowGTK
::SetShape(const wxRegion
& region
)
1105 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1106 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1108 GdkWindow
*window
= NULL
;
1111 do_shape_combine_region(m_wxwindow
->window
, region
);
1113 window
= m_widget
->window
;
1114 return do_shape_combine_region(window
, region
);
1117 bool wxTopLevelWindowGTK
::IsActive()
1119 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1122 void wxTopLevelWindowGTK
::RequestUserAttention(int flags
)
1124 bool new_hint_value
= false;
1126 // FIXME: This is a workaround to focus handling problem
1127 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1128 // yet been processed, and the internal focus system is not up to date yet.
1129 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1130 ::wxYieldIfNeeded();
1132 if(m_urgency_hint
>= 0)
1133 g_source_remove(m_urgency_hint
);
1135 m_urgency_hint
= -2;
1137 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1139 new_hint_value
= true;
1141 if (flags
& wxUSER_ATTENTION_INFO
)
1143 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1145 m_urgency_hint
= -1;
1149 #if GTK_CHECK_VERSION(2,7,0)
1150 if(!gtk_check_version(2,7,0))
1151 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1154 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1157 void wxTopLevelWindowGTK
::SetWindowStyleFlag( long style
)
1159 // Store which styles were changed
1160 long styleChanges
= style
^ m_windowStyle
;
1162 // Process wxWindow styles. This also updates the internal variable
1163 // Therefore m_windowStyle bits carry now the _new_ style values
1164 wxWindow
::SetWindowStyleFlag(style
);
1166 // just return for now if widget does not exist yet
1170 if ( styleChanges
& wxSTAY_ON_TOP
)
1172 gtk_window_set_keep_above(GTK_WINDOW(m_widget
),
1173 m_windowStyle
& wxSTAY_ON_TOP
);
1176 if ( styleChanges
& wxFRAME_NO_TASKBAR
)
1178 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
),
1179 m_windowStyle
& wxFRAME_NO_TASKBAR
);
1183 /* Get the X Window between child and the root window.
1184 This should usually be the WM managed XID */
1185 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1187 Window root
, parent
;
1189 unsigned int nchildren
;
1191 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1194 while (parent
!= root
) {
1196 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1203 bool wxTopLevelWindowGTK
::SetTransparent(wxByte alpha
)
1205 if (!m_widget
|| !m_widget
->window
)
1208 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1209 // We need to get the X Window that has the root window as the immediate parent
1210 // and m_widget->window as a child. This should be the X Window that the WM manages and
1211 // from which the opacity property is checked from.
1212 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1215 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1217 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1220 long opacity
= alpha
* 0x1010101L
;
1221 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1222 XA_CARDINAL
, 32, PropModeReplace
,
1223 (unsigned char *) &opacity
, 1L);
1229 bool wxTopLevelWindowGTK
::CanSetTransparent()
1231 // allow to override automatic detection as it's far from perfect
1232 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1233 if ( wxSystemOptions
::HasOption(SYSOPT_TRANSPARENT
) )
1235 return wxSystemOptions
::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1238 #if GTK_CHECK_VERSION(2,10,0)
1239 if (!gtk_check_version(2,10,0))
1241 return (gtk_widget_is_composited (m_widget
));
1244 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1249 #if 0 // Don't be optimistic here for the sake of wxAUI
1250 int opcode
, event
, error
;
1251 // Check for the existence of a RGBA visual instead?
1252 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1253 "Composite", &opcode
, &event
, &error
);
1257 void wxTopLevelWindowGTK
::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1259 // We don't know the order in which top-level windows will
1260 // be notified, so we need to clear the system objects
1261 // for each top-level window.
1262 extern void wxClearGtkSystemObjects();
1263 wxClearGtkSystemObjects();
1265 // wxWindowBase::OnSysColourChanged will propagate event