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
32 #include "wx/dialog.h"
33 #include "wx/control.h"
35 #include "wx/dcclient.h"
36 #include "wx/gtk/private.h"
38 #include "wx/settings.h"
43 #include <gdk/gdkkeysyms.h>
46 #include "wx/gtk/win_gtk.h"
48 #include "wx/unix/utilsx11.h"
51 #include <X11/Xatom.h>
53 // ----------------------------------------------------------------------------
55 // ----------------------------------------------------------------------------
57 extern void wxapp_install_idle_handler();
60 // ----------------------------------------------------------------------------
62 // ----------------------------------------------------------------------------
64 extern wxList wxPendingDelete
;
66 extern int g_openDialogs
;
67 extern wxWindowGTK
*g_delayedFocus
;
69 // the frame that is currently active (i.e. its child has focus). It is
70 // used to generate wxActivateEvents
71 static wxTopLevelWindowGTK
*g_activeFrame
= (wxTopLevelWindowGTK
*) NULL
;
72 static wxTopLevelWindowGTK
*g_lastActiveFrame
= (wxTopLevelWindowGTK
*) NULL
;
74 // if we detect that the app has got/lost the focus, we set this variable to
75 // either TRUE or FALSE and an activate event will be sent during the next
76 // OnIdle() call and it is reset to -1: this value means that we shouldn't
77 // send any activate events at all
78 static int g_sendActivateEvent
= -1;
80 //-----------------------------------------------------------------------------
82 //-----------------------------------------------------------------------------
84 static gint
gtk_frame_focus_in_callback( GtkWidget
*widget
,
85 GdkEvent
*WXUNUSED(event
),
86 wxTopLevelWindowGTK
*win
)
89 wxapp_install_idle_handler();
91 switch ( g_sendActivateEvent
)
94 // we've got focus from outside, synthetize wxActivateEvent
95 g_sendActivateEvent
= 1;
99 // another our window just lost focus, it was already ours before
100 // - don't send any wxActivateEvent
101 g_sendActivateEvent
= -1;
106 g_lastActiveFrame
= g_activeFrame
;
108 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
110 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
111 wxActivateEvent
event(wxEVT_ACTIVATE
, TRUE
, g_activeFrame
->GetId());
112 event
.SetEventObject(g_activeFrame
);
113 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
118 //-----------------------------------------------------------------------------
120 //-----------------------------------------------------------------------------
122 static gint
gtk_frame_focus_out_callback( GtkWidget
*widget
,
123 GdkEventFocus
*WXUNUSED(gdk_event
),
124 wxTopLevelWindowGTK
*win
)
127 wxapp_install_idle_handler();
129 // if the focus goes out of our app alltogether, OnIdle() will send
130 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
131 // g_sendActivateEvent to -1
132 g_sendActivateEvent
= 0;
134 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
136 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
140 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame
);
141 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
142 event
.SetEventObject(g_activeFrame
);
143 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
145 g_activeFrame
= NULL
;
151 //-----------------------------------------------------------------------------
152 // "focus" from m_window
153 //-----------------------------------------------------------------------------
155 static gint
gtk_frame_focus_callback( GtkWidget
*widget
, GtkDirectionType
WXUNUSED(d
), wxWindow
*WXUNUSED(win
) )
158 wxapp_install_idle_handler();
160 // This disables GTK's tab traversal
161 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus" );
165 //-----------------------------------------------------------------------------
167 //-----------------------------------------------------------------------------
169 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxTopLevelWindowGTK
*win
)
172 wxapp_install_idle_handler();
177 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
180 wxPrintf( "OnSize from " );
181 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
182 wxPrintf( win->GetClassInfo()->GetClassName() );
183 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
186 (int)alloc->height );
189 win
->m_width
= alloc
->width
;
190 win
->m_height
= alloc
->height
;
191 win
->GtkUpdateSize();
195 //-----------------------------------------------------------------------------
197 //-----------------------------------------------------------------------------
199 static gint
gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
), GdkEvent
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
202 wxapp_install_idle_handler();
204 if (win
->IsEnabled() &&
205 (g_openDialogs
== 0 || (win
->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) ||
213 //-----------------------------------------------------------------------------
215 //-----------------------------------------------------------------------------
218 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
), GdkEventConfigure
*WXUNUSED(event
), wxTopLevelWindowGTK
*win
)
221 wxapp_install_idle_handler();
223 if (!win
->m_hasVMT
|| !win
->IsShown())
228 gdk_window_get_root_origin( win
->m_widget
->window
, &x
, &y
);
232 wxMoveEvent
mevent( wxPoint(win
->m_x
,win
->m_y
), win
->GetId() );
233 mevent
.SetEventObject( win
);
234 win
->GetEventHandler()->ProcessEvent( mevent
);
239 //-----------------------------------------------------------------------------
240 // "realize" from m_widget
241 //-----------------------------------------------------------------------------
243 // we cannot MWM hints and icons before the widget has been realized,
244 // so we do this directly after realization
247 gtk_frame_realized_callback( GtkWidget
* WXUNUSED(widget
),
248 wxTopLevelWindowGTK
*win
)
251 wxapp_install_idle_handler();
253 // All this is for Motif Window Manager "hints" and is supposed to be
254 // recognized by other WM as well. Not tested.
255 gdk_window_set_decorations(win
->m_widget
->window
,
256 (GdkWMDecoration
)win
->m_gdkDecor
);
257 gdk_window_set_functions(win
->m_widget
->window
,
258 (GdkWMFunction
)win
->m_gdkFunc
);
260 // GTK's shrinking/growing policy
261 if ((win
->m_gdkFunc
& GDK_FUNC_RESIZE
) == 0)
262 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 0, 0, 1);
264 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
267 wxIconBundle iconsOld
= win
->GetIcons();
268 if ( iconsOld
.GetIcon(-1).Ok() )
270 win
->SetIcon( wxNullIcon
);
271 win
->SetIcons( iconsOld
);
275 //-----------------------------------------------------------------------------
276 // "map_event" from m_widget
277 //-----------------------------------------------------------------------------
280 gtk_frame_map_callback( GtkWidget
* WXUNUSED(widget
),
281 GdkEvent
* WXUNUSED(event
),
282 wxTopLevelWindow
*win
)
284 win
->SetIconizeState(FALSE
);
287 //-----------------------------------------------------------------------------
288 // "unmap_event" from m_widget
289 //-----------------------------------------------------------------------------
292 gtk_frame_unmap_callback( GtkWidget
* WXUNUSED(widget
),
293 GdkEvent
* WXUNUSED(event
),
294 wxTopLevelWindow
*win
)
296 win
->SetIconizeState(TRUE
);
299 //-----------------------------------------------------------------------------
300 // "expose_event" of m_client
301 //-----------------------------------------------------------------------------
303 static int gtk_window_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
305 GtkPizza
*pizza
= GTK_PIZZA(widget
);
307 gtk_paint_flat_box (win
->m_widget
->style
,
308 pizza
->bin_window
, GTK_STATE_NORMAL
,
318 //-----------------------------------------------------------------------------
319 // "draw" of m_client
320 //-----------------------------------------------------------------------------
324 static void gtk_window_draw_callback( GtkWidget
*widget
, GdkRectangle
*rect
, wxWindow
*win
)
326 GtkPizza
*pizza
= GTK_PIZZA(widget
);
328 gtk_paint_flat_box (win
->m_widget
->style
,
329 pizza
->bin_window
, GTK_STATE_NORMAL
,
339 // ----------------------------------------------------------------------------
340 // wxTopLevelWindowGTK itself
341 // ----------------------------------------------------------------------------
343 //-----------------------------------------------------------------------------
344 // InsertChild for wxTopLevelWindowGTK
345 //-----------------------------------------------------------------------------
347 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
348 * C++ has no virtual methods in a constructor. We have to emulate a
349 * virtual function here as wxWidgets requires different ways to insert
350 * a child in container classes. */
352 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK
* parent
, wxWindow
* child
)
354 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
356 if (!parent
->m_insertInClientArea
)
358 // these are outside the client area
359 wxTopLevelWindowGTK
* frame
= (wxTopLevelWindowGTK
*) parent
;
360 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
361 GTK_WIDGET(child
->m_widget
),
369 // these are inside the client area
370 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
371 GTK_WIDGET(child
->m_widget
),
378 // resize on OnInternalIdle
379 parent
->GtkUpdateSize();
382 // ----------------------------------------------------------------------------
383 // wxTopLevelWindowGTK creation
384 // ----------------------------------------------------------------------------
386 void wxTopLevelWindowGTK::Init()
391 m_mainWidget
= (GtkWidget
*) NULL
;
392 m_insertInClientArea
= TRUE
;
393 m_isIconized
= FALSE
;
394 m_fsIsShowing
= FALSE
;
395 m_themeEnabled
= TRUE
;
396 m_gdkDecor
= m_gdkFunc
= 0;
400 bool wxTopLevelWindowGTK::Create( wxWindow
*parent
,
402 const wxString
& title
,
404 const wxSize
& sizeOrig
,
406 const wxString
&name
)
408 // always create a frame of some reasonable, even if arbitrary, size (at
409 // least for MSW compatibility)
410 wxSize size
= sizeOrig
;
411 size
.x
= WidthDefault(size
.x
);
412 size
.y
= HeightDefault(size
.y
);
414 wxTopLevelWindows
.Append( this );
416 m_needParent
= FALSE
;
418 if (!PreCreation( parent
, pos
, size
) ||
419 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
421 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
427 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInTopLevelWindow
;
429 // NB: m_widget may be !=NULL if it was created by derived class' Create,
430 // e.g. in wxTaskBarIconAreaGTK
431 if (m_widget
== NULL
)
433 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
436 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
437 // Tell WM that this is a dialog window and make it center
438 // on parent by default (this is what GtkDialog ctor does):
439 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
440 GDK_WINDOW_TYPE_HINT_DIALOG
);
441 gtk_window_set_position(GTK_WINDOW(m_widget
),
442 GTK_WIN_POS_CENTER_ON_PARENT
);
444 m_widget
= gtk_window_new(GTK_WINDOW_DIALOG
);
449 m_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
451 if (style
& wxFRAME_TOOL_WINDOW
)
452 gtk_window_set_type_hint(GTK_WINDOW(m_widget
),
453 GDK_WINDOW_TYPE_HINT_UTILITY
);
458 wxWindow
*topParent
= wxGetTopLevelParent(m_parent
);
459 if (topParent
&& (((GTK_IS_WINDOW(topParent
->m_widget
)) &&
460 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)) ||
461 (style
& wxFRAME_FLOAT_ON_PARENT
)))
463 gtk_window_set_transient_for( GTK_WINDOW(m_widget
),
464 GTK_WINDOW(topParent
->m_widget
) );
467 #if GTK_CHECK_VERSION(2,2,0)
468 if (style
& wxFRAME_NO_TASKBAR
)
470 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget
), TRUE
);
475 gtk_window_set_wmclass( GTK_WINDOW(m_widget
), wxGTK_CONV( name
), wxGTK_CONV( name
) );
477 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
478 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
480 gtk_signal_connect( GTK_OBJECT(m_widget
), "delete_event",
481 GTK_SIGNAL_FUNC(gtk_frame_delete_callback
), (gpointer
)this );
483 // m_mainWidget holds the toolbar, the menubar and the client area
484 m_mainWidget
= gtk_pizza_new();
485 gtk_widget_show( m_mainWidget
);
486 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
487 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
489 if (m_miniEdge
== 0) // wxMiniFrame has its own version.
491 // For m_mainWidget themes
492 gtk_signal_connect( GTK_OBJECT(m_mainWidget
), "expose_event",
493 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
495 gtk_signal_connect( GTK_OBJECT(m_mainWidget
), "draw",
496 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
500 // m_wxwindow only represents the client area without toolbar and menubar
501 m_wxwindow
= gtk_pizza_new();
502 gtk_widget_show( m_wxwindow
);
503 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
505 // we donm't allow the frame to get the focus as otherwise
506 // the frame will grab it at arbitrary focus changes
507 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
509 if (m_parent
) m_parent
->AddChild( this );
511 // the user resized the frame by dragging etc.
512 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_allocate",
513 GTK_SIGNAL_FUNC(gtk_frame_size_callback
), (gpointer
)this );
517 if ((m_x
!= -1) || (m_y
!= -1))
518 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
520 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
522 // we cannot set MWM hints and icons before the widget has
523 // been realized, so we do this directly after realization
524 gtk_signal_connect( GTK_OBJECT(m_widget
), "realize",
525 GTK_SIGNAL_FUNC(gtk_frame_realized_callback
), (gpointer
) this );
527 // the only way to get the window size is to connect to this event
528 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
529 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
531 // map and unmap for iconized state
532 gtk_signal_connect( GTK_OBJECT(m_widget
), "map_event",
533 GTK_SIGNAL_FUNC(gtk_frame_map_callback
), (gpointer
)this );
534 gtk_signal_connect( GTK_OBJECT(m_widget
), "unmap_event",
535 GTK_SIGNAL_FUNC(gtk_frame_unmap_callback
), (gpointer
)this );
537 // the only way to get the window size is to connect to this event
538 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
539 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
541 // disable native tab traversal
542 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus",
543 GTK_SIGNAL_FUNC(gtk_frame_focus_callback
), (gpointer
)this );
546 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_in_event",
547 GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback
), (gpointer
)this );
548 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_out_event",
549 GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback
), (gpointer
)this );
552 if ((m_miniEdge
> 0) || (style
& wxSIMPLE_BORDER
) || (style
& wxNO_BORDER
))
559 m_gdkDecor
= (long) GDK_DECOR_BORDER
;
560 m_gdkFunc
= (long) GDK_FUNC_MOVE
;
562 // All this is for Motif Window Manager "hints" and is supposed to be
563 // recognized by other WMs as well.
564 if ((style
& wxCAPTION
) != 0)
566 m_gdkDecor
|= GDK_DECOR_TITLE
;
568 if ((style
& wxCLOSE_BOX
) != 0)
570 m_gdkFunc
|= GDK_FUNC_CLOSE
;
572 if ((style
& wxSYSTEM_MENU
) != 0)
574 m_gdkDecor
|= GDK_DECOR_MENU
;
576 if ((style
& wxMINIMIZE_BOX
) != 0)
578 m_gdkFunc
|= GDK_FUNC_MINIMIZE
;
579 m_gdkDecor
|= GDK_DECOR_MINIMIZE
;
581 if ((style
& wxMAXIMIZE_BOX
) != 0)
583 m_gdkFunc
|= GDK_FUNC_MAXIMIZE
;
584 m_gdkDecor
|= GDK_DECOR_MAXIMIZE
;
586 if ((style
& wxRESIZE_BORDER
) != 0)
588 m_gdkFunc
|= GDK_FUNC_RESIZE
;
589 m_gdkDecor
|= GDK_DECOR_RESIZEH
;
596 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
600 wxASSERT_MSG( FALSE
, _T("Window still grabbed"));
604 m_isBeingDeleted
= TRUE
;
606 // it may also be GtkScrolledWindow in the case of an MDI child
607 if (GTK_IS_WINDOW(m_widget
))
609 gtk_window_set_focus( GTK_WINDOW(m_widget
), NULL
);
612 if (g_activeFrame
== this)
613 g_activeFrame
= NULL
;
614 if (g_lastActiveFrame
== this)
615 g_lastActiveFrame
= NULL
;
620 bool wxTopLevelWindowGTK::ShowFullScreen(bool show
, long style
)
622 if (show
== m_fsIsShowing
) return FALSE
; // return what?
624 m_fsIsShowing
= show
;
626 GdkWindow
*window
= m_widget
->window
;
627 wxX11FullScreenMethod method
=
628 wxGetFullScreenMethodX11((WXDisplay
*)GDK_DISPLAY(),
629 (WXWindow
)GDK_ROOT_WINDOW());
633 m_fsSaveFlag
= style
;
634 GetPosition( &m_fsSaveFrame
.x
, &m_fsSaveFrame
.y
);
635 GetSize( &m_fsSaveFrame
.width
, &m_fsSaveFrame
.height
);
637 int screen_width
,screen_height
;
638 wxDisplaySize( &screen_width
, &screen_height
);
640 gint client_x
, client_y
, root_x
, root_y
;
643 if (method
!= wxX11_FS_WMSPEC
)
645 // don't do it always, Metacity hates it
646 m_fsSaveGdkFunc
= m_gdkFunc
;
647 m_fsSaveGdkDecor
= m_gdkDecor
;
648 m_gdkFunc
= m_gdkDecor
= 0;
649 gdk_window_set_decorations(window
, (GdkWMDecoration
)0);
650 gdk_window_set_functions(window
, (GdkWMFunction
)0);
653 gdk_window_get_origin (m_widget
->window
, &root_x
, &root_y
);
654 gdk_window_get_geometry (m_widget
->window
, &client_x
, &client_y
,
655 &width
, &height
, NULL
);
657 gdk_window_move_resize (m_widget
->window
, -client_x
, -client_y
,
658 screen_width
+ 1, screen_height
+ 1);
660 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
661 (WXWindow
)GDK_ROOT_WINDOW(),
662 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
663 show
, &m_fsSaveFrame
, method
);
667 if (method
!= wxX11_FS_WMSPEC
)
669 // don't do it always, Metacity hates it
670 m_gdkFunc
= m_fsSaveGdkFunc
;
671 m_gdkDecor
= m_fsSaveGdkDecor
;
672 gdk_window_set_decorations(window
, (GdkWMDecoration
)m_gdkDecor
);
673 gdk_window_set_functions(window
, (GdkWMFunction
)m_gdkFunc
);
676 wxSetFullScreenStateX11((WXDisplay
*)GDK_DISPLAY(),
677 (WXWindow
)GDK_ROOT_WINDOW(),
678 (WXWindow
)GDK_WINDOW_XWINDOW(window
),
679 show
, &m_fsSaveFrame
, method
);
681 SetSize(m_fsSaveFrame
.x
, m_fsSaveFrame
.y
,
682 m_fsSaveFrame
.width
, m_fsSaveFrame
.height
);
689 // ----------------------------------------------------------------------------
690 // overridden wxWindow methods
691 // ----------------------------------------------------------------------------
693 bool wxTopLevelWindowGTK::Show( bool show
)
695 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
697 if (show
&& !m_sizeSet
)
699 /* by calling GtkOnSize here, we don't have to call
700 either after showing the frame, which would entail
701 much ugly flicker or from within the size_allocate
702 handler, because GTK 1.1.X forbids that. */
704 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
707 return wxWindow::Show( show
);
710 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(width
), int WXUNUSED(height
) )
712 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
715 void wxTopLevelWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
717 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
719 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
720 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
730 int old_width
= m_width
;
731 int old_height
= m_height
;
733 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
735 if (x
!= -1) m_x
= x
;
736 if (y
!= -1) m_y
= y
;
743 if (width
!= -1) m_width
= width
;
744 if (height
!= -1) m_height
= height
;
747 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
749 if (width == -1) m_width = 80;
752 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
754 if (height == -1) m_height = 26;
758 int minWidth
= GetMinWidth(),
759 minHeight
= GetMinHeight(),
760 maxWidth
= GetMaxWidth(),
761 maxHeight
= GetMaxHeight();
764 // GPE's window manager doesn't like size hints
765 // at all, esp. when the user has to use the
773 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
774 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
775 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
776 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
778 if ((m_x
!= -1) || (m_y
!= -1))
780 if ((m_x
!= old_x
) || (m_y
!= old_y
))
782 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
786 if ((m_width
!= old_width
) || (m_height
!= old_height
))
788 if (m_widget
->window
)
789 gdk_window_resize( m_widget
->window
, m_width
, m_height
);
791 gtk_window_set_default_size( GTK_WINDOW(m_widget
), m_width
, m_height
);
793 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
794 done either directly before the frame is shown or in idle time
795 so that different calls to SetSize() don't lead to flicker. */
802 void wxTopLevelWindowGTK::DoGetClientSize( int *width
, int *height
) const
804 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
806 wxWindow::DoGetClientSize( width
, height
);
810 *height
-= m_miniEdge
*2 + m_miniTitle
;
814 *width
-= m_miniEdge
*2;
818 void wxTopLevelWindowGTK::DoSetClientSize( int width
, int height
)
820 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
823 width
+ m_miniEdge
*2, height
+ m_miniEdge
*2 + m_miniTitle
, 0);
826 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x
), int WXUNUSED(y
),
827 int width
, int height
)
829 // due to a bug in gtk, x,y are always 0
834 if (m_resizing
) return;
837 if ( m_wxwindow
== NULL
) return;
842 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
843 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
844 set in wxFrame::Create so it is used to check what kind of frame we
845 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
846 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
847 importantly) m_mainWidget */
849 int minWidth
= GetMinWidth(),
850 minHeight
= GetMinHeight(),
851 maxWidth
= GetMaxWidth(),
852 maxHeight
= GetMaxHeight();
855 // GPE's window manager doesn't like size hints
856 // at all, esp. when the user has to use the
864 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
865 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
866 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
867 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
872 gint flag
= 0; // GDK_HINT_POS;
875 if ((minWidth
!= -1) || (minHeight
!= -1)) flag
|= GDK_HINT_MIN_SIZE
;
876 if ((maxWidth
!= -1) || (maxHeight
!= -1)) flag
|= GDK_HINT_MAX_SIZE
;
878 geom
.min_width
= minWidth
;
879 geom
.min_height
= minHeight
;
881 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
882 // maxHeight or maxWidth is set, we must set them both, else the
883 // remaining -1 will be taken literally.
885 // I'm certain this also happens elsewhere, and is the probable
886 // cause of other such things as:
887 // Gtk-WARNING **: gtk_widget_size_allocate():
888 // attempt to allocate widget with width 65535 and height 600
889 // but I don't have time to track them all now..
891 // Really we need to encapulate all this height/width business and
892 // stop any old method from ripping at the members directly and
893 // scattering -1's without regard for who might resolve them later.
895 geom
.max_width
= ( maxHeight
== -1 ) ? maxWidth
896 : ( maxWidth
== -1 ) ? wxGetDisplaySize().GetWidth()
899 geom
.max_height
= ( maxWidth
== -1 ) ? maxHeight
// ( == -1 here )
900 : ( maxHeight
== -1 ) ? wxGetDisplaySize().GetHeight()
903 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget
),
906 (GdkWindowHints
) flag
);
908 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
909 * menubar, the toolbar and the client area, which is represented by
911 * this hurts in the eye, but I don't want to call SetSize()
912 * because I don't want to call any non-native functions here. */
914 int client_x
= m_miniEdge
;
915 int client_y
= m_miniEdge
+ m_miniTitle
;
916 int client_w
= m_width
- 2*m_miniEdge
;
917 int client_h
= m_height
- 2*m_miniEdge
- m_miniTitle
;
919 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
921 client_x
, client_y
, client_w
, client_h
);
925 // If there is no m_mainWidget between m_widget and m_wxwindow there
926 // is no need to set the size or position of m_wxwindow.
931 // send size event to frame
932 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
933 event
.SetEventObject( this );
934 GetEventHandler()->ProcessEvent( event
);
939 void wxTopLevelWindowGTK::OnInternalIdle()
941 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
943 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
945 // we'll come back later
947 wxapp_install_idle_handler();
951 // set the focus if not done yet and if we can already do it
952 if ( GTK_WIDGET_REALIZED(m_wxwindow
) )
954 if ( g_delayedFocus
&&
955 wxGetTopLevelParent((wxWindow
*)g_delayedFocus
) == this )
957 wxLogTrace(_T("focus"),
958 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
959 g_delayedFocus
->GetClassInfo()->GetClassName(),
960 g_delayedFocus
->GetLabel().c_str());
962 g_delayedFocus
->SetFocus();
963 g_delayedFocus
= NULL
;
967 wxWindow::OnInternalIdle();
969 // Synthetize activate events.
970 if ( g_sendActivateEvent
!= -1 )
972 bool activate
= g_sendActivateEvent
!= 0;
974 // if (!activate) wxPrintf( wxT("de") );
975 // wxPrintf( wxT("activate\n") );
978 g_sendActivateEvent
= -1;
980 wxTheApp
->SetActive(activate
, (wxWindow
*)g_lastActiveFrame
);
984 // ----------------------------------------------------------------------------
986 // ----------------------------------------------------------------------------
988 void wxTopLevelWindowGTK::SetTitle( const wxString
&title
)
990 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
993 gtk_window_set_title( GTK_WINDOW(m_widget
), wxGTK_CONV( title
) );
996 void wxTopLevelWindowGTK::SetIcon( const wxIcon
&icon
)
998 SetIcons( wxIconBundle( icon
) );
1001 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle
&icons
)
1003 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1005 wxTopLevelWindowBase::SetIcons( icons
);
1009 size_t max
= icons
.m_icons
.GetCount();
1011 for (size_t i
= 0; i
< max
; i
++)
1013 if (icons
.m_icons
[i
].Ok())
1015 list
= g_list_prepend(list
, icons
.m_icons
[i
].GetPixbuf());
1018 gtk_window_set_icon_list(GTK_WINDOW(m_widget
), list
);
1021 #else // !__WXGTK20__
1022 GdkWindow
* window
= m_widget
->window
;
1026 wxIcon icon
= icons
.GetIcon(-1);
1029 wxMask
*mask
= icon
.GetMask();
1030 GdkBitmap
*bm
= (GdkBitmap
*) NULL
;
1031 if (mask
) bm
= mask
->GetBitmap();
1033 gdk_window_set_icon( m_widget
->window
, (GdkWindow
*) NULL
, icon
.GetPixmap(), bm
);
1036 wxSetIconsX11( (WXDisplay
*)GDK_WINDOW_XDISPLAY( window
),
1037 (WXWindow
)GDK_WINDOW_XWINDOW( window
), icons
);
1038 #endif // !__WXGTK20__
1041 // ----------------------------------------------------------------------------
1042 // frame state: maximized/iconized/normal
1043 // ----------------------------------------------------------------------------
1045 void wxTopLevelWindowGTK::Maximize(bool maximize
)
1049 gtk_window_maximize( GTK_WINDOW( m_widget
) );
1051 gtk_window_unmaximize( GTK_WINDOW( m_widget
) );
1053 wxFAIL_MSG( _T("not implemented") );
1057 bool wxTopLevelWindowGTK::IsMaximized() const
1060 if(!m_widget
->window
)
1063 return gdk_window_get_state(m_widget
->window
) & GDK_WINDOW_STATE_MAXIMIZED
;
1065 // wxFAIL_MSG( _T("not implemented") );
1067 // This is an approximation
1072 void wxTopLevelWindowGTK::Restore()
1075 // "Present" seems similar enough to "restore"
1076 gtk_window_present( GTK_WINDOW( m_widget
) );
1078 wxFAIL_MSG( _T("not implemented") );
1082 void wxTopLevelWindowGTK::Iconize( bool iconize
)
1086 gtk_window_iconify( GTK_WINDOW( m_widget
) );
1088 gtk_window_deiconify( GTK_WINDOW( m_widget
) );
1092 GdkWindow
*window
= m_widget
->window
;
1094 // you should do it later, for example from OnCreate() handler
1095 wxCHECK_RET( window
, _T("frame not created yet - can't iconize") );
1097 XIconifyWindow( GDK_WINDOW_XDISPLAY( window
),
1098 GDK_WINDOW_XWINDOW( window
),
1099 DefaultScreen( GDK_DISPLAY() ) );
1104 bool wxTopLevelWindowGTK::IsIconized() const
1106 return m_isIconized
;
1109 void wxTopLevelWindowGTK::SetIconizeState(bool iconize
)
1111 if ( iconize
!= m_isIconized
)
1113 m_isIconized
= iconize
;
1114 (void)SendIconizeEvent(iconize
);
1118 void wxTopLevelWindowGTK::AddGrab()
1123 gtk_grab_add( m_widget
);
1125 gtk_grab_remove( m_widget
);
1129 void wxTopLevelWindowGTK::RemoveGrab()
1140 static bool do_shape_combine_region(GdkWindow
* window
, const wxRegion
& region
)
1144 if (region
.IsEmpty())
1146 gdk_window_shape_combine_mask(window
, NULL
, 0, 0);
1151 gdk_window_shape_combine_region(window
, region
.GetRegion(), 0, 0);
1153 wxBitmap bmp
= region
.ConvertToBitmap();
1154 bmp
.SetMask(new wxMask(bmp
, *wxBLACK
));
1155 GdkBitmap
* mask
= bmp
.GetMask()->GetBitmap();
1156 gdk_window_shape_combine_mask(window
, mask
, 0, 0);
1165 bool wxTopLevelWindowGTK::SetShape(const wxRegion
& region
)
1167 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), FALSE
,
1168 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1170 GdkWindow
*window
= NULL
;
1173 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
1174 do_shape_combine_region(window
, region
);
1176 window
= m_widget
->window
;
1177 return do_shape_combine_region(window
, region
);
1180 bool wxTopLevelWindowGTK::IsActive()
1182 return (this == (wxTopLevelWindowGTK
*)g_activeFrame
);