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 //-----------------------------------------------------------------------------
170 static gboolean
gtk_frame_focus_out_callback( GtkWidget
*widget
,
171 GdkEventFocus
*WXUNUSED(gdk_event
),
172 wxTopLevelWindowGTK
*win
)
174 // if the focus goes out of our app alltogether, OnIdle() will send
175 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
176 // g_sendActivateEvent to -1
177 g_sendActivateEvent
= 0;
179 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
181 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
185 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
186 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
187 event
.SetEventObject(g_activeFrame
);
188 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
190 g_activeFrame
= NULL
;
197 //-----------------------------------------------------------------------------
199 //-----------------------------------------------------------------------------
202 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
207 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
210 wxPrintf( wxT("gtk_frame_size_callback from ") );
211 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
212 wxPrintf( win->GetClassInfo()->GetClassName() );
213 wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
216 (int)alloc->height );
219 // Tell the wxWindow class about the new size
220 win
->m_width
= alloc
->width
;
221 win
->m_height
= alloc
->height
;
223 win
->GtkUpdateSize();
228 // ----------------------------------------------------------------------------
230 // ----------------------------------------------------------------------------
233 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
234 GtkRequisition
*requisition
,
235 wxTopLevelWindowGTK
*win
)
237 // we must return the size of the window without WM decorations, otherwise
238 // GTK+ gets confused, so don't call just GetSize() here
240 win
->GTKDoGetSize(&w
, &h
);
242 requisition
->height
= h
;
243 requisition
->width
= w
;
246 //-----------------------------------------------------------------------------
248 //-----------------------------------------------------------------------------
252 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
253 GdkEvent
*WXUNUSED(event
),
254 wxTopLevelWindowGTK
*win
)
256 if (win
->IsEnabled() &&
257 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
266 //-----------------------------------------------------------------------------
268 //-----------------------------------------------------------------------------
272 gtk_frame_configure_callback( GtkWidget
* widget
,
273 GdkEventConfigure
*WXUNUSED(event
),
274 wxTopLevelWindowGTK
*win
)
276 if (!win
->m_hasVMT
|| !win
->IsShown())
280 gtk_window_get_position((GtkWindow
*)widget
, &point
.x
, &point
.y
);
284 wxMoveEvent
mevent(point
, win
->GetId());
285 mevent
.SetEventObject( win
);
286 win
->GetEventHandler()->ProcessEvent( mevent
);
292 //-----------------------------------------------------------------------------
293 // "realize" from m_widget
294 //-----------------------------------------------------------------------------
296 // we cannot MWM hints and icons before the widget has been realized,
297 // so we do this directly after realization
301 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
302 wxTopLevelWindowGTK
*win
)
304 // All this is for Motif Window Manager "hints" and is supposed to be
305 // recognized by other WM as well. Not tested.
306 gdk_window_set_decorations(win
->m_widget
->window
,
307 (GdkWMDecoration
)win
->m_gdkDecor
);
308 gdk_window_set_functions(win
->m_widget
->window
,
309 (GdkWMFunction
)win
->m_gdkFunc
);
311 // GTK's shrinking/growing policy
312 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
313 gtk_window_set_resizable(GTK_WINDOW(win
->m_widget
), FALSE
);
315 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
318 wxIconBundle iconsOld
= win
->GetIcons();
319 if ( !iconsOld
.IsEmpty() )
321 win
->SetIcon( wxNullIcon
);
322 win
->SetIcons( iconsOld
);
327 //-----------------------------------------------------------------------------
328 // "map_event" from m_widget
329 //-----------------------------------------------------------------------------
333 gtk_frame_map_callback( GtkWidget
* WXUNUSED(widget
),
334 GdkEvent
* WXUNUSED(event
),
335 wxTopLevelWindow
*win
)
337 win
->SetIconizeState(false);
342 //-----------------------------------------------------------------------------
343 // "unmap_event" from m_widget
344 //-----------------------------------------------------------------------------
348 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
349 GdkEvent
* WXUNUSED(event
),
350 wxTopLevelWindow
*win
)
352 win
->SetIconizeState(true);
357 //-----------------------------------------------------------------------------
358 // "expose_event" of m_client
359 //-----------------------------------------------------------------------------
363 gtk_window_expose_callback( GtkWidget
*widget
,
364 GdkEventExpose
*gdk_event
,
367 GtkPizza
*pizza
= GTK_PIZZA(widget
);
369 gtk_paint_flat_box (win
->m_widget
->style
,
370 pizza
->bin_window
, GTK_STATE_NORMAL
,
381 // ----------------------------------------------------------------------------
382 // wxTopLevelWindowGTK itself
383 // ----------------------------------------------------------------------------
385 //-----------------------------------------------------------------------------
386 // InsertChild for wxTopLevelWindowGTK
387 //-----------------------------------------------------------------------------
389 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
390 * C++ has no virtual methods in a constructor. We have to emulate a
391 * virtual function here as wxWidgets requires different ways to insert
392 * a child in container classes. */
394 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK
* parent
, wxWindow
* child
)
396 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
398 if (!parent
->m_insertInClientArea
)
400 // these are outside the client area
401 wxTopLevelWindowGTK
* frame
= (wxTopLevelWindowGTK
*) parent
;
402 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
411 // these are inside the client area
412 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
421 // ----------------------------------------------------------------------------
422 // wxTopLevelWindowGTK creation
423 // ----------------------------------------------------------------------------
425 void wxTopLevelWindowGTK::Init()
430 m_mainWidget
= (GtkWidget
*) NULL
;
431 m_insertInClientArea
= true;
432 m_isIconized
= false;
433 m_fsIsShowing
= false;
435 m_themeEnabled
= true;
436 m_gdkDecor
= m_gdkFunc
= 0;
442 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
444 const wxString
& title
,
446 const wxSize
& sizeOrig
,
448 const wxString
&name
)
450 // always create a frame of some reasonable, even if arbitrary, size (at
451 // least for MSW compatibility)
452 wxSize size
= sizeOrig
;
453 size
.x
= WidthDefault(size
.x
);
454 size
.y
= HeightDefault(size
.y
);
456 wxTopLevelWindows
.Append( this );
458 if (!PreCreation( parent
, pos
, size
) ||
459 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
461 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
467 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInTopLevelWindow
;
469 // NB: m_widget may be !=NULL if it was created by derived class' Create,
470 // e.g. in wxTaskBarIconAreaGTK
471 if (m_widget
== NULL
)
473 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
475 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
476 // Tell WM that this is a dialog window and make it center
477 // on parent by default (this is what GtkDialog ctor does):
478 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
479 GDK_WINDOW_TYPE_HINT_DIALOG
);
480 gtk_window_set_position(GTK_WINDOW(m_widget
),
481 GTK_WIN_POS_CENTER_ON_PARENT
);
485 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
486 #if GTK_CHECK_VERSION(2,1,0)
487 if (!gtk_check_version(2,1,0))
489 if (style
& wxFRAME_TOOL_WINDOW
)
491 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
492 GDK_WINDOW_TYPE_HINT_UTILITY
);
494 // On some WMs, like KDE, a TOOL_WINDOW will still show
495 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
496 // For consistency between WMs and with Windows, we
497 // should set the NO_TASKBAR flag which will apply
498 // the set_skip_taskbar_hint if it is available,
499 // ensuring no taskbar entry will appear.
500 style
|= wxFRAME_NO_TASKBAR
;
507 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
508 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
509 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
510 (style
& wxFRAME_FLOAT_ON_PARENT
)))
512 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
513 GTK_WINDOW(topParent
->m_widget
) );
516 #if GTK_CHECK_VERSION(2,2,0)
517 if (!gtk_check_version(2,2,0))
519 if (style
& wxFRAME_NO_TASKBAR
)
521 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
527 if (!gtk_check_version(2,4,0))
529 if (style
& wxSTAY_ON_TOP
)
531 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
538 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
541 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
542 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
544 g_signal_connect (m_widget
, "delete_event",
545 G_CALLBACK (gtk_frame_delete_callback
), this);
547 // m_mainWidget holds the toolbar, the menubar and the client area
548 m_mainWidget
= gtk_pizza_new();
549 gtk_widget_show( m_mainWidget
);
550 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
551 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
553 if (m_miniEdge
== 0) // wxMiniFrame has its own version.
555 // For m_mainWidget themes
556 g_signal_connect (m_mainWidget
, "expose_event",
557 G_CALLBACK (gtk_window_expose_callback
), this);
560 // m_wxwindow only represents the client area without toolbar and menubar
561 m_wxwindow
= gtk_pizza_new();
562 gtk_widget_show( m_wxwindow
);
563 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
565 // we donm't allow the frame to get the focus as otherwise
566 // the frame will grab it at arbitrary focus changes
567 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
569 if (m_parent
) m_parent
->AddChild( this );
571 // the user resized the frame by dragging etc.
572 g_signal_connect (m_widget
, "size_allocate",
573 G_CALLBACK (gtk_frame_size_callback
), this);
575 g_signal_connect (m_widget
, "size_request",
576 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
579 if ((m_x
!= -1) || (m_y
!= -1))
580 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
582 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
584 // we cannot set MWM hints and icons before the widget has
585 // been realized, so we do this directly after realization
586 g_signal_connect (m_widget
, "realize",
587 G_CALLBACK (gtk_frame_realized_callback
), this);
589 // map and unmap for iconized state
590 g_signal_connect (m_widget
, "map_event",
591 G_CALLBACK (gtk_frame_map_callback
), this);
592 g_signal_connect (m_widget
, "unmap_event",
593 G_CALLBACK (gtk_frame_unmap_callback
), this);
596 g_signal_connect (m_widget
, "configure_event",
597 G_CALLBACK (gtk_frame_configure_callback
), this);
600 g_signal_connect_after (m_widget
, "focus_in_event",
601 G_CALLBACK (gtk_frame_focus_in_callback
), this);
602 g_signal_connect_after (m_widget
, "focus_out_event",
603 G_CALLBACK (gtk_frame_focus_out_callback
), this);
606 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
617 if ((style
& wxRESIZE_BORDER
) != 0)
618 m_gdkFunc
|= GDK_FUNC_RESIZE
;
622 m_gdkDecor
= (long) GDK_DECOR_BORDER
;
623 m_gdkFunc
= (long) GDK_FUNC_MOVE
;
625 // All this is for Motif Window Manager "hints" and is supposed to be
626 // recognized by other WMs as well.
627 if ((style
& wxCAPTION
) != 0)
629 m_gdkDecor
|= GDK_DECOR_TITLE
;
631 if ((style
& wxCLOSE_BOX
) != 0)
633 m_gdkFunc
|= GDK_FUNC_CLOSE
;
635 if ((style
& wxSYSTEM_MENU
) != 0)
637 m_gdkDecor
|= GDK_DECOR_MENU
;
639 if ((style
& wxMINIMIZE_BOX
) != 0)
641 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
642 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
644 if ((style
& wxMAXIMIZE_BOX
) != 0)
646 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
647 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
649 if ((style
& wxRESIZE_BORDER
) != 0)
651 m_gdkFunc
|= GDK_FUNC_RESIZE
;
652 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
659 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
663 wxFAIL_MSG(_T("Window still grabbed"));
667 m_isBeingDeleted
= true;
669 // it may also be GtkScrolledWindow in the case of an MDI child
670 if (GTK_IS_WINDOW(m_widget
))
672 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
675 if (g_activeFrame
== this)
676 g_activeFrame
= NULL
;
677 if (g_lastActiveFrame
== this)
678 g_lastActiveFrame
= NULL
;
681 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
684 m_gdkFunc
|= GDK_FUNC_CLOSE
;
686 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
688 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
689 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
694 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long style
)
696 if (show
== m_fsIsShowing
)
697 return false; // return what?
699 m_fsIsShowing
= show
;
701 wxX11FullScreenMethod method
=
702 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
703 (WXWindow
)GDK_ROOT_WINDOW());
705 #if GTK_CHECK_VERSION(2,2,0)
706 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
707 // to switch to fullscreen, which is not always available. We must
708 // check if WM supports the spec and use legacy methods if it
710 if ( (method
== wxX11_FS_WMSPEC
) && !gtk_check_version(2,2,0) )
714 m_fsSaveFlag
= style
;
715 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
720 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
724 #endif // GTK+ >= 2.2.0
726 GdkWindow
*window
= m_widget
->window
;
730 m_fsSaveFlag
= style
;
731 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
732 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
734 int screen_width
,screen_height
;
735 wxDisplaySize( &screen_width
, &screen_height
);
737 gint client_x
, client_y
, root_x
, root_y
;
740 if (method
!= wxX11_FS_WMSPEC
)
742 // don't do it always, Metacity hates it
743 m_fsSaveGdkFunc
= m_gdkFunc
;
744 m_fsSaveGdkDecor
= m_gdkDecor
;
745 m_gdkFunc
= m_gdkDecor
= 0;
746 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
747 gdk_window_set_functions(window
, (GdkWMFunction
)0);
750 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
751 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
752 &width
, &height
, NULL
);
754 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
755 screen_width
+ 1, screen_height
+ 1);
757 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
758 (WXWindow
)GDK_ROOT_WINDOW(),
759 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
760 show
, &m_fsSaveFrame
, method
);
765 if (method
!= wxX11_FS_WMSPEC
)
767 // don't do it always, Metacity hates it
768 m_gdkFunc
= m_fsSaveGdkFunc
;
769 m_gdkDecor
= m_fsSaveGdkDecor
;
770 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
771 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
774 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
775 (WXWindow
)GDK_ROOT_WINDOW(),
776 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
777 show
, &m_fsSaveFrame
, method
);
779 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
780 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
784 // documented behaviour is to show the window if it's still hidden when
785 // showing it full screen
786 if ( show
&& !IsShown() )
792 // ----------------------------------------------------------------------------
793 // overridden wxWindow methods
794 // ----------------------------------------------------------------------------
796 bool wxTopLevelWindowGTK::Show( bool show
)
798 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
800 if (show
== IsShown())
803 if (show
&& !m_sizeSet
)
805 /* by calling GtkOnSize here, we don't have to call
806 either after showing the frame, which would entail
807 much ugly flicker or from within the size_allocate
808 handler, because GTK 1.1.X forbids that. */
813 wxTopLevelWindowBase::Show(show
);
817 // make sure window has a non-default position, so when it is shown
818 // again, it won't be repositioned by WM as if it were a new window
819 // Note that this must be done _after_ the window is hidden.
820 gtk_window_move((GtkWindow
*)m_widget
, m_x
, m_y
);
826 void wxTopLevelWindowGTK::Raise()
828 gtk_window_present( GTK_WINDOW( m_widget
) );
831 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
833 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
836 // ----------------------------------------------------------------------------
838 // ----------------------------------------------------------------------------
840 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
842 return wxTopLevelWindowBase::DoGetSize(width
, height
);
845 void wxTopLevelWindowGTK::GTKDoSetSize(int width
, int height
)
852 int old_width
= m_width
;
853 int old_height
= m_height
;
862 if ( m_width
!= old_width
|| m_height
!= old_height
)
864 gtk_window_resize( GTK_WINDOW(m_widget
), m_width
, m_height
);
866 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
867 done either directly before the frame is shown or in idle time
868 so that different calls to SetSize() don't lead to flicker. */
875 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
877 wxCHECK_RET( m_widget
, wxT("invalid frame") );
879 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
880 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
883 // deal with the position first
887 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
889 // -1 means "use existing" unless the flag above is specified
895 else // wxSIZE_ALLOW_MINUS_ONE
901 if ( m_x
!= old_x
|| m_y
!= old_y
)
903 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
907 // and now change the size: as we want to set the size of the entire
908 // window, including decorations, we must adjust the size passed to
909 // GTKDoSetSize() which takes with the size of undecorated frame only
910 if ( width
!= -1 || height
!= -1 )
914 DoGetSize(&wTotal
, &hTotal
);
918 GTKDoGetSize(&wUndec
, &hUndec
);
921 width
-= wTotal
- wUndec
;
923 height
-= hTotal
- hUndec
;
926 GTKDoSetSize(width
, height
);
929 void wxTopLevelWindowGTK::DoGetSize(int *width
, int *height
) const
931 wxCHECK_RET( m_widget
, wxT("invalid frame") );
933 if ( !m_widget
->window
)
935 // this can happen if we're called before the window is realized, so
936 // don't assert but just return the stored values
937 GTKDoGetSize(width
, height
);
942 gdk_window_get_frame_extents(m_widget
->window
, &rect
);
947 *height
= rect
.height
;
950 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
954 // for consistency with wxMSW, client area is supposed to be empty for
955 // the iconized windows
964 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
968 *height
= m_height
- 2 * m_miniEdge
- m_miniTitle
;
974 *width
= m_width
- 2 * m_miniEdge
;
980 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
984 wxTopLevelWindowBase::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
986 const wxSize minSize
= GetMinSize();
987 const wxSize maxSize
= GetMaxSize();
990 if (minSize
.x
> 0 || minSize
.y
> 0)
992 hints_mask
|= GDK_HINT_MIN_SIZE
;
993 hints
.min_width
= minSize
.x
> 0 ? minSize
.x
: 0;
994 hints
.min_height
= minSize
.y
> 0 ? minSize
.y
: 0;
996 if (maxSize
.x
> 0 || maxSize
.y
> 0)
998 hints_mask
|= GDK_HINT_MAX_SIZE
;
999 hints
.max_width
= maxSize
.x
> 0 ? maxSize
.x
: INT_MAX
;
1000 hints
.max_height
= maxSize
.y
> 0 ? maxSize
.y
: INT_MAX
;
1002 if (incW
> 0 || incH
> 0)
1004 hints_mask
|= GDK_HINT_RESIZE_INC
;
1005 hints
.width_inc
= incW
> 0 ? incW
: 1;
1006 hints
.height_inc
= incH
> 0 ? incH
: 1;
1008 gtk_window_set_geometry_hints(
1009 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
1013 void wxTopLevelWindowGTK::GtkOnSize()
1016 if (m_resizing
) return;
1019 if ( m_wxwindow
== NULL
) return;
1025 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
1027 0, 0, m_width
, m_height
);
1032 // send size event to frame
1033 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1034 event
.SetEventObject( this );
1035 GetEventHandler()->ProcessEvent( event
);
1040 void wxTopLevelWindowGTK::OnInternalIdle()
1042 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
1046 // we'll come back later
1050 // set the focus if not done yet and if we can already do it
1051 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
1053 if ( g_delayedFocus
&&
1054 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
1056 wxLogTrace(_T("focus"),
1057 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1058 g_delayedFocus
->GetClassInfo()->GetClassName(),
1059 g_delayedFocus
->GetLabel().c_str());
1061 g_delayedFocus
->SetFocus();
1062 g_delayedFocus
= NULL
;
1066 wxWindow::OnInternalIdle();
1068 // Synthetize activate events.
1069 if ( g_sendActivateEvent
!= -1 )
1071 bool activate
= g_sendActivateEvent
!= 0;
1073 // if (!activate) wxPrintf( wxT("de") );
1074 // wxPrintf( wxT("activate\n") );
1077 g_sendActivateEvent
= -1;
1079 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1083 // ----------------------------------------------------------------------------
1085 // ----------------------------------------------------------------------------
1087 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1089 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1091 if ( title
== m_title
)
1096 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1099 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1101 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1103 wxTopLevelWindowBase::SetIcons( icons
);
1107 const size_t numIcons
= icons
.GetIconCount();
1108 for ( size_t i
= 0; i
< numIcons
; i
++ )
1110 list
= g_list_prepend(list
, icons
.GetIconByIndex(i
).GetPixbuf());
1113 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1117 // ----------------------------------------------------------------------------
1118 // frame state: maximized/iconized/normal
1119 // ----------------------------------------------------------------------------
1121 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1124 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1126 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1129 bool wxTopLevelWindowGTK::IsMaximized() const
1131 if(!m_widget
->window
)
1134 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1137 void wxTopLevelWindowGTK::Restore()
1139 // "Present" seems similar enough to "restore"
1140 gtk_window_present( GTK_WINDOW( m_widget
) );
1143 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1146 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1148 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1151 bool wxTopLevelWindowGTK::IsIconized() const
1153 return m_isIconized
;
1156 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1158 if ( iconize
!= m_isIconized
)
1160 m_isIconized
= iconize
;
1161 (void)SendIconizeEvent(iconize
);
1165 void wxTopLevelWindowGTK::AddGrab()
1170 gtk_grab_add( m_widget
);
1171 wxGUIEventLoop().Run();
1172 gtk_grab_remove( m_widget
);
1176 void wxTopLevelWindowGTK::RemoveGrab()
1187 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1191 if (region
.IsEmpty())
1193 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1197 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1205 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1207 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1208 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1210 GdkWindow
*window
= NULL
;
1213 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1214 do_shape_combine_region(window
, region
);
1216 window
= m_widget
->window
;
1217 return do_shape_combine_region(window
, region
);
1220 bool wxTopLevelWindowGTK::IsActive()
1222 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1225 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1227 bool new_hint_value
= false;
1229 // FIXME: This is a workaround to focus handling problem
1230 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1231 // yet been processed, and the internal focus system is not up to date yet.
1232 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1233 ::wxYieldIfNeeded();
1235 if(m_urgency_hint
>= 0)
1236 g_source_remove(m_urgency_hint
);
1238 m_urgency_hint
= -2;
1240 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1242 new_hint_value
= true;
1244 if (flags
& wxUSER_ATTENTION_INFO
)
1246 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1248 m_urgency_hint
= -1;
1252 #if GTK_CHECK_VERSION(2,7,0)
1253 if(!gtk_check_version(2,7,0))
1254 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1257 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1260 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1262 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1263 // Store which styles were changed
1264 long styleChanges
= style
^ m_windowStyle
;
1267 // Process wxWindow styles. This also updates the internal variable
1268 // Therefore m_windowStyle bits carry now the _new_ style values
1269 wxWindow::SetWindowStyleFlag(style
);
1271 // just return for now if widget does not exist yet
1276 if ( (styleChanges
& wxSTAY_ON_TOP
) && !gtk_check_version(2,4,0) )
1277 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), m_windowStyle
& wxSTAY_ON_TOP
);
1279 #if GTK_CHECK_VERSION(2,2,0)
1280 if ( (styleChanges
& wxFRAME_NO_TASKBAR
) && !gtk_check_version(2,2,0) )
1282 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), m_windowStyle
& wxFRAME_NO_TASKBAR
);
1287 #include <X11/Xlib.h>
1289 /* Get the X Window between child and the root window.
1290 This should usually be the WM managed XID */
1291 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1293 Window root
, parent
;
1295 unsigned int nchildren
;
1297 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1300 while (parent
!= root
) {
1302 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1309 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1311 if (!m_widget
|| !m_widget
->window
)
1314 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1315 // We need to get the X Window that has the root window as the immediate parent
1316 // and m_widget->window as a child. This should be the X Window that the WM manages and
1317 // from which the opacity property is checked from.
1318 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1320 unsigned int opacity
= alpha
* 0x1010101;
1322 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1324 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1326 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1327 XA_CARDINAL
, 32, PropModeReplace
,
1328 (unsigned char *) &opacity
, 1L);
1333 bool wxTopLevelWindowGTK::CanSetTransparent()
1335 // allow to override automatic detection as it's far from perfect
1336 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1337 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1339 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1342 #if GTK_CHECK_VERSION(2,10,0)
1343 if (!gtk_check_version(2,10,0))
1345 return (gtk_widget_is_composited (m_widget
));
1348 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1353 #if 0 // Don't be optimistic here for the sake of wxAUI
1354 int opcode
, event
, error
;
1355 // Check for the existence of a RGBA visual instead?
1356 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1357 "Composite", &opcode
, &event
, &error
);