1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
19 #pragma implementation "frame.h"
23 #include "wx/dialog.h"
24 #include "wx/control.h"
28 #include "wx/toolbar.h"
31 #include "wx/statusbr.h"
33 #include "wx/dcclient.h"
38 #include <gdk/gdkkeysyms.h>
41 #include "wx/gtk/win_gtk.h"
43 // ----------------------------------------------------------------------------
45 // ----------------------------------------------------------------------------
47 const int wxMENU_HEIGHT
= 27;
48 const int wxSTATUS_HEIGHT
= 25;
49 const int wxPLACE_HOLDER
= 0;
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
55 extern void wxapp_install_idle_handler();
57 extern int g_openDialogs
;
59 // ----------------------------------------------------------------------------
61 // ----------------------------------------------------------------------------
63 IMPLEMENT_DYNAMIC_CLASS(wxFrame
,wxWindow
)
65 // ----------------------------------------------------------------------------
67 // ----------------------------------------------------------------------------
69 extern wxList wxPendingDelete
;
71 // ----------------------------------------------------------------------------
73 // ----------------------------------------------------------------------------
77 extern void debug_focus_in( GtkWidget
* widget
, const wxChar
* name
, const wxChar
*window
);
81 // ============================================================================
83 // ============================================================================
85 // ----------------------------------------------------------------------------
87 // ----------------------------------------------------------------------------
89 //-----------------------------------------------------------------------------
90 // "focus" from m_window
91 //-----------------------------------------------------------------------------
93 static gint
gtk_frame_focus_callback( GtkWidget
*widget
, GtkDirectionType
WXUNUSED(d
), wxWindow
*WXUNUSED(win
) )
96 wxapp_install_idle_handler();
98 // This disables GTK's tab traversal
99 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus" );
103 //-----------------------------------------------------------------------------
105 //-----------------------------------------------------------------------------
107 static void gtk_frame_size_callback( GtkWidget
*WXUNUSED(widget
), GtkAllocation
* alloc
, wxFrame
*win
)
110 wxapp_install_idle_handler();
115 if ((win
->m_width
!= alloc
->width
) || (win
->m_height
!= alloc
->height
))
118 wxPrintf( "OnSize from " );
119 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
120 wxPrintf( win->GetClassInfo()->GetClassName() );
121 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
124 (int)alloc->height );
127 win
->m_width
= alloc
->width
;
128 win
->m_height
= alloc
->height
;
133 //-----------------------------------------------------------------------------
135 //-----------------------------------------------------------------------------
137 static gint
gtk_frame_delete_callback( GtkWidget
*WXUNUSED(widget
), GdkEvent
*WXUNUSED(event
), wxFrame
*win
)
140 wxapp_install_idle_handler();
142 if (g_openDialogs
== 0)
148 //-----------------------------------------------------------------------------
149 // "child_attached" of menu bar
150 //-----------------------------------------------------------------------------
152 static void gtk_menu_attached_callback( GtkWidget
*WXUNUSED(widget
), GtkWidget
*WXUNUSED(child
), wxFrame
*win
)
154 if (!win
->m_hasVMT
) return;
156 win
->m_menuBarDetached
= FALSE
;
160 //-----------------------------------------------------------------------------
161 // "child_detached" of menu bar
162 //-----------------------------------------------------------------------------
164 static void gtk_menu_detached_callback( GtkWidget
*WXUNUSED(widget
), GtkWidget
*WXUNUSED(child
), wxFrame
*win
)
166 if (!win
->m_hasVMT
) return;
168 win
->m_menuBarDetached
= TRUE
;
173 //-----------------------------------------------------------------------------
174 // "child_attached" of tool bar
175 //-----------------------------------------------------------------------------
177 static void gtk_toolbar_attached_callback( GtkWidget
*WXUNUSED(widget
), GtkWidget
*WXUNUSED(child
), wxFrame
*win
)
179 if (!win
->m_hasVMT
) return;
181 win
->m_toolBarDetached
= FALSE
;
186 //-----------------------------------------------------------------------------
187 // "child_detached" of tool bar
188 //-----------------------------------------------------------------------------
190 static void gtk_toolbar_detached_callback( GtkWidget
*WXUNUSED(widget
), GtkWidget
*WXUNUSED(child
), wxFrame
*win
)
193 wxapp_install_idle_handler();
195 if (!win
->m_hasVMT
) return;
197 win
->m_toolBarDetached
= TRUE
;
200 #endif // wxUSE_TOOLBAR
202 //-----------------------------------------------------------------------------
204 //-----------------------------------------------------------------------------
207 #if (GTK_MINOR_VERSION > 0)
208 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
), GdkEventConfigure
*WXUNUSED(event
), wxFrame
*win
)
210 gtk_frame_configure_callback( GtkWidget
*WXUNUSED(widget
), GdkEventConfigure
*event
, wxFrame
*win
)
214 wxapp_install_idle_handler();
219 #if (GTK_MINOR_VERSION > 0)
222 gdk_window_get_root_origin( win
->m_widget
->window
, &x
, &y
);
230 wxMoveEvent
mevent( wxPoint(win
->m_x
,win
->m_y
), win
->GetId() );
231 mevent
.SetEventObject( win
);
232 win
->GetEventHandler()->ProcessEvent( mevent
);
237 //-----------------------------------------------------------------------------
238 // "realize" from m_widget
239 //-----------------------------------------------------------------------------
241 /* we cannot MWM hints and icons before the widget has been realized,
242 so we do this directly after realization */
245 gtk_frame_realized_callback( GtkWidget
*widget
, wxFrame
*win
)
248 wxapp_install_idle_handler();
250 /* I haven't been able to set the position of
251 the dialog before it is shown, so I set the
252 position in "realize" */
253 gtk_widget_set_uposition( widget
, win
->m_x
, win
->m_y
);
255 /* all this is for Motif Window Manager "hints" and is supposed to be
256 recognized by other WM as well. not tested. */
257 long decor
= (long) GDK_DECOR_BORDER
;
258 long func
= (long) GDK_FUNC_MOVE
;
260 if ((win
->GetWindowStyle() & wxCAPTION
) != 0)
261 decor
|= GDK_DECOR_TITLE
;
262 if ((win
->GetWindowStyle() & wxSYSTEM_MENU
) != 0)
264 decor
|= GDK_DECOR_MENU
;
265 func
|= GDK_FUNC_CLOSE
;
267 if ((win
->GetWindowStyle() & wxMINIMIZE_BOX
) != 0)
269 func
|= GDK_FUNC_MINIMIZE
;
270 decor
|= GDK_DECOR_MINIMIZE
;
272 if ((win
->GetWindowStyle() & wxMAXIMIZE_BOX
) != 0)
274 func
|= GDK_FUNC_MAXIMIZE
;
275 decor
|= GDK_DECOR_MAXIMIZE
;
277 if ((win
->GetWindowStyle() & wxRESIZE_BORDER
) != 0)
279 func
|= GDK_FUNC_RESIZE
;
280 decor
|= GDK_DECOR_RESIZEH
;
283 gdk_window_set_decorations( win
->m_widget
->window
, (GdkWMDecoration
)decor
);
284 gdk_window_set_functions( win
->m_widget
->window
, (GdkWMFunction
)func
);
286 /* GTK's shrinking/growing policy */
287 if ((win
->GetWindowStyle() & wxRESIZE_BORDER
) == 0)
288 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 0, 0, 1);
290 gtk_window_set_policy(GTK_WINDOW(win
->m_widget
), 1, 1, 1);
293 gint flag
= 0; // GDK_HINT_POS;
294 if ((win
->GetMinWidth() != -1) || (win
->GetMinHeight() != -1)) flag
|= GDK_HINT_MIN_SIZE
;
295 if ((win
->GetMaxWidth() != -1) || (win
->GetMaxHeight() != -1)) flag
|= GDK_HINT_MAX_SIZE
;
298 gdk_window_set_hints( win
->m_widget
->window
,
300 win
->GetMinWidth(), win
->GetMinHeight(),
301 win
->GetMaxWidth(), win
->GetMaxHeight(),
306 wxIcon iconOld
= win
->GetIcon();
307 if ( iconOld
!= wxNullIcon
)
309 wxIcon
icon( iconOld
);
310 win
->SetIcon( wxNullIcon
);
311 win
->SetIcon( icon
);
314 /* we set the focus to the child that accepts the focus. this
315 doesn't really have to be done in "realize" but why not? */
316 wxWindowList::Node
*node
= win
->GetChildren().GetFirst();
319 wxWindow
*child
= node
->GetData();
320 if (child
->AcceptsFocus())
326 node
= node
->GetNext();
332 // ----------------------------------------------------------------------------
334 // ----------------------------------------------------------------------------
336 //-----------------------------------------------------------------------------
337 // InsertChild for wxFrame
338 //-----------------------------------------------------------------------------
340 /* Callback for wxFrame. This very strange beast has to be used because
341 * C++ has no virtual methods in a constructor. We have to emulate a
342 * virtual function here as wxWindows requires different ways to insert
343 * a child in container classes. */
345 static void wxInsertChildInFrame( wxFrame
* parent
, wxWindow
* child
)
347 wxASSERT( GTK_IS_WIDGET(child
->m_widget
) );
349 if (!parent
->m_insertInClientArea
)
351 /* these are outside the client area */
352 wxFrame
* frame
= (wxFrame
*) parent
;
353 gtk_pizza_put( GTK_PIZZA(frame
->m_mainWidget
),
354 GTK_WIDGET(child
->m_widget
),
360 #if wxUSE_TOOLBAR_NATIVE
361 /* we connect to these events for recalculating the client area
362 space when the toolbar is floating */
363 if (wxIS_KIND_OF(child
,wxToolBar
))
365 wxToolBar
*toolBar
= (wxToolBar
*) child
;
366 if (toolBar
->GetWindowStyle() & wxTB_DOCKABLE
)
368 gtk_signal_connect( GTK_OBJECT(toolBar
->m_widget
), "child_attached",
369 GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback
), (gpointer
)parent
);
371 gtk_signal_connect( GTK_OBJECT(toolBar
->m_widget
), "child_detached",
372 GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback
), (gpointer
)parent
);
375 #endif // wxUSE_TOOLBAR
379 /* these are inside the client area */
380 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
381 GTK_WIDGET(child
->m_widget
),
388 /* resize on OnInternalIdle */
389 parent
->UpdateSize();
392 // ----------------------------------------------------------------------------
394 // ----------------------------------------------------------------------------
401 m_mainWidget
= (GtkWidget
*) NULL
;
402 m_menuBarDetached
= FALSE
;
403 m_toolBarDetached
= FALSE
;
404 m_insertInClientArea
= TRUE
;
408 bool wxFrame::Create( wxWindow
*parent
,
410 const wxString
&title
,
414 const wxString
&name
)
416 wxTopLevelWindows
.Append( this );
418 m_needParent
= FALSE
;
420 if (!PreCreation( parent
, pos
, size
) ||
421 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
423 wxFAIL_MSG( wxT("wxFrame creation failed") );
429 m_insertCallback
= (wxInsertChildFunction
) wxInsertChildInFrame
;
431 GtkWindowType win_type
= GTK_WINDOW_TOPLEVEL
;
432 if (style
& wxSIMPLE_BORDER
) win_type
= GTK_WINDOW_POPUP
;
434 m_widget
= gtk_window_new( win_type
);
437 gtk_window_set_wmclass( GTK_WINDOW(m_widget
), name
.mb_str(), name
.mb_str() );
440 debug_focus_in( m_widget
, wxT("wxFrame::m_widget"), name
);
443 gtk_window_set_title( GTK_WINDOW(m_widget
), title
.mbc_str() );
444 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
446 gtk_signal_connect( GTK_OBJECT(m_widget
), "delete_event",
447 GTK_SIGNAL_FUNC(gtk_frame_delete_callback
), (gpointer
)this );
449 /* m_mainWidget holds the toolbar, the menubar and the client area */
450 m_mainWidget
= gtk_pizza_new();
451 gtk_widget_show( m_mainWidget
);
452 GTK_WIDGET_UNSET_FLAGS( m_mainWidget
, GTK_CAN_FOCUS
);
453 gtk_container_add( GTK_CONTAINER(m_widget
), m_mainWidget
);
456 debug_focus_in( m_mainWidget
, wxT("wxFrame::m_mainWidget"), name
);
459 /* m_wxwindow only represents the client area without toolbar and menubar */
460 m_wxwindow
= gtk_pizza_new();
461 gtk_widget_show( m_wxwindow
);
462 gtk_container_add( GTK_CONTAINER(m_mainWidget
), m_wxwindow
);
465 debug_focus_in( m_wxwindow
, wxT("wxFrame::m_wxwindow"), name
);
468 /* we donm't allow the frame to get the focus as otherwise
469 the frame will grabit at arbitrary fcous changes. */
470 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
472 if (m_parent
) m_parent
->AddChild( this );
474 /* the user resized the frame by dragging etc. */
475 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_allocate",
476 GTK_SIGNAL_FUNC(gtk_frame_size_callback
), (gpointer
)this );
480 /* we cannot set MWM hints and icons before the widget has
481 been realized, so we do this directly after realization */
482 gtk_signal_connect( GTK_OBJECT(m_widget
), "realize",
483 GTK_SIGNAL_FUNC(gtk_frame_realized_callback
), (gpointer
) this );
485 /* the only way to get the window size is to connect to this event */
486 gtk_signal_connect( GTK_OBJECT(m_widget
), "configure_event",
487 GTK_SIGNAL_FUNC(gtk_frame_configure_callback
), (gpointer
)this );
489 /* disable native tab traversal */
490 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus",
491 GTK_SIGNAL_FUNC(gtk_frame_focus_callback
), (gpointer
)this );
498 m_isBeingDeleted
= TRUE
;
502 wxTopLevelWindows
.DeleteObject( this );
504 if (wxTheApp
->GetTopWindow() == this)
505 wxTheApp
->SetTopWindow( (wxWindow
*) NULL
);
507 if ((wxTopLevelWindows
.Number() == 0) &&
508 (wxTheApp
->GetExitOnFrameDelete()))
510 wxTheApp
->ExitMainLoop();
514 // ----------------------------------------------------------------------------
515 // overridden wxWindow methods
516 // ----------------------------------------------------------------------------
518 bool wxFrame::Show( bool show
)
520 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
522 if (show
&& !m_sizeSet
)
524 /* by calling GtkOnSize here, we don't have to call
525 either after showing the frame, which would entail
526 much ugly flicker or from within the size_allocate
527 handler, because GTK 1.1.X forbids that. */
529 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
532 return wxWindow::Show( show
);
535 void wxFrame::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
537 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
539 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
540 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
542 /* avoid recursions */
550 int old_width
= m_width
;
551 int old_height
= m_height
;
553 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
555 if (x
!= -1) m_x
= x
;
556 if (y
!= -1) m_y
= y
;
557 if (width
!= -1) m_width
= width
;
558 if (height
!= -1) m_height
= height
;
569 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
571 if (width == -1) m_width = 80;
574 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
576 if (height == -1) m_height = 26;
580 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
581 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
582 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
583 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
585 if ((m_x
!= -1) || (m_y
!= -1))
587 if ((m_x
!= old_x
) || (m_y
!= old_y
))
589 gtk_widget_set_uposition( m_widget
, m_x
, m_y
);
593 if ((m_width
!= old_width
) || (m_height
!= old_height
))
595 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
596 done either directly before the frame is shown or in idle time
597 so that different calls to SetSize() don't lead to flicker. */
604 void wxFrame::DoGetClientSize( int *width
, int *height
) const
606 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
608 wxWindow::DoGetClientSize( width
, height
);
614 if (!m_menuBarDetached
)
615 (*height
) -= wxMENU_HEIGHT
;
617 (*height
) -= wxPLACE_HOLDER
;
622 if (m_frameStatusBar
) (*height
) -= wxSTATUS_HEIGHT
;
623 #endif // wxUSE_STATUSBAR
629 if (m_toolBarDetached
)
631 *height
-= wxPLACE_HOLDER
;
636 m_frameToolBar
->GetSize( &x
, &y
);
637 if ( m_frameToolBar
->GetWindowStyle() & wxTB_VERTICAL
)
647 #endif // wxUSE_TOOLBAR
650 *height
-= m_miniEdge
*2 + m_miniTitle
;
654 *width
-= m_miniEdge
*2;
658 void wxFrame::DoSetClientSize( int width
, int height
)
660 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
665 if (!m_menuBarDetached
)
666 height
+= wxMENU_HEIGHT
;
668 height
+= wxPLACE_HOLDER
;
673 if (m_frameStatusBar
) height
+= wxSTATUS_HEIGHT
;
680 if (m_toolBarDetached
)
682 height
+= wxPLACE_HOLDER
;
687 m_frameToolBar
->GetSize( &x
, &y
);
688 if ( m_frameToolBar
->GetWindowStyle() & wxTB_VERTICAL
)
700 DoSetSize( -1, -1, width
+ m_miniEdge
*2, height
+ m_miniEdge
*2 + m_miniTitle
, 0 );
703 void wxFrame::GtkOnSize( int WXUNUSED(x
), int WXUNUSED(y
),
704 int width
, int height
)
706 // due to a bug in gtk, x,y are always 0
710 /* avoid recursions */
711 if (m_resizing
) return;
714 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
715 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
720 /* space occupied by m_frameToolBar and m_frameMenuBar */
721 int client_area_x_offset
= 0,
722 client_area_y_offset
= 0;
724 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
725 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
726 set in wxFrame::Create so it is used to check what kind of frame we
727 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
728 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
729 importantly) m_mainWidget */
733 /* check if size is in legal range */
734 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
735 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
736 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
737 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
739 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
740 * menubar, the toolbar and the client area, which is represented by
742 * this hurts in the eye, but I don't want to call SetSize()
743 * because I don't want to call any non-native functions here. */
748 int yy
= m_miniEdge
+ m_miniTitle
;
749 int ww
= m_width
- 2*m_miniEdge
;
750 int hh
= wxMENU_HEIGHT
;
751 if (m_menuBarDetached
) hh
= wxPLACE_HOLDER
;
752 m_frameMenuBar
->m_x
= xx
;
753 m_frameMenuBar
->m_y
= yy
;
754 m_frameMenuBar
->m_width
= ww
;
755 m_frameMenuBar
->m_height
= hh
;
756 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
757 m_frameMenuBar
->m_widget
,
759 client_area_y_offset
+= hh
;
763 if ((m_frameToolBar
) &&
764 (m_frameToolBar
->m_widget
->parent
== m_mainWidget
))
767 int yy
= m_miniEdge
+ m_miniTitle
;
770 if (!m_menuBarDetached
)
773 yy
+= wxPLACE_HOLDER
;
776 m_frameToolBar
->m_x
= xx
;
777 m_frameToolBar
->m_y
= yy
;
779 /* don't change the toolbar's reported height/width */
781 if ( m_frameToolBar
->GetWindowStyle() & wxTB_VERTICAL
)
783 ww
= m_toolBarDetached
? wxPLACE_HOLDER
784 : m_frameToolBar
->m_width
;
785 hh
= m_height
- 2*m_miniEdge
;
787 client_area_x_offset
+= ww
;
791 ww
= m_width
- 2*m_miniEdge
;
792 hh
= m_toolBarDetached
? wxPLACE_HOLDER
793 : m_frameToolBar
->m_height
;
795 client_area_y_offset
+= hh
;
798 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
799 m_frameToolBar
->m_widget
,
802 #endif // wxUSE_TOOLBAR
804 int client_x
= client_area_x_offset
+ m_miniEdge
;
805 int client_y
= client_area_y_offset
+ m_miniEdge
+ m_miniTitle
;
806 int client_w
= m_width
- client_area_x_offset
- 2*m_miniEdge
;
807 int client_h
= m_height
- client_area_y_offset
- 2*m_miniEdge
- m_miniTitle
;
808 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget
),
810 client_x
, client_y
, client_w
, client_h
);
814 /* if there is no m_mainWidget between m_widget and m_wxwindow there
815 is no need to set the size or position of m_wxwindow. */
819 if (m_frameStatusBar
)
821 int xx
= 0 + m_miniEdge
;
822 int yy
= m_height
- wxSTATUS_HEIGHT
- m_miniEdge
- client_area_y_offset
;
823 int ww
= m_width
- 2*m_miniEdge
;
824 int hh
= wxSTATUS_HEIGHT
;
825 m_frameStatusBar
->m_x
= xx
;
826 m_frameStatusBar
->m_y
= yy
;
827 m_frameStatusBar
->m_width
= ww
;
828 m_frameStatusBar
->m_height
= hh
;
829 gtk_pizza_set_size( GTK_PIZZA(m_wxwindow
),
830 m_frameStatusBar
->m_widget
,
835 /* we actually set the size of a frame here and no-where else */
836 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
840 // send size event to frame
841 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
842 event
.SetEventObject( this );
843 GetEventHandler()->ProcessEvent( event
);
845 // send size event to status bar
846 if (m_frameStatusBar
)
848 wxSizeEvent
event2( wxSize(m_frameStatusBar
->m_width
,m_frameStatusBar
->m_height
), m_frameStatusBar
->GetId() );
849 event2
.SetEventObject( m_frameStatusBar
);
850 m_frameStatusBar
->GetEventHandler()->ProcessEvent( event2
);
856 void wxFrame::MakeModal( bool modal
)
859 gtk_grab_add( m_widget
);
861 gtk_grab_remove( m_widget
);
864 void wxFrame::OnInternalIdle()
866 if (!m_sizeSet
&& GTK_WIDGET_REALIZED(m_wxwindow
))
868 GtkOnSize( m_x
, m_y
, m_width
, m_height
);
870 // we'll come back later
872 wxapp_install_idle_handler();
876 if (m_frameMenuBar
) m_frameMenuBar
->OnInternalIdle();
878 if (m_frameToolBar
) m_frameToolBar
->OnInternalIdle();
881 if (m_frameStatusBar
) m_frameStatusBar
->OnInternalIdle();
884 wxWindow::OnInternalIdle();
887 // ----------------------------------------------------------------------------
888 // menu/tool/status bar stuff
889 // ----------------------------------------------------------------------------
891 void wxFrame::SetMenuBar( wxMenuBar
*menuBar
)
893 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
894 wxASSERT_MSG( (m_wxwindow
!= NULL
), wxT("invalid frame") );
896 m_frameMenuBar
= menuBar
;
900 m_frameMenuBar
->SetInvokingWindow( this );
902 if (m_frameMenuBar
->GetParent() != this)
904 m_frameMenuBar
->SetParent(this);
905 gtk_pizza_put( GTK_PIZZA(m_mainWidget
),
906 m_frameMenuBar
->m_widget
,
909 m_frameMenuBar
->m_width
,
910 m_frameMenuBar
->m_height
);
912 if (menuBar
->GetWindowStyle() & wxMB_DOCKABLE
)
914 gtk_signal_connect( GTK_OBJECT(menuBar
->m_widget
), "child_attached",
915 GTK_SIGNAL_FUNC(gtk_menu_attached_callback
), (gpointer
)this );
917 gtk_signal_connect( GTK_OBJECT(menuBar
->m_widget
), "child_detached",
918 GTK_SIGNAL_FUNC(gtk_menu_detached_callback
), (gpointer
)this );
921 m_frameMenuBar
->Show( TRUE
);
925 /* resize window in OnInternalIdle */
930 wxToolBar
* wxFrame::CreateToolBar( long style
, wxWindowID id
, const wxString
& name
)
932 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
934 m_insertInClientArea
= FALSE
;
936 m_frameToolBar
= wxFrameBase::CreateToolBar( style
, id
, name
);
939 GetChildren().DeleteObject( m_frameToolBar
);
941 m_insertInClientArea
= TRUE
;
945 return m_frameToolBar
;
948 void wxFrame::SetToolBar(wxToolBar
*toolbar
)
950 wxFrameBase::SetToolBar(toolbar
);
954 /* insert into toolbar area if not already there */
955 if ((m_frameToolBar
->m_widget
->parent
) &&
956 (m_frameToolBar
->m_widget
->parent
!= m_mainWidget
))
958 GetChildren().DeleteObject( m_frameToolBar
);
960 gtk_widget_reparent( m_frameToolBar
->m_widget
, m_mainWidget
);
966 #endif // wxUSE_TOOLBAR
970 wxStatusBar
* wxFrame::CreateStatusBar(int number
,
973 const wxString
& name
)
975 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
977 // because it will change when toolbar is added
980 return wxFrameBase::CreateStatusBar( number
, style
, id
, name
);
983 #endif // wxUSE_STATUSBAR
985 // ----------------------------------------------------------------------------
987 // ----------------------------------------------------------------------------
989 void wxFrame::SetTitle( const wxString
&title
)
991 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
994 gtk_window_set_title( GTK_WINDOW(m_widget
), title
.mbc_str() );
997 void wxFrame::SetIcon( const wxIcon
&icon
)
999 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid frame") );
1001 wxFrameBase::SetIcon(icon
);
1006 if (!m_widget
->window
)
1009 wxMask
*mask
= icon
.GetMask();
1010 GdkBitmap
*bm
= (GdkBitmap
*) NULL
;
1011 if (mask
) bm
= mask
->GetBitmap();
1013 gdk_window_set_icon( m_widget
->window
, (GdkWindow
*) NULL
, icon
.GetPixmap(), bm
);
1016 // ----------------------------------------------------------------------------
1017 // frame state: maximized/iconized/normal (TODO)
1018 // ----------------------------------------------------------------------------
1020 void wxFrame::Maximize(bool WXUNUSED(maximize
))
1024 bool wxFrame::IsMaximized() const
1029 void wxFrame::Restore()
1033 void wxFrame::Iconize( bool iconize
)
1037 XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget
->window
),
1038 GDK_WINDOW_XWINDOW( m_widget
->window
),
1039 DefaultScreen( GDK_DISPLAY() ) );
1043 bool wxFrame::IsIconized() const