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 // don't need to install idle handler, its done from "event" signal
117 switch ( g_sendActivateEvent
)
120 // we've got focus from outside, synthetize wxActivateEvent
121 g_sendActivateEvent
= 1;
125 // another our window just lost focus, it was already ours before
126 // - don't send any wxActivateEvent
127 g_sendActivateEvent
= -1;
132 g_lastActiveFrame
= g_activeFrame
;
134 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
136 // MR: wxRequestUserAttention related block
137 switch( win
->m_urgency_hint
)
140 g_source_remove( win
->m_urgency_hint
);
141 // no break, fallthrough to remove hint too
143 #if GTK_CHECK_VERSION(2,7,0)
144 if(!gtk_check_version(2,7,0))
145 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
149 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
152 win
->m_urgency_hint
= -2;
158 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
159 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
160 event
.SetEventObject(g_activeFrame
);
161 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
167 //-----------------------------------------------------------------------------
169 //-----------------------------------------------------------------------------
172 static gboolean
gtk_frame_focus_out_callback( GtkWidget
*widget
,
173 GdkEventFocus
*WXUNUSED(gdk_event
),
174 wxTopLevelWindowGTK
*win
)
176 // don't need to install idle handler, its done from "event" signal
178 // if the focus goes out of our app alltogether, OnIdle() will send
179 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
180 // g_sendActivateEvent to -1
181 g_sendActivateEvent
= 0;
183 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
185 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
189 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
190 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
191 event
.SetEventObject(g_activeFrame
);
192 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
194 g_activeFrame
= NULL
;
201 //-----------------------------------------------------------------------------
203 //-----------------------------------------------------------------------------
206 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
209 wxapp_install_idle_handler();
214 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
217 wxPrintf( wxT("gtk_frame_size_callback from ") );
218 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
219 wxPrintf( win->GetClassInfo()->GetClassName() );
220 wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
223 (int)alloc->height );
226 // Tell the wxWindow class about the new size
227 win
->m_width
= alloc
->width
;
228 win
->m_height
= alloc
->height
;
230 win
->GtkUpdateSize();
235 // ----------------------------------------------------------------------------
237 // ----------------------------------------------------------------------------
240 void wxgtk_tlw_size_request_callback(GtkWidget
* WXUNUSED(widget
),
241 GtkRequisition
*requisition
,
242 wxTopLevelWindowGTK
*win
)
244 // we must return the size of the window without WM decorations, otherwise
245 // GTK+ gets confused, so don't call just GetSize() here
247 win
->GTKDoGetSize(&w
, &h
);
249 requisition
->height
= h
;
250 requisition
->width
= w
;
253 //-----------------------------------------------------------------------------
255 //-----------------------------------------------------------------------------
259 gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
),
260 GdkEvent
*WXUNUSED(event
),
261 wxTopLevelWindowGTK
*win
)
263 // don't need to install idle handler, its done from "event" signal
265 if (win
->IsEnabled() &&
266 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
275 //-----------------------------------------------------------------------------
277 //-----------------------------------------------------------------------------
281 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
),
282 GdkEventConfigure
*WXUNUSED(event
),
283 wxTopLevelWindowGTK
*win
)
285 // don't need to install idle handler, its done from "event" signal
287 if (!win
->m_hasVMT
|| !win
->IsShown())
293 gdk_window_get_root_origin( win
->m_widget
->window
, &x
, &y
);
297 wxMoveEvent
mevent( wxPoint(win
->m_x
,win
->m_y
), win
->GetId() );
298 mevent
.SetEventObject( win
);
299 win
->GetEventHandler()->ProcessEvent( mevent
);
305 //-----------------------------------------------------------------------------
306 // "realize" from m_widget
307 //-----------------------------------------------------------------------------
309 // we cannot MWM hints and icons before the widget has been realized,
310 // so we do this directly after realization
314 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
315 wxTopLevelWindowGTK
*win
)
318 wxapp_install_idle_handler();
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
.GetIcon(-1).Ok() )
337 win
->SetIcon( wxNullIcon
);
338 win
->SetIcons( iconsOld
);
343 //-----------------------------------------------------------------------------
344 // "map_event" from m_widget
345 //-----------------------------------------------------------------------------
349 gtk_frame_map_callback( GtkWidget
* WXUNUSED(widget
),
350 GdkEvent
* WXUNUSED(event
),
351 wxTopLevelWindow
*win
)
353 win
->SetIconizeState(false);
357 //-----------------------------------------------------------------------------
358 // "unmap_event" from m_widget
359 //-----------------------------------------------------------------------------
363 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
364 GdkEvent
* WXUNUSED(event
),
365 wxTopLevelWindow
*win
)
367 win
->SetIconizeState(true);
371 //-----------------------------------------------------------------------------
372 // "expose_event" of m_client
373 //-----------------------------------------------------------------------------
377 gtk_window_expose_callback( GtkWidget
*widget
,
378 GdkEventExpose
*gdk_event
,
381 GtkPizza
*pizza
= GTK_PIZZA(widget
);
383 gtk_paint_flat_box (win
->m_widget
->style
,
384 pizza
->bin_window
, GTK_STATE_NORMAL
,
395 // ----------------------------------------------------------------------------
396 // wxTopLevelWindowGTK itself
397 // ----------------------------------------------------------------------------
399 //-----------------------------------------------------------------------------
400 // InsertChild for wxTopLevelWindowGTK
401 //-----------------------------------------------------------------------------
403 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
404 * C++ has no virtual methods in a constructor. We have to emulate a
405 * virtual function here as wxWidgets requires different ways to insert
406 * a child in container classes. */
408 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK
* parent
, wxWindow
* child
)
410 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
412 if (!parent
->m_insertInClientArea
)
414 // these are outside the client area
415 wxTopLevelWindowGTK
* frame
= (wxTopLevelWindowGTK
*) parent
;
416 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
417 GTK_WIDGET(child
->m_widget
),
425 // these are inside the client area
426 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
427 GTK_WIDGET(child
->m_widget
),
435 // ----------------------------------------------------------------------------
436 // wxTopLevelWindowGTK creation
437 // ----------------------------------------------------------------------------
439 void wxTopLevelWindowGTK::Init()
444 m_mainWidget
= (GtkWidget
*) NULL
;
445 m_insertInClientArea
= true;
446 m_isIconized
= false;
447 m_fsIsShowing
= false;
449 m_themeEnabled
= true;
450 m_gdkDecor
= m_gdkFunc
= 0;
456 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
458 const wxString
& title
,
460 const wxSize
& sizeOrig
,
462 const wxString
&name
)
464 // always create a frame of some reasonable, even if arbitrary, size (at
465 // least for MSW compatibility)
466 wxSize size
= sizeOrig
;
467 size
.x
= WidthDefault(size
.x
);
468 size
.y
= HeightDefault(size
.y
);
470 wxTopLevelWindows
.Append( this );
472 m_needParent
= false;
474 if (!PreCreation( parent
, pos
, size
) ||
475 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
477 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
483 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInTopLevelWindow
;
485 // NB: m_widget may be !=NULL if it was created by derived class' Create,
486 // e.g. in wxTaskBarIconAreaGTK
487 if (m_widget
== NULL
)
489 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
491 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
492 // Tell WM that this is a dialog window and make it center
493 // on parent by default (this is what GtkDialog ctor does):
494 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
495 GDK_WINDOW_TYPE_HINT_DIALOG
);
496 gtk_window_set_position(GTK_WINDOW(m_widget
),
497 GTK_WIN_POS_CENTER_ON_PARENT
);
501 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
502 #if GTK_CHECK_VERSION(2,1,0)
503 if (!gtk_check_version(2,1,0))
505 if (style
& wxFRAME_TOOL_WINDOW
)
507 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
508 GDK_WINDOW_TYPE_HINT_UTILITY
);
510 // On some WMs, like KDE, a TOOL_WINDOW will still show
511 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
512 // For consistency between WMs and with Windows, we
513 // should set the NO_TASKBAR flag which will apply
514 // the set_skip_taskbar_hint if it is available,
515 // ensuring no taskbar entry will appear.
516 style
|= wxFRAME_NO_TASKBAR
;
523 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
524 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
525 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
526 (style
& wxFRAME_FLOAT_ON_PARENT
)))
528 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
529 GTK_WINDOW(topParent
->m_widget
) );
532 #if GTK_CHECK_VERSION(2,2,0)
533 if (!gtk_check_version(2,2,0))
535 if (style
& wxFRAME_NO_TASKBAR
)
537 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
543 if (!gtk_check_version(2,4,0))
545 if (style
& wxSTAY_ON_TOP
)
547 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
554 gtk_window_set_role( GTK_WINDOW(m_widget
), wxGTK_CONV( name
) );
557 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
558 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
560 g_signal_connect (m_widget
, "delete_event",
561 G_CALLBACK (gtk_frame_delete_callback
), this);
563 // m_mainWidget holds the toolbar, the menubar and the client area
564 m_mainWidget
= gtk_pizza_new();
565 gtk_widget_show( m_mainWidget
);
566 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
567 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
569 if (m_miniEdge
== 0) // wxMiniFrame has its own version.
571 // For m_mainWidget themes
572 g_signal_connect (m_mainWidget
, "expose_event",
573 G_CALLBACK (gtk_window_expose_callback
), this);
576 // m_wxwindow only represents the client area without toolbar and menubar
577 m_wxwindow
= gtk_pizza_new();
578 gtk_widget_show( m_wxwindow
);
579 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
581 // we donm't allow the frame to get the focus as otherwise
582 // the frame will grab it at arbitrary focus changes
583 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
585 if (m_parent
) m_parent
->AddChild( this );
587 // the user resized the frame by dragging etc.
588 g_signal_connect (m_widget
, "size_allocate",
589 G_CALLBACK (gtk_frame_size_callback
), this);
591 g_signal_connect (m_widget
, "size_request",
592 G_CALLBACK (wxgtk_tlw_size_request_callback
), this);
595 if ((m_x
!= -1) || (m_y
!= -1))
596 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
598 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
600 // we cannot set MWM hints and icons before the widget has
601 // been realized, so we do this directly after realization
602 g_signal_connect (m_widget
, "realize",
603 G_CALLBACK (gtk_frame_realized_callback
), this);
605 // map and unmap for iconized state
606 g_signal_connect (m_widget
, "map_event",
607 G_CALLBACK (gtk_frame_map_callback
), this);
608 g_signal_connect (m_widget
, "unmap_event",
609 G_CALLBACK (gtk_frame_unmap_callback
), this);
611 // the only way to get the window size is to connect to this event
612 g_signal_connect (m_widget
, "configure_event",
613 G_CALLBACK (gtk_frame_configure_callback
), this);
616 g_signal_connect_after (m_widget
, "focus_in_event",
617 G_CALLBACK (gtk_frame_focus_in_callback
), this);
618 g_signal_connect_after (m_widget
, "focus_out_event",
619 G_CALLBACK (gtk_frame_focus_out_callback
), this);
622 if ((style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
633 if ((style
& wxRESIZE_BORDER
) != 0)
634 m_gdkFunc
|= GDK_FUNC_RESIZE
;
638 m_gdkDecor
= (long) GDK_DECOR_BORDER
;
639 m_gdkFunc
= (long) GDK_FUNC_MOVE
;
641 // All this is for Motif Window Manager "hints" and is supposed to be
642 // recognized by other WMs as well.
643 if ((style
& wxCAPTION
) != 0)
645 m_gdkDecor
|= GDK_DECOR_TITLE
;
647 if ((style
& wxCLOSE_BOX
) != 0)
649 m_gdkFunc
|= GDK_FUNC_CLOSE
;
651 if ((style
& wxSYSTEM_MENU
) != 0)
653 m_gdkDecor
|= GDK_DECOR_MENU
;
655 if ((style
& wxMINIMIZE_BOX
) != 0)
657 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
658 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
660 if ((style
& wxMAXIMIZE_BOX
) != 0)
662 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
663 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
665 if ((style
& wxRESIZE_BORDER
) != 0)
667 m_gdkFunc
|= GDK_FUNC_RESIZE
;
668 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
675 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
679 wxFAIL_MSG(_T("Window still grabbed"));
683 m_isBeingDeleted
= true;
685 // it may also be GtkScrolledWindow in the case of an MDI child
686 if (GTK_IS_WINDOW(m_widget
))
688 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
691 if (g_activeFrame
== this)
692 g_activeFrame
= NULL
;
693 if (g_lastActiveFrame
== this)
694 g_lastActiveFrame
= NULL
;
697 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable
)
700 m_gdkFunc
|= GDK_FUNC_CLOSE
;
702 m_gdkFunc
&= ~GDK_FUNC_CLOSE
;
704 if (GTK_WIDGET_REALIZED(m_widget
) && (m_widget
->window
))
705 gdk_window_set_functions( m_widget
->window
, (GdkWMFunction
)m_gdkFunc
);
710 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long style
)
712 if (show
== m_fsIsShowing
)
713 return false; // return what?
715 m_fsIsShowing
= show
;
717 wxX11FullScreenMethod method
=
718 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
719 (WXWindow
)GDK_ROOT_WINDOW());
721 #if GTK_CHECK_VERSION(2,2,0)
722 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
723 // to switch to fullscreen, which is not always available. We must
724 // check if WM supports the spec and use legacy methods if it
726 if ( (method
== wxX11_FS_WMSPEC
) && !gtk_check_version(2,2,0) )
730 m_fsSaveFlag
= style
;
731 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
736 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
740 #endif // GTK+ >= 2.2.0
742 GdkWindow
*window
= m_widget
->window
;
746 m_fsSaveFlag
= style
;
747 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
748 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
750 int screen_width
,screen_height
;
751 wxDisplaySize( &screen_width
, &screen_height
);
753 gint client_x
, client_y
, root_x
, root_y
;
756 if (method
!= wxX11_FS_WMSPEC
)
758 // don't do it always, Metacity hates it
759 m_fsSaveGdkFunc
= m_gdkFunc
;
760 m_fsSaveGdkDecor
= m_gdkDecor
;
761 m_gdkFunc
= m_gdkDecor
= 0;
762 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
763 gdk_window_set_functions(window
, (GdkWMFunction
)0);
766 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
767 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
768 &width
, &height
, NULL
);
770 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
771 screen_width
+ 1, screen_height
+ 1);
773 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
774 (WXWindow
)GDK_ROOT_WINDOW(),
775 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
776 show
, &m_fsSaveFrame
, method
);
781 if (method
!= wxX11_FS_WMSPEC
)
783 // don't do it always, Metacity hates it
784 m_gdkFunc
= m_fsSaveGdkFunc
;
785 m_gdkDecor
= m_fsSaveGdkDecor
;
786 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
787 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
790 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
791 (WXWindow
)GDK_ROOT_WINDOW(),
792 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
793 show
, &m_fsSaveFrame
, method
);
795 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
796 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
800 // documented behaviour is to show the window if it's still hidden when
801 // showing it full screen
802 if ( show
&& !IsShown() )
808 // ----------------------------------------------------------------------------
809 // overridden wxWindow methods
810 // ----------------------------------------------------------------------------
812 bool wxTopLevelWindowGTK::Show( bool show
)
814 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
816 if (show
== IsShown())
819 if (show
&& !m_sizeSet
)
821 /* by calling GtkOnSize here, we don't have to call
822 either after showing the frame, which would entail
823 much ugly flicker or from within the size_allocate
824 handler, because GTK 1.1.X forbids that. */
829 // This seems no longer to be needed and the call
830 // itself is deprecated.
833 // gtk_widget_set_uposition( m_widget, m_x, m_y );
835 return wxWindow::Show( show
);
838 void wxTopLevelWindowGTK::Raise()
840 gtk_window_present( GTK_WINDOW( m_widget
) );
843 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
845 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
848 // ----------------------------------------------------------------------------
850 // ----------------------------------------------------------------------------
852 void wxTopLevelWindowGTK::GTKDoGetSize(int *width
, int *height
) const
854 return wxTopLevelWindowBase::DoGetSize(width
, height
);
857 void wxTopLevelWindowGTK::GTKDoSetSize(int width
, int height
)
864 int old_width
= m_width
;
865 int old_height
= m_height
;
872 // GPE's window manager doesn't like size hints at all, esp. when the user
873 // has to use the virtual keyboard, so don't constrain size there
875 int minWidth
= GetMinWidth(),
876 minHeight
= GetMinHeight(),
877 maxWidth
= GetMaxWidth(),
878 maxHeight
= GetMaxHeight();
880 if ( minWidth
!= -1 && m_width
< minWidth
)
882 if ( minHeight
!= -1 && m_height
< minHeight
)
883 m_height
= minHeight
;
884 if ( maxWidth
!= -1 && m_width
> maxWidth
)
886 if ( maxHeight
!= -1 && m_height
> maxHeight
)
887 m_height
= maxHeight
;
890 if ( m_width
!= old_width
|| m_height
!= old_height
)
892 gtk_window_resize( GTK_WINDOW(m_widget
), m_width
, m_height
);
894 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
895 done either directly before the frame is shown or in idle time
896 so that different calls to SetSize() don't lead to flicker. */
903 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
905 wxCHECK_RET( m_widget
, wxT("invalid frame") );
907 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
908 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
911 // deal with the position first
915 if ( !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
917 // -1 means "use existing" unless the flag above is specified
923 else // wxSIZE_ALLOW_MINUS_ONE
929 if ( m_x
!= old_x
|| m_y
!= old_y
)
931 gtk_window_move( GTK_WINDOW(m_widget
), m_x
, m_y
);
935 // and now change the size: as we want to set the size of the entire
936 // window, including decorations, we must adjust the size passed to
937 // GTKDoSetSize() which takes with the size of undecorated frame only
938 if ( width
!= -1 || height
!= -1 )
942 DoGetSize(&wTotal
, &hTotal
);
946 GTKDoGetSize(&wUndec
, &hUndec
);
949 width
-= wTotal
- wUndec
;
951 height
-= hTotal
- hUndec
;
954 GTKDoSetSize(width
, height
);
957 void wxTopLevelWindowGTK::DoGetSize(int *width
, int *height
) const
959 wxCHECK_RET( m_widget
, wxT("invalid frame") );
961 if ( !m_widget
->window
)
963 // this can happen if we're called before the window is realized, so
964 // don't assert but just return the stored values
965 GTKDoGetSize(width
, height
);
970 gdk_window_get_frame_extents(m_widget
->window
, &rect
);
975 *height
= rect
.height
;
978 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
982 // for consistency with wxMSW, client area is supposed to be empty for
983 // the iconized windows
992 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
996 *height
= m_height
- 2 * m_miniEdge
- m_miniTitle
;
1002 *width
= m_width
- 2 * m_miniEdge
;
1008 void wxTopLevelWindowGTK::DoSetClientSize( int width
, int height
)
1010 GTKDoSetSize(width
+ m_miniEdge
*2, height
+ m_miniEdge
*2 + m_miniTitle
);
1013 void wxTopLevelWindowGTK::DoSetSizeHints( int minW
, int minH
,
1015 int incW
, int incH
)
1017 wxTopLevelWindowBase::DoSetSizeHints( minW
, minH
, maxW
, maxH
, incW
, incH
);
1019 const wxSize minSize
= GetMinSize();
1020 const wxSize maxSize
= GetMaxSize();
1023 if (minSize
.x
> 0 || minSize
.y
> 0)
1025 hints_mask
|= GDK_HINT_MIN_SIZE
;
1026 hints
.min_width
= minSize
.x
> 0 ? minSize
.x
: 0;
1027 hints
.min_height
= minSize
.y
> 0 ? minSize
.y
: 0;
1029 if (maxSize
.x
> 0 || maxSize
.y
> 0)
1031 hints_mask
|= GDK_HINT_MAX_SIZE
;
1032 hints
.max_width
= maxSize
.x
> 0 ? maxSize
.x
: INT_MAX
;
1033 hints
.max_height
= maxSize
.y
> 0 ? maxSize
.y
: INT_MAX
;
1035 if (incW
> 0 || incH
> 0)
1037 hints_mask
|= GDK_HINT_RESIZE_INC
;
1038 hints
.width_inc
= incW
> 0 ? incW
: 1;
1039 hints
.height_inc
= incH
> 0 ? incH
: 1;
1041 gtk_window_set_geometry_hints(
1042 (GtkWindow
*)m_widget
, NULL
, &hints
, (GdkWindowHints
)hints_mask
);
1046 void wxTopLevelWindowGTK::GtkOnSize()
1049 if (m_resizing
) return;
1052 if ( m_wxwindow
== NULL
) return;
1054 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1055 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1056 set in wxFrame::Create so it is used to check what kind of frame we
1057 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1058 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1059 importantly) m_mainWidget */
1061 int minWidth
= GetMinWidth(),
1062 minHeight
= GetMinHeight(),
1063 maxWidth
= GetMaxWidth(),
1064 maxHeight
= GetMaxHeight();
1067 // GPE's window manager doesn't like size hints
1068 // at all, esp. when the user has to use the
1069 // virtual keyboard.
1076 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
1077 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
1078 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
1079 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
1083 // m_mainWidget holds the menubar, the toolbar and the client area,
1084 // which is represented by m_wxwindow.
1085 int client_x
= m_miniEdge
;
1086 int client_y
= m_miniEdge
+ m_miniTitle
;
1087 int client_w
= m_width
- 2*m_miniEdge
;
1088 int client_h
= m_height
- 2*m_miniEdge
- m_miniTitle
;
1094 // Let the parent perform the resize
1095 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
1097 client_x
, client_y
, client_w
, client_h
);
1101 // If there is no m_mainWidget between m_widget and m_wxwindow there
1102 // is no need to set the size or position of m_wxwindow.
1107 // send size event to frame
1108 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1109 event
.SetEventObject( this );
1110 GetEventHandler()->ProcessEvent( event
);
1115 void wxTopLevelWindowGTK::OnInternalIdle()
1117 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
1121 // we'll come back later
1123 wxapp_install_idle_handler();
1127 // set the focus if not done yet and if we can already do it
1128 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
1130 if ( g_delayedFocus
&&
1131 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
1133 wxLogTrace(_T("focus"),
1134 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1135 g_delayedFocus
->GetClassInfo()->GetClassName(),
1136 g_delayedFocus
->GetLabel().c_str());
1138 g_delayedFocus
->SetFocus();
1139 g_delayedFocus
= NULL
;
1143 wxWindow::OnInternalIdle();
1145 // Synthetize activate events.
1146 if ( g_sendActivateEvent
!= -1 )
1148 bool activate
= g_sendActivateEvent
!= 0;
1150 // if (!activate) wxPrintf( wxT("de") );
1151 // wxPrintf( wxT("activate\n") );
1154 g_sendActivateEvent
= -1;
1156 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1160 // ----------------------------------------------------------------------------
1162 // ----------------------------------------------------------------------------
1164 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1166 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1168 if ( title
== m_title
)
1173 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1176 void wxTopLevelWindowGTK::SetIcon( const wxIcon
&icon
)
1178 SetIcons( wxIconBundle( icon
) );
1181 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1183 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1185 wxTopLevelWindowBase::SetIcons( icons
);
1188 size_t max
= icons
.m_icons
.GetCount();
1190 for (size_t i
= 0; i
< max
; i
++)
1192 if (icons
.m_icons
[i
].Ok())
1194 list
= g_list_prepend(list
, icons
.m_icons
[i
].GetPixbuf());
1197 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1201 // ----------------------------------------------------------------------------
1202 // frame state: maximized/iconized/normal
1203 // ----------------------------------------------------------------------------
1205 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1208 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1210 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1213 bool wxTopLevelWindowGTK::IsMaximized() const
1215 if(!m_widget
->window
)
1218 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1221 void wxTopLevelWindowGTK::Restore()
1223 // "Present" seems similar enough to "restore"
1224 gtk_window_present( GTK_WINDOW( m_widget
) );
1227 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1230 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1232 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1235 bool wxTopLevelWindowGTK::IsIconized() const
1237 return m_isIconized
;
1240 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1242 if ( iconize
!= m_isIconized
)
1244 m_isIconized
= iconize
;
1245 (void)SendIconizeEvent(iconize
);
1249 void wxTopLevelWindowGTK::AddGrab()
1254 gtk_grab_add( m_widget
);
1255 wxEventLoop().Run();
1256 gtk_grab_remove( m_widget
);
1260 void wxTopLevelWindowGTK::RemoveGrab()
1271 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1275 if (region
.IsEmpty())
1277 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1281 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1289 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1291 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1292 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1294 GdkWindow
*window
= NULL
;
1297 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1298 do_shape_combine_region(window
, region
);
1300 window
= m_widget
->window
;
1301 return do_shape_combine_region(window
, region
);
1304 bool wxTopLevelWindowGTK::IsActive()
1306 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1309 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1311 bool new_hint_value
= false;
1313 // FIXME: This is a workaround to focus handling problem
1314 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1315 // yet been processed, and the internal focus system is not up to date yet.
1316 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1317 ::wxYieldIfNeeded();
1319 if(m_urgency_hint
>= 0)
1320 g_source_remove(m_urgency_hint
);
1322 m_urgency_hint
= -2;
1324 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1326 new_hint_value
= true;
1328 if (flags
& wxUSER_ATTENTION_INFO
)
1330 m_urgency_hint
= g_timeout_add(5000, (GSourceFunc
)gtk_frame_urgency_timer_callback
, this);
1332 m_urgency_hint
= -1;
1336 #if GTK_CHECK_VERSION(2,7,0)
1337 if(!gtk_check_version(2,7,0))
1338 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1341 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1344 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style
)
1346 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1347 // Store which styles were changed
1348 long styleChanges
= style
^ m_windowStyle
;
1351 // Process wxWindow styles. This also updates the internal variable
1352 // Therefore m_windowStyle bits carry now the _new_ style values
1353 wxWindow::SetWindowStyleFlag(style
);
1355 // just return for now if widget does not exist yet
1360 if ( (styleChanges
& wxSTAY_ON_TOP
) && !gtk_check_version(2,4,0) )
1361 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), m_windowStyle
& wxSTAY_ON_TOP
);
1363 #if GTK_CHECK_VERSION(2,2,0)
1364 if ( (styleChanges
& wxFRAME_NO_TASKBAR
) && !gtk_check_version(2,2,0) )
1366 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), m_windowStyle
& wxFRAME_NO_TASKBAR
);
1371 #include <X11/Xlib.h>
1373 /* Get the X Window between child and the root window.
1374 This should usually be the WM managed XID */
1375 static Window
wxGetTopmostWindowX11(Display
*dpy
, Window child
)
1377 Window root
, parent
;
1379 unsigned int nchildren
;
1381 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1384 while (parent
!= root
) {
1386 XQueryTree(dpy
, child
, &root
, &parent
, &children
, &nchildren
);
1393 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha
)
1395 if (!m_widget
|| !m_widget
->window
)
1398 Display
* dpy
= GDK_WINDOW_XDISPLAY (m_widget
->window
);
1399 // We need to get the X Window that has the root window as the immediate parent
1400 // and m_widget->window as a child. This should be the X Window that the WM manages and
1401 // from which the opacity property is checked from.
1402 Window win
= wxGetTopmostWindowX11(dpy
, GDK_WINDOW_XID (m_widget
->window
));
1404 unsigned int opacity
= alpha
* 0x1010101;
1406 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1408 XDeleteProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
));
1410 XChangeProperty(dpy
, win
, XInternAtom(dpy
, "_NET_WM_WINDOW_OPACITY", False
),
1411 XA_CARDINAL
, 32, PropModeReplace
,
1412 (unsigned char *) &opacity
, 1L);
1417 bool wxTopLevelWindowGTK::CanSetTransparent()
1419 // allow to override automatic detection as it's far from perfect
1420 static const wxChar
*SYSOPT_TRANSPARENT
= wxT("gtk.tlw.can-set-transparent");
1421 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT
) )
1423 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT
) != 0;
1426 #if GTK_CHECK_VERSION(2,10,0)
1427 if (!gtk_check_version(2,10,0))
1429 return (gtk_widget_is_composited (m_widget
));
1432 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1437 #if 0 // Don't be optimistic here for the sake of wxAUI
1438 int opcode
, event
, error
;
1439 // Check for the existence of a RGBA visual instead?
1440 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1441 "Composite", &opcode
, &event
, &error
);