1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
19 #pragma implementation "toplevel.h"
22 // For compilers that support precompilation, includes "wx.h".
23 #include "wx/wxprec.h"
26 #define XIconifyWindow XICONIFYWINDOW
31 #include "wx/toplevel.h"
33 #include "wx/dialog.h"
34 #include "wx/control.h"
36 #include "wx/dcclient.h"
37 #include "wx/gtk/private.h"
39 #include "wx/settings.h"
40 #include "wx/evtloop.h"
45 #include <gdk/gdkkeysyms.h>
48 #include "wx/gtk/win_gtk.h"
50 #include "wx/unix/utilsx11.h"
53 #include <X11/Xatom.h>
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 extern void wxapp_install_idle_handler();
62 // ----------------------------------------------------------------------------
64 // ----------------------------------------------------------------------------
66 extern wxList wxPendingDelete
;
68 extern int g_openDialogs
;
69 extern wxWindowGTK
*g_delayedFocus
;
71 // the frame that is currently active (i.e. its child has focus). It is
72 // used to generate wxActivateEvents
73 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
74 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
76 // if we detect that the app has got/lost the focus, we set this variable to
77 // either TRUE or FALSE and an activate event will be sent during the next
78 // OnIdle() call and it is reset to -1: this value means that we shouldn't
79 // send any activate events at all
80 static int g_sendActivateEvent
= -1;
82 //-----------------------------------------------------------------------------
83 // RequestUserAttention related functions
84 //-----------------------------------------------------------------------------
87 static void wxgtk_window_set_urgency_hint (GtkWindow
*win
,
90 wxASSERT_MSG( GTK_WIDGET_REALIZED(win
), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
91 GdkWindow
*window
= GTK_WIDGET(win
)->window
;
94 wm_hints
= XGetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
));
97 wm_hints
= XAllocWMHints();
100 wm_hints
->flags
|= XUrgencyHint
;
102 wm_hints
->flags
&= ~XUrgencyHint
;
104 XSetWMHints(GDK_WINDOW_XDISPLAY(window
), GDK_WINDOW_XWINDOW(window
), wm_hints
);
108 static gint
gtk_frame_urgency_timer_callback( GtkWidget
*win
)
110 #if __WXGTK20__ && GTK_CHECK_VERSION(2,7,0)
111 if(!gtk_check_version(2,7,0))
112 gtk_window_set_urgency_hint(GTK_WINDOW( win
), FALSE
);
115 wxgtk_window_set_urgency_hint(GTK_WINDOW( win
), FALSE
);
117 //BCI: argument from GtkWidget* to wxTopLevelWindowGTK* && win->m_urgency_hint = -2;
118 gtk_object_set_data(GTK_OBJECT(win
), "m_urgency_hint", GINT_TO_POINTER(-2));
123 //-----------------------------------------------------------------------------
125 //-----------------------------------------------------------------------------
128 static gint
gtk_frame_focus_in_callback( GtkWidget
*widget
,
129 GdkEvent
*WXUNUSED(event
),
130 wxTopLevelWindowGTK
*win
)
133 wxapp_install_idle_handler();
135 switch ( g_sendActivateEvent
)
138 // we've got focus from outside, synthetize wxActivateEvent
139 g_sendActivateEvent
= 1;
143 // another our window just lost focus, it was already ours before
144 // - don't send any wxActivateEvent
145 g_sendActivateEvent
= -1;
150 g_lastActiveFrame
= g_activeFrame
;
152 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
154 // MR: wxRequestUserAttention related block
155 //BCI: switch(win->m_urgency_hint)
156 switch( GPOINTER_TO_INT(gtk_object_get_data( GTK_OBJECT(widget
), "m_urgency_hint") ) )
160 gtk_timeout_remove( GPOINTER_TO_INT(gtk_object_get_data( GTK_OBJECT(widget
), "m_urgency_hint") ) );
161 // no break, fallthrough to remove hint too
163 #if __WXGTK20__ && GTK_CHECK_VERSION(2,7,0)
164 if(!gtk_check_version(2,7,0))
165 gtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
169 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget
), FALSE
);
172 //BCI: win->m_urgency_hint = -2;
173 gtk_object_set_data( GTK_OBJECT(widget
), "m_urgency_hint", GINT_TO_POINTER(-2) );
179 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
180 wxActivateEvent
event(wxEVT_ACTIVATE
, true, g_activeFrame
->GetId());
181 event
.SetEventObject(g_activeFrame
);
182 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
188 //-----------------------------------------------------------------------------
190 //-----------------------------------------------------------------------------
193 static gint
gtk_frame_focus_out_callback( GtkWidget
*widget
,
194 GdkEventFocus
*WXUNUSED(gdk_event
),
195 wxTopLevelWindowGTK
*win
)
198 wxapp_install_idle_handler();
200 // if the focus goes out of our app alltogether, OnIdle() will send
201 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
202 // g_sendActivateEvent to -1
203 g_sendActivateEvent
= 0;
205 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
207 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
211 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
212 wxActivateEvent
event(wxEVT_ACTIVATE
, false, g_activeFrame
->GetId());
213 event
.SetEventObject(g_activeFrame
);
214 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
216 g_activeFrame
= NULL
;
223 //-----------------------------------------------------------------------------
224 // "focus" from m_window
225 //-----------------------------------------------------------------------------
228 static gint
gtk_frame_focus_callback( GtkWidget
*widget
, GtkDirectionType
WXUNUSED(d
), wxWindow
*WXUNUSED(win
) )
231 wxapp_install_idle_handler();
233 // This disables GTK's tab traversal
234 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus" );
239 //-----------------------------------------------------------------------------
241 //-----------------------------------------------------------------------------
244 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
247 wxapp_install_idle_handler();
252 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
255 wxPrintf( "OnSize from " );
256 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
257 wxPrintf( win->GetClassInfo()->GetClassName() );
258 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
261 (int)alloc->height );
264 win
->m_width
= alloc
->width
;
265 win
->m_height
= alloc
->height
;
266 win
->GtkUpdateSize();
271 //-----------------------------------------------------------------------------
273 //-----------------------------------------------------------------------------
276 static gint
gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
), GdkEvent
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
279 wxapp_install_idle_handler();
281 if (win
->IsEnabled() &&
282 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
291 //-----------------------------------------------------------------------------
293 //-----------------------------------------------------------------------------
297 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
), GdkEventConfigure
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
300 wxapp_install_idle_handler();
302 if (!win
->m_hasVMT
|| !win
->IsShown())
308 gdk_window_get_root_origin( win
->m_widget
->window
, &x
, &y
);
312 wxMoveEvent
mevent( wxPoint(win
->m_x
,win
->m_y
), win
->GetId() );
313 mevent
.SetEventObject( win
);
314 win
->GetEventHandler()->ProcessEvent( mevent
);
320 //-----------------------------------------------------------------------------
321 // "realize" from m_widget
322 //-----------------------------------------------------------------------------
324 // we cannot MWM hints and icons before the widget has been realized,
325 // so we do this directly after realization
329 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
330 wxTopLevelWindowGTK
*win
)
333 wxapp_install_idle_handler();
335 // All this is for Motif Window Manager "hints" and is supposed to be
336 // recognized by other WM as well. Not tested.
337 gdk_window_set_decorations(win
->m_widget
->window
,
338 (GdkWMDecoration
)win
->m_gdkDecor
);
339 gdk_window_set_functions(win
->m_widget
->window
,
340 (GdkWMFunction
)win
->m_gdkFunc
);
342 // GTK's shrinking/growing policy
343 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
344 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 0, 0, 1);
346 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
349 wxIconBundle iconsOld
= win
->GetIcons();
350 if ( iconsOld
.GetIcon(-1).Ok() )
352 win
->SetIcon( wxNullIcon
);
353 win
->SetIcons( iconsOld
);
358 //-----------------------------------------------------------------------------
359 // "map_event" from m_widget
360 //-----------------------------------------------------------------------------
364 gtk_frame_map_callback( GtkWidget
* WXUNUSED(widget
),
365 GdkEvent
* WXUNUSED(event
),
366 wxTopLevelWindow
*win
)
368 win
->SetIconizeState(false);
372 //-----------------------------------------------------------------------------
373 // "unmap_event" from m_widget
374 //-----------------------------------------------------------------------------
378 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
379 GdkEvent
* WXUNUSED(event
),
380 wxTopLevelWindow
*win
)
382 win
->SetIconizeState(TRUE
);
386 //-----------------------------------------------------------------------------
387 // "expose_event" of m_client
388 //-----------------------------------------------------------------------------
391 static int gtk_window_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
393 GtkPizza
*pizza
= GTK_PIZZA(widget
);
395 gtk_paint_flat_box (win
->m_widget
->style
,
396 pizza
->bin_window
, GTK_STATE_NORMAL
,
407 //-----------------------------------------------------------------------------
408 // "draw" of m_client
409 //-----------------------------------------------------------------------------
414 static void gtk_window_draw_callback( GtkWidget
*widget
, GdkRectangle
*rect
, wxWindow
*win
)
416 GtkPizza
*pizza
= GTK_PIZZA(widget
);
418 gtk_paint_flat_box (win
->m_widget
->style
,
419 pizza
->bin_window
, GTK_STATE_NORMAL
,
430 // ----------------------------------------------------------------------------
431 // wxTopLevelWindowGTK itself
432 // ----------------------------------------------------------------------------
434 //-----------------------------------------------------------------------------
435 // InsertChild for wxTopLevelWindowGTK
436 //-----------------------------------------------------------------------------
438 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
439 * C++ has no virtual methods in a constructor. We have to emulate a
440 * virtual function here as wxWidgets requires different ways to insert
441 * a child in container classes. */
443 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK
* parent
, wxWindow
* child
)
445 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
447 if (!parent
->m_insertInClientArea
)
449 // these are outside the client area
450 wxTopLevelWindowGTK
* frame
= (wxTopLevelWindowGTK
*) parent
;
451 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
452 GTK_WIDGET(child
->m_widget
),
460 // these are inside the client area
461 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
462 GTK_WIDGET(child
->m_widget
),
469 // resize on OnInternalIdle
470 parent
->GtkUpdateSize();
473 // ----------------------------------------------------------------------------
474 // wxTopLevelWindowGTK creation
475 // ----------------------------------------------------------------------------
477 void wxTopLevelWindowGTK::Init()
482 m_mainWidget
= (GtkWidget
*) NULL
;
483 m_insertInClientArea
= true;
484 m_isIconized
= false;
485 m_fsIsShowing
= false;
486 m_themeEnabled
= true;
487 m_gdkDecor
= m_gdkFunc
= 0;
490 //BCI: header wx/gtk/toplevel.h:
491 // private gtk_timeout_add result for mimicing wxUSER_ATTENTION_INFO and
492 // wxUSER_ATTENTION_ERROR difference, -2 for no hint, -1 for ERROR hint, rest for GtkTimeout handle.
493 // int m_urgency_hint;
495 //BCI: m_urgency_hint = -2;
498 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
500 const wxString
& title
,
502 const wxSize
& sizeOrig
,
504 const wxString
&name
)
506 // always create a frame of some reasonable, even if arbitrary, size (at
507 // least for MSW compatibility)
508 wxSize size
= sizeOrig
;
509 size
.x
= WidthDefault(size
.x
);
510 size
.y
= HeightDefault(size
.y
);
512 wxTopLevelWindows
.Append( this );
514 m_needParent
= false;
516 if (!PreCreation( parent
, pos
, size
) ||
517 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
519 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
525 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInTopLevelWindow
;
527 // NB: m_widget may be !=NULL if it was created by derived class' Create,
528 // e.g. in wxTaskBarIconAreaGTK
529 if (m_widget
== NULL
)
531 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
534 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
535 // Tell WM that this is a dialog window and make it center
536 // on parent by default (this is what GtkDialog ctor does):
537 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
538 GDK_WINDOW_TYPE_HINT_DIALOG
);
539 gtk_window_set_position(GTK_WINDOW(m_widget
),
540 GTK_WIN_POS_CENTER_ON_PARENT
);
542 m_widget
= gtk_window_new(GTK_WINDOW_DIALOG
);
547 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
548 #if GTK_CHECK_VERSION(2,1,0)
549 if (!gtk_check_version(2,1,0))
551 if (style
& wxFRAME_TOOL_WINDOW
)
553 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
554 GDK_WINDOW_TYPE_HINT_UTILITY
);
556 // On some WMs, like KDE, a TOOL_WINDOW will still show
557 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
558 // For consistency between WMs and with Windows, we
559 // should set the NO_TASKBAR flag which will apply
560 // the set_skip_taskbar_hint if it is available,
561 // ensuring no taskbar entry will appear.
562 style
|= wxFRAME_NO_TASKBAR
;
570 gtk_object_set_data( GTK_OBJECT(m_widget
), "m_urgency_hint", GINT_TO_POINTER(-2) );
572 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
573 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
574 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
575 (style
& wxFRAME_FLOAT_ON_PARENT
)))
577 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
578 GTK_WINDOW(topParent
->m_widget
) );
581 #if GTK_CHECK_VERSION(2,2,0)
582 if (!gtk_check_version(2,2,0))
584 if (style
& wxFRAME_NO_TASKBAR
)
586 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
591 #if GTK_CHECK_VERSION(2,4,0)
592 if (!gtk_check_version(2,4,0))
594 if (style
& wxSTAY_ON_TOP
)
596 gtk_window_set_keep_above(GTK_WINDOW(m_widget
), TRUE
);
602 gtk_window_set_wmclass( GTK_WINDOW(m_widget
), wxGTK_CONV( name
), wxGTK_CONV( name
) );
604 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
605 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
607 gtk_signal_connect( GTK_OBJECT(m_widget
), "delete_event",
608 GTK_SIGNAL_FUNC(gtk_frame_delete_callback
), (gpointer
)this );
610 // m_mainWidget holds the toolbar, the menubar and the client area
611 m_mainWidget
= gtk_pizza_new();
612 gtk_widget_show( m_mainWidget
);
613 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
614 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
616 if (m_miniEdge
== 0) // wxMiniFrame has its own version.
618 // For m_mainWidget themes
619 gtk_signal_connect( GTK_OBJECT(m_mainWidget
), "expose_event",
620 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
622 gtk_signal_connect( GTK_OBJECT(m_mainWidget
), "draw",
623 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
627 // m_wxwindow only represents the client area without toolbar and menubar
628 m_wxwindow
= gtk_pizza_new();
629 gtk_widget_show( m_wxwindow
);
630 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
632 // we donm't allow the frame to get the focus as otherwise
633 // the frame will grab it at arbitrary focus changes
634 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
636 if (m_parent
) m_parent
->AddChild( this );
638 // the user resized the frame by dragging etc.
639 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_allocate",
640 GTK_SIGNAL_FUNC(gtk_frame_size_callback
), (gpointer
)this );
644 if ((m_x
!= -1) || (m_y
!= -1))
645 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
647 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
649 // we cannot set MWM hints and icons before the widget has
650 // been realized, so we do this directly after realization
651 gtk_signal_connect( GTK_OBJECT(m_widget
), "realize",
652 GTK_SIGNAL_FUNC(gtk_frame_realized_callback
), (gpointer
) this );
654 // the only way to get the window size is to connect to this event
655 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
656 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
658 // map and unmap for iconized state
659 gtk_signal_connect( GTK_OBJECT(m_widget
), "map_event",
660 GTK_SIGNAL_FUNC(gtk_frame_map_callback
), (gpointer
)this );
661 gtk_signal_connect( GTK_OBJECT(m_widget
), "unmap_event",
662 GTK_SIGNAL_FUNC(gtk_frame_unmap_callback
), (gpointer
)this );
664 // the only way to get the window size is to connect to this event
665 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
666 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
668 // disable native tab traversal
669 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus",
670 GTK_SIGNAL_FUNC(gtk_frame_focus_callback
), (gpointer
)this );
673 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_in_event",
674 GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback
), (gpointer
)this );
675 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_out_event",
676 GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback
), (gpointer
)this );
679 if ((m_miniEdge
> 0) || (style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
686 m_gdkDecor
= (long) GDK_DECOR_BORDER
;
687 m_gdkFunc
= (long) GDK_FUNC_MOVE
;
689 // All this is for Motif Window Manager "hints" and is supposed to be
690 // recognized by other WMs as well.
691 if ((style
& wxCAPTION
) != 0)
693 m_gdkDecor
|= GDK_DECOR_TITLE
;
695 if ((style
& wxCLOSE_BOX
) != 0)
697 m_gdkFunc
|= GDK_FUNC_CLOSE
;
699 if ((style
& wxSYSTEM_MENU
) != 0)
701 m_gdkDecor
|= GDK_DECOR_MENU
;
703 if ((style
& wxMINIMIZE_BOX
) != 0)
705 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
706 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
708 if ((style
& wxMAXIMIZE_BOX
) != 0)
710 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
711 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
713 if ((style
& wxRESIZE_BORDER
) != 0)
715 m_gdkFunc
|= GDK_FUNC_RESIZE
;
716 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
723 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
727 wxASSERT_MSG( FALSE
, _T("Window still grabbed"));
731 m_isBeingDeleted
= true;
733 // it may also be GtkScrolledWindow in the case of an MDI child
734 if (GTK_IS_WINDOW(m_widget
))
736 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
739 if (g_activeFrame
== this)
740 g_activeFrame
= NULL
;
741 if (g_lastActiveFrame
== this)
742 g_lastActiveFrame
= NULL
;
747 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long style
)
749 if (show
== m_fsIsShowing
)
750 return false; // return what?
752 m_fsIsShowing
= show
;
754 wxX11FullScreenMethod method
=
755 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
756 (WXWindow
)GDK_ROOT_WINDOW());
758 #if GTK_CHECK_VERSION(2,2,0)
759 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
760 // to switch to fullscreen, which is not always available. We must
761 // check if WM supports the spec and use legacy methods if it
763 if ( (method
== wxX11_FS_WMSPEC
) && !gtk_check_version(2,2,0) )
766 gtk_window_fullscreen( GTK_WINDOW( m_widget
) );
768 gtk_window_unfullscreen( GTK_WINDOW( m_widget
) );
771 #endif // GTK+ >= 2.2.0
773 GdkWindow
*window
= m_widget
->window
;
777 m_fsSaveFlag
= style
;
778 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
779 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
781 int screen_width
,screen_height
;
782 wxDisplaySize( &screen_width
, &screen_height
);
784 gint client_x
, client_y
, root_x
, root_y
;
787 if (method
!= wxX11_FS_WMSPEC
)
789 // don't do it always, Metacity hates it
790 m_fsSaveGdkFunc
= m_gdkFunc
;
791 m_fsSaveGdkDecor
= m_gdkDecor
;
792 m_gdkFunc
= m_gdkDecor
= 0;
793 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
794 gdk_window_set_functions(window
, (GdkWMFunction
)0);
797 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
798 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
799 &width
, &height
, NULL
);
801 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
802 screen_width
+ 1, screen_height
+ 1);
804 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
805 (WXWindow
)GDK_ROOT_WINDOW(),
806 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
807 show
, &m_fsSaveFrame
, method
);
811 if (method
!= wxX11_FS_WMSPEC
)
813 // don't do it always, Metacity hates it
814 m_gdkFunc
= m_fsSaveGdkFunc
;
815 m_gdkDecor
= m_fsSaveGdkDecor
;
816 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
817 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
820 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
821 (WXWindow
)GDK_ROOT_WINDOW(),
822 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
823 show
, &m_fsSaveFrame
, method
);
825 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
826 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
830 // documented behaviour is to show the window if it's still hidden when
831 // showing it full screen
832 if ( show
&& !IsShown() )
838 // ----------------------------------------------------------------------------
839 // overridden wxWindow methods
840 // ----------------------------------------------------------------------------
842 bool wxTopLevelWindowGTK::Show( bool show
)
844 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
846 if (show
&& !m_sizeSet
)
848 /* by calling GtkOnSize here, we don't have to call
849 either after showing the frame, which would entail
850 much ugly flicker or from within the size_allocate
851 handler, because GTK 1.1.X forbids that. */
853 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
857 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
859 return wxWindow::Show( show
);
862 void wxTopLevelWindowGTK::Raise()
865 gtk_window_present( GTK_WINDOW( m_widget
) );
871 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
873 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
876 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
878 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
880 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
881 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
891 int old_width
= m_width
;
892 int old_height
= m_height
;
894 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
896 if (x
!= -1) m_x
= x
;
897 if (y
!= -1) m_y
= y
;
904 if (width
!= -1) m_width
= width
;
905 if (height
!= -1) m_height
= height
;
908 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
910 if (width == -1) m_width = 80;
913 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
915 if (height == -1) m_height = 26;
919 int minWidth
= GetMinWidth(),
920 minHeight
= GetMinHeight(),
921 maxWidth
= GetMaxWidth(),
922 maxHeight
= GetMaxHeight();
925 // GPE's window manager doesn't like size hints
926 // at all, esp. when the user has to use the
934 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
935 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
936 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
937 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
939 if ((m_x
!= -1) || (m_y
!= -1))
941 if ((m_x
!= old_x
) || (m_y
!= old_y
))
943 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
947 if ((m_width
!= old_width
) || (m_height
!= old_height
))
949 if (m_widget
->window
)
950 gdk_window_resize( m_widget
->window
, m_width
, m_height
);
952 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
954 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
955 done either directly before the frame is shown or in idle time
956 so that different calls to SetSize() don't lead to flicker. */
963 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
965 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
967 wxWindow::DoGetClientSize( width
, height
);
971 *height
-= m_miniEdge
*2 + m_miniTitle
;
975 *width
-= m_miniEdge
*2;
979 void wxTopLevelWindowGTK::DoSetClientSize( int width
, int height
)
981 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
984 width
+ m_miniEdge
*2, height
+ m_miniEdge
*2 + m_miniTitle
, 0);
987 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x
), int WXUNUSED(y
),
988 int width
, int height
)
990 // due to a bug in gtk, x,y are always 0
995 if (m_resizing
) return;
998 if ( m_wxwindow
== NULL
) return;
1003 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1004 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1005 set in wxFrame::Create so it is used to check what kind of frame we
1006 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1007 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1008 importantly) m_mainWidget */
1010 int minWidth
= GetMinWidth(),
1011 minHeight
= GetMinHeight(),
1012 maxWidth
= GetMaxWidth(),
1013 maxHeight
= GetMaxHeight();
1016 // GPE's window manager doesn't like size hints
1017 // at all, esp. when the user has to use the
1018 // virtual keyboard.
1025 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
1026 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
1027 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
1028 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
1033 gint flag
= 0; // GDK_HINT_POS;
1036 if ((minWidth
!= -1) || (minHeight
!= -1)) flag
|= GDK_HINT_MIN_SIZE
;
1037 if ((maxWidth
!= -1) || (maxHeight
!= -1)) flag
|= GDK_HINT_MAX_SIZE
;
1039 geom
.min_width
= minWidth
;
1040 geom
.min_height
= minHeight
;
1042 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
1043 // maxHeight or maxWidth is set, we must set them both, else the
1044 // remaining -1 will be taken literally.
1046 // I'm certain this also happens elsewhere, and is the probable
1047 // cause of other such things as:
1048 // Gtk-WARNING **: gtk_widget_size_allocate():
1049 // attempt to allocate widget with width 65535 and height 600
1050 // but I don't have time to track them all now..
1052 // Really we need to encapulate all this height/width business and
1053 // stop any old method from ripping at the members directly and
1054 // scattering -1's without regard for who might resolve them later.
1056 geom
.max_width
= ( maxHeight
== -1 ) ? maxWidth
1057 : ( maxWidth
== -1 ) ? wxGetDisplaySize().GetWidth()
1060 geom
.max_height
= ( maxWidth
== -1 ) ? maxHeight
// ( == -1 here )
1061 : ( maxHeight
== -1 ) ? wxGetDisplaySize().GetHeight()
1064 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget
),
1067 (GdkWindowHints
) flag
);
1069 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1070 * menubar, the toolbar and the client area, which is represented by
1072 * this hurts in the eye, but I don't want to call SetSize()
1073 * because I don't want to call any non-native functions here. */
1075 int client_x
= m_miniEdge
;
1076 int client_y
= m_miniEdge
+ m_miniTitle
;
1077 int client_w
= m_width
- 2*m_miniEdge
;
1078 int client_h
= m_height
- 2*m_miniEdge
- m_miniTitle
;
1080 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
1082 client_x
, client_y
, client_w
, client_h
);
1086 // If there is no m_mainWidget between m_widget and m_wxwindow there
1087 // is no need to set the size or position of m_wxwindow.
1092 // send size event to frame
1093 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1094 event
.SetEventObject( this );
1095 GetEventHandler()->ProcessEvent( event
);
1100 void wxTopLevelWindowGTK::OnInternalIdle()
1102 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
1104 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
1106 // we'll come back later
1108 wxapp_install_idle_handler();
1112 // set the focus if not done yet and if we can already do it
1113 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
1115 if ( g_delayedFocus
&&
1116 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
1118 wxLogTrace(_T("focus"),
1119 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1120 g_delayedFocus
->GetClassInfo()->GetClassName(),
1121 g_delayedFocus
->GetLabel().c_str());
1123 g_delayedFocus
->SetFocus();
1124 g_delayedFocus
= NULL
;
1128 wxWindow::OnInternalIdle();
1130 // Synthetize activate events.
1131 if ( g_sendActivateEvent
!= -1 )
1133 bool activate
= g_sendActivateEvent
!= 0;
1135 // if (!activate) wxPrintf( wxT("de") );
1136 // wxPrintf( wxT("activate\n") );
1139 g_sendActivateEvent
= -1;
1141 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
1145 // ----------------------------------------------------------------------------
1147 // ----------------------------------------------------------------------------
1149 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
1151 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1154 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
1157 void wxTopLevelWindowGTK::SetIcon( const wxIcon
&icon
)
1159 SetIcons( wxIconBundle( icon
) );
1162 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1164 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1166 wxTopLevelWindowBase::SetIcons( icons
);
1170 size_t max
= icons
.m_icons
.GetCount();
1172 for (size_t i
= 0; i
< max
; i
++)
1174 if (icons
.m_icons
[i
].Ok())
1176 list
= g_list_prepend(list
, icons
.m_icons
[i
].GetPixbuf());
1179 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1182 #else // !__WXGTK20__
1183 GdkWindow
* window
= m_widget
->window
;
1187 wxIcon icon
= icons
.GetIcon(-1);
1190 wxMask
*mask
= icon
.GetMask();
1191 GdkBitmap
*bm
= (GdkBitmap
*) NULL
;
1192 if (mask
) bm
= mask
->GetBitmap();
1194 gdk_window_set_icon( m_widget
->window
, (GdkWindow
*) NULL
, icon
.GetPixmap(), bm
);
1197 wxSetIconsX11( (WXDisplay
*)GDK_WINDOW_XDISPLAY( window
),
1198 (WXWindow
)GDK_WINDOW_XWINDOW( window
), icons
);
1199 #endif // !__WXGTK20__
1202 // ----------------------------------------------------------------------------
1203 // frame state: maximized/iconized/normal
1204 // ----------------------------------------------------------------------------
1206 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1210 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1212 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1214 wxFAIL_MSG( _T("not implemented") );
1218 bool wxTopLevelWindowGTK::IsMaximized() const
1221 if(!m_widget
->window
)
1224 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1226 // wxFAIL_MSG( _T("not implemented") );
1228 // This is an approximation
1233 void wxTopLevelWindowGTK::Restore()
1236 // "Present" seems similar enough to "restore"
1237 gtk_window_present( GTK_WINDOW( m_widget
) );
1239 wxFAIL_MSG( _T("not implemented") );
1243 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1247 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1249 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1253 GdkWindow
*window
= m_widget
->window
;
1255 // you should do it later, for example from OnCreate() handler
1256 wxCHECK_RET( window
, _T("frame not created yet - can't iconize") );
1258 XIconifyWindow( GDK_WINDOW_XDISPLAY( window
),
1259 GDK_WINDOW_XWINDOW( window
),
1260 DefaultScreen( GDK_DISPLAY() ) );
1265 bool wxTopLevelWindowGTK::IsIconized() const
1267 return m_isIconized
;
1270 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1272 if ( iconize
!= m_isIconized
)
1274 m_isIconized
= iconize
;
1275 (void)SendIconizeEvent(iconize
);
1279 void wxTopLevelWindowGTK::AddGrab()
1284 gtk_grab_add( m_widget
);
1285 wxEventLoop().Run();
1286 gtk_grab_remove( m_widget
);
1290 void wxTopLevelWindowGTK::RemoveGrab()
1301 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1305 if (region
.IsEmpty())
1307 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1312 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1314 wxBitmap bmp
= region
.ConvertToBitmap();
1315 bmp
.SetMask(new wxMask(bmp
, *wxBLACK
));
1316 GdkBitmap
* mask
= bmp
.GetMask()->GetBitmap();
1317 gdk_window_shape_combine_mask(window
, mask
, 0, 0);
1326 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1328 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1329 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1331 GdkWindow
*window
= NULL
;
1334 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1335 do_shape_combine_region(window
, region
);
1337 window
= m_widget
->window
;
1338 return do_shape_combine_region(window
, region
);
1341 bool wxTopLevelWindowGTK::IsActive()
1343 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);
1346 void wxTopLevelWindowGTK::RequestUserAttention(int flags
)
1348 bool new_hint_value
= false;
1350 // FIXME: This is a workaround to focus handling problem
1351 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1352 // yet been processed, and the internal focus system is not up to date yet.
1353 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1354 ::wxYieldIfNeeded();
1357 if(m_urgency_hint >= 0)
1358 gtk_timeout_remove(m_urgency_hint);
1360 int urgency_hint
= GPOINTER_TO_INT( gtk_object_get_data( GTK_OBJECT(m_widget
), "m_urgency_hint") );
1361 if(urgency_hint
>= 0)
1362 gtk_timeout_remove(urgency_hint
);
1365 //BCI: m_urgency_hint = -2;
1366 gtk_object_set_data( GTK_OBJECT(m_widget
), "m_urgency_hint", GINT_TO_POINTER(-2));
1368 if( GTK_WIDGET_REALIZED(m_widget
) && !IsActive() )
1370 new_hint_value
= true;
1372 if (flags
& wxUSER_ATTENTION_INFO
)
1374 //BCI: m_urgency_hint = gtk_timeout_add(5000, (GtkFunction)gtk_frame_urgency_timer_callback, this);
1375 gtk_object_set_data( GTK_OBJECT(m_widget
), "m_urgency_hint",
1376 GINT_TO_POINTER( gtk_timeout_add(5000,
1377 (GtkFunction
)gtk_frame_urgency_timer_callback
,
1380 //BCI: m_urgency_hint = -1;
1381 gtk_object_set_data( GTK_OBJECT(m_widget
), "m_urgency_hint", GINT_TO_POINTER(-1) );
1385 #if __WXGTK20__ && GTK_CHECK_VERSION(2,7,0)
1386 if(!gtk_check_version(2,7,0))
1387 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);
1390 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget
), new_hint_value
);