1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/toplevel.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
22 #define XIconifyWindow XICONIFYWINDOW
27 #include "wx/toplevel.h"
29 #include "wx/dialog.h"
30 #include "wx/control.h"
32 #include "wx/dcclient.h"
33 #include "wx/gtk/private.h"
35 #include "wx/settings.h"
36 #include "wx/evtloop.h"
41 #include <gdk/gdkkeysyms.h>
44 #include "wx/gtk/win_gtk.h"
46 #include "wx/unix/utilsx11.h"
49 #include <X11/Xatom.h>
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
55 extern void wxapp_install_idle_handler();
58 // ----------------------------------------------------------------------------
60 // ----------------------------------------------------------------------------
62 extern wxList wxPendingDelete
;
64 extern int g_openDialogs
;
65 extern wxWindowGTK
*g_delayedFocus
;
67 // the frame that is currently active (i.e. its child has focus). It is
68 // used to generate wxActivateEvents
69 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
70 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
72 // if we detect that the app has got/lost the focus, we set this variable to
73 // either TRUE or FALSE and an activate event will be sent during the next
74 // OnIdle() call and it is reset to -1: this value means that we shouldn't
75 // send any activate events at all
76 static int g_sendActivateEvent
= -1;
78 //-----------------------------------------------------------------------------
79 // RequestUserAttention related functions
80 //-----------------------------------------------------------------------------
83 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
86 wxASSERT_MSG( GTK_WIDGET_REALIZED(win
), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
87 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
90 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
93 wm_hints
= XAllocWMHints();
96 wm_hints
->flags
|= XUrgencyHint
;
98 wm_hints
->flags
&= ~XUrgencyHint
;
100 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
104 static gint
gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK
*win
)
106 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
107 if(!gtk_check_version(2,7,0))
108 gtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
111 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
->m_widget
), FALSE
);
113 win
->m_urgency_hint
= -2;
118 //-----------------------------------------------------------------------------
120 //-----------------------------------------------------------------------------
123 static gint
gtk_frame_focus_in_callback( GtkWidget
*widget
,
124 GdkEvent
*WXUNUSED(event
),
125 wxTopLevelWindowGTK
*win
)
128 wxapp_install_idle_handler();
130 switch ( g_sendActivateEvent
)
133 // we've got focus from outside, synthetize wxActivateEvent
134 g_sendActivateEvent
= 1;
138 // another our window just lost focus, it was already ours before
139 // - don't send any wxActivateEvent
140 g_sendActivateEvent
= -1;
145 g_lastActiveFrame
= g_activeFrame
;
147 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
149 // MR: wxRequestUserAttention related block
150 switch( win
->m_urgency_hint
)
153 gtk_timeout_remove( win
->m_urgency_hint
);
154 // no break, fallthrough to remove hint too
156 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
157 if(!gtk_check_version(2,7,0))
158 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
162 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
165 win
->m_urgency_hint
= -2;
171 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
172 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
173 event
.SetEventObject(g_activeFrame
);
174 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
180 //-----------------------------------------------------------------------------
182 //-----------------------------------------------------------------------------
185 static gint
gtk_frame_focus_out_callback( GtkWidget
*widget
,
186 GdkEventFocus
*WXUNUSED(gdk_event
),
187 wxTopLevelWindowGTK
*win
)
190 wxapp_install_idle_handler();
192 // if the focus goes out of our app alltogether, OnIdle() will send
193 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
194 // g_sendActivateEvent to -1
195 g_sendActivateEvent
= 0;
197 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
199 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
203 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
204 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
205 event
.SetEventObject(g_activeFrame
);
206 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
208 g_activeFrame
= NULL
;
215 //-----------------------------------------------------------------------------
216 // "focus" from m_window
217 //-----------------------------------------------------------------------------
220 static gint
gtk_frame_focus_callback( GtkWidget
*widget
, GtkDirectionType
WXUNUSED(d
), wxWindow
*WXUNUSED(win
) )
223 wxapp_install_idle_handler();
225 // This disables GTK's tab traversal
226 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus" );
231 //-----------------------------------------------------------------------------
233 //-----------------------------------------------------------------------------
236 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
239 wxapp_install_idle_handler();
244 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
247 wxPrintf( "OnSize from " );
248 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
249 wxPrintf( win->GetClassInfo()->GetClassName() );
250 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
253 (int)alloc->height );
256 win
->m_width
= alloc
->width
;
257 win
->m_height
= alloc
->height
;
258 win
->GtkUpdateSize();
263 //-----------------------------------------------------------------------------
265 //-----------------------------------------------------------------------------
268 static gint
gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
), GdkEvent
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
271 wxapp_install_idle_handler();
273 if (win
->IsEnabled() &&
274 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
283 //-----------------------------------------------------------------------------
285 //-----------------------------------------------------------------------------
289 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
), GdkEventConfigure
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
292 wxapp_install_idle_handler();
294 if (!win
->m_hasVMT
|| !win
->IsShown())
300 gdk_window_get_root_origin( win
->m_widget
->window
, &x
, &y
);
304 wxMoveEvent
mevent( wxPoint(win
->m_x
,win
->m_y
), win
->GetId() );
305 mevent
.SetEventObject( win
);
306 win
->GetEventHandler()->ProcessEvent( mevent
);
312 //-----------------------------------------------------------------------------
313 // "realize" from m_widget
314 //-----------------------------------------------------------------------------
316 // we cannot MWM hints and icons before the widget has been realized,
317 // so we do this directly after realization
321 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
322 wxTopLevelWindowGTK
*win
)
325 wxapp_install_idle_handler();
327 // All this is for Motif Window Manager "hints" and is supposed to be
328 // recognized by other WM as well. Not tested.
329 gdk_window_set_decorations(win
->m_widget
->window
,
330 (GdkWMDecoration
)win
->m_gdkDecor
);
331 gdk_window_set_functions(win
->m_widget
->window
,
332 (GdkWMFunction
)win
->m_gdkFunc
);
334 // GTK's shrinking/growing policy
335 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
336 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 0, 0, 1);
338 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
341 wxIconBundle iconsOld
= win
->GetIcons();
342 if ( iconsOld
.GetIcon(-1).Ok() )
344 win
->SetIcon( wxNullIcon
);
345 win
->SetIcons( iconsOld
);
350 //-----------------------------------------------------------------------------
351 // "map_event" from m_widget
352 //-----------------------------------------------------------------------------
356 gtk_frame_map_callback( GtkWidget
* WXUNUSED(widget
),
357 GdkEvent
* WXUNUSED(event
),
358 wxTopLevelWindow
*win
)
360 win
->SetIconizeState(false);
364 //-----------------------------------------------------------------------------
365 // "unmap_event" from m_widget
366 //-----------------------------------------------------------------------------
370 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
371 GdkEvent
* WXUNUSED(event
),
372 wxTopLevelWindow
*win
)
374 win
->SetIconizeState(true);
378 //-----------------------------------------------------------------------------
379 // "expose_event" of m_client
380 //-----------------------------------------------------------------------------
383 static int gtk_window_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
385 GtkPizza
*pizza
= GTK_PIZZA(widget
);
387 gtk_paint_flat_box (win
->m_widget
->style
,
388 pizza
->bin_window
, GTK_STATE_NORMAL
,
399 // ----------------------------------------------------------------------------
400 // wxTopLevelWindowGTK itself
401 // ----------------------------------------------------------------------------
403 //-----------------------------------------------------------------------------
404 // InsertChild for wxTopLevelWindowGTK
405 //-----------------------------------------------------------------------------
407 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
408 * C++ has no virtual methods in a constructor. We have to emulate a
409 * virtual function here as wxWidgets requires different ways to insert
410 * a child in container classes. */
412 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK
* parent
, wxWindow
* child
)
414 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
416 if (!parent
->m_insertInClientArea
)
418 // these are outside the client area
419 wxTopLevelWindowGTK
* frame
= (wxTopLevelWindowGTK
*) parent
;
420 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
421 GTK_WIDGET(child
->m_widget
),
429 // these are inside the client area
430 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
431 GTK_WIDGET(child
->m_widget
),
438 // resize on OnInternalIdle
439 parent
->GtkUpdateSize();
442 // ----------------------------------------------------------------------------
443 // wxTopLevelWindowGTK creation
444 // ----------------------------------------------------------------------------
446 void wxTopLevelWindowGTK::Init()
451 m_mainWidget
= (GtkWidget
*) NULL
;
452 m_insertInClientArea
= true;
453 m_isIconized
= false;
454 m_fsIsShowing
= false;
455 m_themeEnabled
= true;
456 m_gdkDecor
= m_gdkFunc
= 0;
462 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
464 const wxString
& title
,
466 const wxSize
& sizeOrig
,
468 const wxString
&name
)
470 // always create a frame of some reasonable, even if arbitrary, size (at
471 // least for MSW compatibility)
472 wxSize size
= sizeOrig
;
473 size
.x
= WidthDefault(size
.x
);
474 size
.y
= HeightDefault(size
.y
);
476 wxTopLevelWindows
.Append( this );
478 m_needParent
= false;
480 if (!PreCreation( parent
, pos
, size
) ||
481 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
483 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
489 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInTopLevelWindow
;
491 // NB: m_widget may be !=NULL if it was created by derived class' Create,
492 // e.g. in wxTaskBarIconAreaGTK
493 if (m_widget
== NULL
)
495 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
497 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
498 // Tell WM that this is a dialog window and make it center
499 // on parent by default (this is what GtkDialog ctor does):
500 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
501 GDK_WINDOW_TYPE_HINT_DIALOG
);
502 gtk_window_set_position(GTK_WINDOW(m_widget
),
503 GTK_WIN_POS_CENTER_ON_PARENT
);
507 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
508 #if GTK_CHECK_VERSION(2,1,0)
509 if (!gtk_check_version(2,1,0))
511 if (style
& wxFRAME_TOOL_WINDOW
)
513 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
514 GDK_WINDOW_TYPE_HINT_UTILITY
);
516 // On some WMs, like KDE, a TOOL_WINDOW will still show
517 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
518 // For consistency between WMs and with Windows, we
519 // should set the NO_TASKBAR flag which will apply
520 // the set_skip_taskbar_hint if it is available,
521 // ensuring no taskbar entry will appear.
522 style
|= wxFRAME_NO_TASKBAR
;
529 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
530 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
531 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
532 (style
& wxFRAME_FLOAT_ON_PARENT
)))
534 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
535 GTK_WINDOW(topParent
->m_widget
) );
538 #if GTK_CHECK_VERSION(2,2,0)
539 if (!gtk_check_version(2,2,0))
541 if (style
& wxFRAME_NO_TASKBAR
)
543 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
549 if (!gtk_check_version(2,4,0))
551 if (style
& wxSTAY_ON_TOP
)
553 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
559 gtk_window_set_wmclass( GTK_WINDOW(m_widget
), wxGTK_CONV( name
), wxGTK_CONV( name
) );
561 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
562 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
564 gtk_signal_connect( GTK_OBJECT(m_widget
), "delete_event",
565 GTK_SIGNAL_FUNC(gtk_frame_delete_callback
), (gpointer
)this );
567 // m_mainWidget holds the toolbar, the menubar and the client area
568 m_mainWidget
= gtk_pizza_new();
569 gtk_widget_show( m_mainWidget
);
570 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
571 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
573 if (m_miniEdge
== 0) // wxMiniFrame has its own version.
575 // For m_mainWidget themes
576 gtk_signal_connect( GTK_OBJECT(m_mainWidget
), "expose_event",
577 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
580 // m_wxwindow only represents the client area without toolbar and menubar
581 m_wxwindow
= gtk_pizza_new();
582 gtk_widget_show( m_wxwindow
);
583 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
585 // we donm't allow the frame to get the focus as otherwise
586 // the frame will grab it at arbitrary focus changes
587 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
589 if (m_parent
) m_parent
->AddChild( this );
591 // the user resized the frame by dragging etc.
592 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_allocate",
593 GTK_SIGNAL_FUNC(gtk_frame_size_callback
), (gpointer
)this );
597 if ((m_x
!= -1) || (m_y
!= -1))
598 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
600 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
602 // we cannot set MWM hints and icons before the widget has
603 // been realized, so we do this directly after realization
604 gtk_signal_connect( GTK_OBJECT(m_widget
), "realize",
605 GTK_SIGNAL_FUNC(gtk_frame_realized_callback
), (gpointer
) this );
607 // map and unmap for iconized state
608 gtk_signal_connect( GTK_OBJECT(m_widget
), "map_event",
609 GTK_SIGNAL_FUNC(gtk_frame_map_callback
), (gpointer
)this );
610 gtk_signal_connect( GTK_OBJECT(m_widget
), "unmap_event",
611 GTK_SIGNAL_FUNC(gtk_frame_unmap_callback
), (gpointer
)this );
613 // the only way to get the window size is to connect to this event
614 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
615 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
617 // disable native tab traversal
618 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus",
619 GTK_SIGNAL_FUNC(gtk_frame_focus_callback
), (gpointer
)this );
622 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_in_event",
623 GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback
), (gpointer
)this );
624 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_out_event",
625 GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback
), (gpointer
)this );
628 if ((m_miniEdge
> 0) || (style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
635 m_gdkDecor
= (long) GDK_DECOR_BORDER
;
636 m_gdkFunc
= (long) GDK_FUNC_MOVE
;
638 // All this is for Motif Window Manager "hints" and is supposed to be
639 // recognized by other WMs as well.
640 if ((style
& wxCAPTION
) != 0)
642 m_gdkDecor
|= GDK_DECOR_TITLE
;
644 if ((style
& wxCLOSE_BOX
) != 0)
646 m_gdkFunc
|= GDK_FUNC_CLOSE
;
648 if ((style
& wxSYSTEM_MENU
) != 0)
650 m_gdkDecor
|= GDK_DECOR_MENU
;
652 if ((style
& wxMINIMIZE_BOX
) != 0)
654 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
655 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
657 if ((style
& wxMAXIMIZE_BOX
) != 0)
659 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
660 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
662 if ((style
& wxRESIZE_BORDER
) != 0)
664 m_gdkFunc
|= GDK_FUNC_RESIZE
;
665 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
672 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
676 wxASSERT_MSG( false, _T("Window still grabbed"));
680 m_isBeingDeleted
= true;
682 // it may also be GtkScrolledWindow in the case of an MDI child
683 if (GTK_IS_WINDOW(m_widget
))
685 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
688 if (g_activeFrame
== this)
689 g_activeFrame
= NULL
;
690 if (g_lastActiveFrame
== this)
691 g_lastActiveFrame
= NULL
;
696 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long style
)
698 if (show
== m_fsIsShowing
)
699 return false; // return what?
701 m_fsIsShowing
= show
;
703 wxX11FullScreenMethod method
=
704 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
705 (WXWindow
)GDK_ROOT_WINDOW());
707 #if GTK_CHECK_VERSION(2,2,0)
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
) && !gtk_check_version(2,2,0) )
715 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
717 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
720 #endif // GTK+ >= 2.2.0
722 GdkWindow
*window
= m_widget
->window
;
726 m_fsSaveFlag
= style
;
727 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
728 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
730 int screen_width
,screen_height
;
731 wxDisplaySize( &screen_width
, &screen_height
);
733 gint client_x
, client_y
, root_x
, root_y
;
736 if (method
!= wxX11_FS_WMSPEC
)
738 // don't do it always, Metacity hates it
739 m_fsSaveGdkFunc
= m_gdkFunc
;
740 m_fsSaveGdkDecor
= m_gdkDecor
;
741 m_gdkFunc
= m_gdkDecor
= 0;
742 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
743 gdk_window_set_functions(window
, (GdkWMFunction
)0);
746 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
747 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
748 &width
, &height
, NULL
);
750 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
751 screen_width
+ 1, screen_height
+ 1);
753 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
754 (WXWindow
)GDK_ROOT_WINDOW(),
755 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
756 show
, &m_fsSaveFrame
, method
);
760 if (method
!= wxX11_FS_WMSPEC
)
762 // don't do it always, Metacity hates it
763 m_gdkFunc
= m_fsSaveGdkFunc
;
764 m_gdkDecor
= m_fsSaveGdkDecor
;
765 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
766 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
769 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
770 (WXWindow
)GDK_ROOT_WINDOW(),
771 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
772 show
, &m_fsSaveFrame
, method
);
774 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
775 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
779 // documented behaviour is to show the window if it's still hidden when
780 // showing it full screen
781 if ( show
&& !IsShown() )
787 // ----------------------------------------------------------------------------
788 // overridden wxWindow methods
789 // ----------------------------------------------------------------------------
791 bool wxTopLevelWindowGTK::Show( bool show
)
793 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
795 if (show
&& !m_sizeSet
)
797 /* by calling GtkOnSize here, we don't have to call
798 either after showing the frame, which would entail
799 much ugly flicker or from within the size_allocate
800 handler, because GTK 1.1.X forbids that. */
802 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
806 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
808 return wxWindow::Show( show
);
811 void wxTopLevelWindowGTK::Raise()
813 gtk_window_present( GTK_WINDOW( m_widget
) );
816 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
818 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
821 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
823 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
825 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
826 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
836 int old_width
= m_width
;
837 int old_height
= m_height
;
839 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
841 if (x
!= -1) m_x
= x
;
842 if (y
!= -1) m_y
= y
;
849 if (width
!= -1) m_width
= width
;
850 if (height
!= -1) m_height
= height
;
853 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
855 if (width == -1) m_width = 80;
858 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
860 if (height == -1) m_height = 26;
864 int minWidth
= GetMinWidth(),
865 minHeight
= GetMinHeight(),
866 maxWidth
= GetMaxWidth(),
867 maxHeight
= GetMaxHeight();
870 // GPE's window manager doesn't like size hints
871 // at all, esp. when the user has to use the
879 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
880 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
881 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
882 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
884 if ((m_x
!= -1) || (m_y
!= -1))
886 if ((m_x
!= old_x
) || (m_y
!= old_y
))
888 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
892 if ((m_width
!= old_width
) || (m_height
!= old_height
))
894 if (m_widget
->window
)
895 gdk_window_resize( m_widget
->window
, m_width
, m_height
);
897 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
899 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
900 done either directly before the frame is shown or in idle time
901 so that different calls to SetSize() don't lead to flicker. */
908 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
910 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
912 wxWindow::DoGetClientSize( width
, height
);
916 *height
-= m_miniEdge
*2 + m_miniTitle
;
920 *width
-= m_miniEdge
*2;
924 void wxTopLevelWindowGTK::DoSetClientSize( int width
, int height
)
926 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
929 width
+ m_miniEdge
*2, height
+ m_miniEdge
*2 + m_miniTitle
, 0);
932 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x
), int WXUNUSED(y
),
933 int width
, int height
)
935 // due to a bug in gtk, x,y are always 0
940 if (m_resizing
) return;
943 if ( m_wxwindow
== NULL
) return;
948 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
949 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
950 set in wxFrame::Create so it is used to check what kind of frame we
951 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
952 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
953 importantly) m_mainWidget */
955 int minWidth
= GetMinWidth(),
956 minHeight
= GetMinHeight(),
957 maxWidth
= GetMaxWidth(),
958 maxHeight
= GetMaxHeight();
961 // GPE's window manager doesn't like size hints
962 // at all, esp. when the user has to use the
970 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
971 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
972 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
973 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
978 gint flag
= 0; // GDK_HINT_POS;
981 if ((minWidth
!= -1) || (minHeight
!= -1)) flag
|= GDK_HINT_MIN_SIZE
;
982 if ((maxWidth
!= -1) || (maxHeight
!= -1)) flag
|= GDK_HINT_MAX_SIZE
;
984 geom
.min_width
= minWidth
;
985 geom
.min_height
= minHeight
;
987 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
988 // maxHeight or maxWidth is set, we must set them both, else the
989 // remaining -1 will be taken literally.
991 // I'm certain this also happens elsewhere, and is the probable
992 // cause of other such things as:
993 // Gtk-WARNING **: gtk_widget_size_allocate():
994 // attempt to allocate widget with width 65535 and height 600
995 // but I don't have time to track them all now..
997 // Really we need to encapulate all this height/width business and
998 // stop any old method from ripping at the members directly and
999 // scattering -1's without regard for who might resolve them later.
1001 geom
.max_width
= ( maxHeight
== -1 ) ? maxWidth
1002 : ( maxWidth
== -1 ) ? wxGetDisplaySize().GetWidth()
1005 geom
.max_height
= ( maxWidth
== -1 ) ? maxHeight
// ( == -1 here )
1006 : ( maxHeight
== -1 ) ? wxGetDisplaySize().GetHeight()
1009 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget
),
1012 (GdkWindowHints
) flag
);
1014 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1015 * menubar, the toolbar and the client area, which is represented by
1017 * this hurts in the eye, but I don't want to call SetSize()
1018 * because I don't want to call any non-native functions here. */
1020 int client_x
= m_miniEdge
;
1021 int client_y
= m_miniEdge
+ m_miniTitle
;
1022 int client_w
= m_width
- 2*m_miniEdge
;
1023 int client_h
= m_height
- 2*m_miniEdge
- m_miniTitle
;
1025 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
1027 client_x
, client_y
, client_w
, client_h
);
1031 // If there is no m_mainWidget between m_widget and m_wxwindow there
1032 // is no need to set the size or position of m_wxwindow.
1037 // send size event to frame
1038 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1039 event
.SetEventObject( this );
1040 GetEventHandler()->ProcessEvent( event
);
1045 void wxTopLevelWindowGTK::OnInternalIdle()
1047 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
1049 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
1051 // we'll come back later
1053 wxapp_install_idle_handler();
1057 // set the focus if not done yet and if we can already do it
1058 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
1060 if ( g_delayedFocus
&&
1061 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
1063 wxLogTrace(_T("focus"),
1064 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1065 g_delayedFocus
->GetClassInfo()->GetClassName(),
1066 g_delayedFocus
->GetLabel().c_str());
1068 g_delayedFocus
->SetFocus();
1069 g_delayedFocus
= NULL
;
1073 wxWindow::OnInternalIdle();
1075 // Synthetize activate events.
1076 if ( g_sendActivateEvent
!= -1 )
1078 bool activate
= g_sendActivateEvent
!= 0;
1080 // if (!activate) wxPrintf( wxT("de") );
1081 // wxPrintf( wxT("activate\n") );
1084 g_sendActivateEvent
= -1;
1086 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1090 // ----------------------------------------------------------------------------
1092 // ----------------------------------------------------------------------------
1094 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1096 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1098 if ( title
== m_title
)
1103 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1106 void wxTopLevelWindowGTK::SetIcon( const wxIcon
&icon
)
1108 SetIcons( wxIconBundle( icon
) );
1111 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1113 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1115 wxTopLevelWindowBase::SetIcons( icons
);
1118 size_t max
= icons
.m_icons
.GetCount();
1120 for (size_t i
= 0; i
< max
; i
++)
1122 if (icons
.m_icons
[i
].Ok())
1124 list
= g_list_prepend(list
, icons
.m_icons
[i
].GetPixbuf());
1127 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1131 // ----------------------------------------------------------------------------
1132 // frame state: maximized/iconized/normal
1133 // ----------------------------------------------------------------------------
1135 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1138 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1140 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1143 bool wxTopLevelWindowGTK::IsMaximized() const
1145 if(!m_widget
->window
)
1148 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1151 void wxTopLevelWindowGTK::Restore()
1153 // "Present" seems similar enough to "restore"
1154 gtk_window_present( GTK_WINDOW( m_widget
) );
1157 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1160 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1162 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1165 bool wxTopLevelWindowGTK::IsIconized() const
1167 return m_isIconized
;
1170 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1172 if ( iconize
!= m_isIconized
)
1174 m_isIconized
= iconize
;
1175 (void)SendIconizeEvent(iconize
);
1179 void wxTopLevelWindowGTK::AddGrab()
1184 gtk_grab_add( m_widget
);
1185 wxEventLoop().Run();
1186 gtk_grab_remove( m_widget
);
1190 void wxTopLevelWindowGTK::RemoveGrab()
1201 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1205 if (region
.IsEmpty())
1207 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1211 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1219 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1221 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1222 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1224 GdkWindow
*window
= NULL
;
1227 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1228 do_shape_combine_region(window
, region
);
1230 window
= m_widget
->window
;
1231 return do_shape_combine_region(window
, region
);
1234 bool wxTopLevelWindowGTK::IsActive()
1236 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1239 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1241 bool new_hint_value
= false;
1243 // FIXME: This is a workaround to focus handling problem
1244 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1245 // yet been processed, and the internal focus system is not up to date yet.
1246 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1247 ::wxYieldIfNeeded();
1249 if(m_urgency_hint
>= 0)
1250 gtk_timeout_remove(m_urgency_hint
);
1252 m_urgency_hint
= -2;
1254 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1256 new_hint_value
= true;
1258 if (flags
& wxUSER_ATTENTION_INFO
)
1260 m_urgency_hint
= gtk_timeout_add(5000, (GtkFunction
)gtk_frame_urgency_timer_callback
, this);
1262 m_urgency_hint
= -1;
1266 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
1267 if(!gtk_check_version(2,7,0))
1268 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1271 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1274 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1276 // Store which styles were changed
1277 long styleChanges
= style
^ m_windowStyle
;
1279 // Process wxWindow styles. This also updates the internal variable
1280 // Therefore m_windowStyle bits carry now the _new_ style values
1281 wxWindow::SetWindowStyleFlag(style
);
1283 // just return for now if widget does not exist yet
1288 if ( (styleChanges
& wxSTAY_ON_TOP
) && !gtk_check_version(2,4,0) )
1289 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), m_windowStyle
& wxSTAY_ON_TOP
);
1291 #if GTK_CHECK_VERSION(2,2,0)
1292 if ( (styleChanges
& wxFRAME_NO_TASKBAR
) && !gtk_check_version(2,2,0) )
1294 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), m_windowStyle
& wxFRAME_NO_TASKBAR
);