corrected pragma interface/implementation for Mac OS X

[wxWidgets.git] / src / gtk / frame.cpp

diff --git a/src/gtk/frame.cpp b/src/gtk/frame.cpp
index 43d5e0788781baf39cc8c8bcac7246d17deb86bb..fb364d258e6130ab0898cac62a7e347015a1c104 100644 (file)
--- a/src/gtk/frame.cpp
+++ b/src/gtk/frame.cpp
@@ -23,7 +23,8 @@
 #define XIconifyWindow XICONIFYWINDOW
 #endif
 
 #define XIconifyWindow XICONIFYWINDOW
 #endif
 

-#include "wx/frame.h"
+#include "wx/defs.h"
+

 #include "wx/dialog.h"
 #include "wx/control.h"
 #include "wx/app.h"
 #include "wx/dialog.h"
 #include "wx/control.h"
 #include "wx/app.h"


@@ -64,7 +65,9 @@ extern int g_openDialogs;
 // event tables
 // ----------------------------------------------------------------------------
 
 // event tables
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+#ifndef __WXUNIVERSAL__
+    IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif

 
 // ----------------------------------------------------------------------------
 // data
 
 // ----------------------------------------------------------------------------
 // data


@@ -108,7 +111,7 @@ static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUS
 // "size_allocate"
 //-----------------------------------------------------------------------------
 
 // "size_allocate"
 //-----------------------------------------------------------------------------
 

-static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
+static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrameGTK *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -139,7 +142,7 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 // "delete_event"
 //-----------------------------------------------------------------------------
 
 // "delete_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
+static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrameGTK *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -150,11 +153,13 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX
     return TRUE;
 }
 
     return TRUE;
 }
 

+#if wxUSE_MENUS_NATIVE
+

 //-----------------------------------------------------------------------------
 // "child_attached" of menu bar
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // "child_attached" of menu bar
 //-----------------------------------------------------------------------------
 

-static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )

 {
     if (!win->m_hasVMT) return;
 
 {
     if (!win->m_hasVMT) return;
 


@@ -166,7 +171,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
 // "child_detached" of menu bar
 //-----------------------------------------------------------------------------
 
 // "child_detached" of menu bar
 //-----------------------------------------------------------------------------
 

-static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )

 {
     if (!win->m_hasVMT) return;
 
 {
     if (!win->m_hasVMT) return;
 


@@ -174,12 +179,14 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     win->GtkUpdateSize();
 }
 
     win->GtkUpdateSize();
 }
 

+#endif // wxUSE_MENUS_NATIVE
+

 #if wxUSE_TOOLBAR
 //-----------------------------------------------------------------------------
 // "child_attached" of tool bar
 //-----------------------------------------------------------------------------
 
 #if wxUSE_TOOLBAR
 //-----------------------------------------------------------------------------
 // "child_attached" of tool bar
 //-----------------------------------------------------------------------------
 

-static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )

 {
     if (!win->m_hasVMT) return;
 
 {
     if (!win->m_hasVMT) return;
 


@@ -192,7 +199,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 // "child_detached" of tool bar
 //-----------------------------------------------------------------------------
 
 // "child_detached" of tool bar
 //-----------------------------------------------------------------------------
 

-static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -210,9 +217,9 @@ static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 
 static gint
 #if (GTK_MINOR_VERSION > 0)
 
 static gint
 #if (GTK_MINOR_VERSION > 0)

-gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
+gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrameGTK *win )

 #else
 #else

-gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
+gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrameGTK *win )

 #endif
 {
     if (g_isIdle)
 #endif
 {
     if (g_isIdle)


@@ -247,7 +254,7 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *ev
    so we do this directly after realization */
 
 static void
    so we do this directly after realization */
 
 static void

-gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )
+gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrameGTK *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -332,7 +339,7 @@ gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
                         GdkEvent * WXUNUSED(event),
                         wxFrame *win )
 {
                         GdkEvent * WXUNUSED(event),
                         wxFrame *win )
 {

-    win->m_isIconized = FALSE;
+    win->SetIconizeState(FALSE);

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -344,30 +351,57 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
                           GdkEvent * WXUNUSED(event),
                           wxFrame *win )
 {
                           GdkEvent * WXUNUSED(event),
                           wxFrame *win )
 {

-    win->m_isIconized = TRUE;
+    win->SetIconizeState(TRUE);
+}
+
+//-----------------------------------------------------------------------------
+// "expose_event" of m_client
+//-----------------------------------------------------------------------------
+
+static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+{
+    GtkPizza *pizza = GTK_PIZZA(widget);
+
+    gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+                GTK_SHADOW_NONE, &gdk_event->area, win->m_widget, "base", 0, 0, -1, -1);
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "draw" of m_client
+//-----------------------------------------------------------------------------
+
+
+static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
+{
+    GtkPizza *pizza = GTK_PIZZA(widget);
+
+    gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+                GTK_SHADOW_NONE, rect, win->m_widget, "base", 0, 0, -1, -1);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxFrame itself
+// wxFrameGTK itself

 // ----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// InsertChild for wxFrame
+// InsertChild for wxFrameGTK

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-/* Callback for wxFrame. This very strange beast has to be used because
+/* Callback for wxFrameGTK. This very strange beast has to be used because

  * C++ has no virtual methods in a constructor. We have to emulate a
  * virtual function here as wxWindows requires different ways to insert
  * a child in container classes. */
 
  * C++ has no virtual methods in a constructor. We have to emulate a
  * virtual function here as wxWindows requires different ways to insert
  * a child in container classes. */
 

-static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
+static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child )

 {
     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 
     if (!parent->m_insertInClientArea)
     {
         /* these are outside the client area */
 {
     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 
     if (!parent->m_insertInClientArea)
     {
         /* these are outside the client area */

-        wxFrame* frame = (wxFrame*) parent;
+        wxFrameGTK* frame = (wxFrameGTK*) parent;

         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,
         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,


@@ -408,10 +442,10 @@ static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxFrame creation
+// wxFrameGTK creation

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxFrame::Init()
+void wxFrameGTK::Init()

 {
     m_sizeSet = FALSE;
     m_miniEdge = 0;
 {
     m_sizeSet = FALSE;
     m_miniEdge = 0;


@@ -420,18 +454,32 @@ void wxFrame::Init()
     m_menuBarDetached = FALSE;
     m_toolBarDetached = FALSE;
     m_insertInClientArea = TRUE;
     m_menuBarDetached = FALSE;
     m_toolBarDetached = FALSE;
     m_insertInClientArea = TRUE;

+    m_isFrame = TRUE;

     m_isIconized = FALSE;
     m_fsIsShowing = FALSE;
     m_isIconized = FALSE;
     m_fsIsShowing = FALSE;

+    m_themeEnabled = TRUE;

 }
 
 }
 

-bool wxFrame::Create( wxWindow *parent,
+bool wxFrameGTK::Create( wxWindow *parent,

                       wxWindowID id,
                       wxWindowID id,

-                      const wxString &title,
-                      const wxPoint &pos,
-                      const wxSize &size,
+                      const wxString& title,
+                      const wxPoint& pos,
+                      const wxSize& sizeOrig,

                       long style,
                       const wxString &name )
 {
                       long style,
                       const wxString &name )
 {

+    // always create a frame of some reasonable, even if arbitrary, size (at
+    // least for MSW compatibility)
+    wxSize size = sizeOrig;
+    if ( size.x == -1 || size.y == -1 )
+    {
+        wxSize sizeDpy = wxGetDisplaySize();
+        if ( size.x == -1 )
+            size.x = sizeDpy.x / 3;
+        if ( size.y == -1 )
+            size.y = sizeDpy.y / 5;
+    }
+

     wxTopLevelWindows.Append( this );
 
     m_needParent = FALSE;
     wxTopLevelWindows.Append( this );
 
     m_needParent = FALSE;


@@ -439,7 +487,7 @@ bool wxFrame::Create( wxWindow *parent,
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {

-        wxFAIL_MSG( wxT("wxFrame creation failed") );
+        wxFAIL_MSG( wxT("wxFrameGTK creation failed") );

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -448,7 +496,7 @@ bool wxFrame::Create( wxWindow *parent,
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 
     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 
     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;

-    
+

     if (style & wxFRAME_TOOL_WINDOW)
         win_type = GTK_WINDOW_POPUP;
 
     if (style & wxFRAME_TOOL_WINDOW)
         win_type = GTK_WINDOW_POPUP;
 


@@ -461,7 +509,7 @@ bool wxFrame::Create( wxWindow *parent,
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 
 #ifdef __WXDEBUG__
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 
 #ifdef __WXDEBUG__

-    debug_focus_in( m_widget, wxT("wxFrame::m_widget"), name );
+    debug_focus_in( m_widget, wxT("wxFrameGTK::m_widget"), name );

 #endif
 
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 #endif
 
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );


@@ -476,8 +524,14 @@ bool wxFrame::Create( wxWindow *parent,
     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 
     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 

+    /* for m_mainWidget themes */
+    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
+                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
+                GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+

 #ifdef __WXDEBUG__
 #ifdef __WXDEBUG__

-    debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
+    debug_focus_in( m_mainWidget, wxT("wxFrameGTK::m_mainWidget"), name );

 #endif
 
     /* m_wxwindow only represents the client area without toolbar and menubar */
 #endif
 
     /* m_wxwindow only represents the client area without toolbar and menubar */


@@ -486,11 +540,11 @@ bool wxFrame::Create( wxWindow *parent,
     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 
 #ifdef __WXDEBUG__
     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 
 #ifdef __WXDEBUG__

-    debug_focus_in( m_wxwindow, wxT("wxFrame::m_wxwindow"), name );
+    debug_focus_in( m_wxwindow, wxT("wxFrameGTK::m_wxwindow"), name );

 #endif
 
     /* we donm't allow the frame to get the focus as otherwise
 #endif
 
     /* we donm't allow the frame to get the focus as otherwise

-       the frame will grabit at arbitrary fcous changes. */
+       the frame will grab it at arbitrary focus changes. */

     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 
     if (m_parent) m_parent->AddChild( this );
     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 
     if (m_parent) m_parent->AddChild( this );


@@ -531,7 +585,7 @@ bool wxFrame::Create( wxWindow *parent,
     return TRUE;
 }
 
     return TRUE;
 }
 

-wxFrame::~wxFrame()
+wxFrameGTK::~wxFrameGTK()

 {
     m_isBeingDeleted = TRUE;
 
 {
     m_isBeingDeleted = TRUE;
 


@@ -549,29 +603,29 @@ wxFrame::~wxFrame()
     }
 }
 
     }
 }
 

-bool wxFrame::ShowFullScreen(bool show, long style )
+bool wxFrameGTK::ShowFullScreen(bool show, long style )

 {
     if (show == m_fsIsShowing) return FALSE; // return what?
 
     m_fsIsShowing = show;
 {
     if (show == m_fsIsShowing) return FALSE; // return what?
 
     m_fsIsShowing = show;

-    
+

     if (show)
     {
         m_fsSaveStyle = m_windowStyle;
         m_fsSaveFlag = style;
         GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
         GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
     if (show)
     {
         m_fsSaveStyle = m_windowStyle;
         m_fsSaveFlag = style;
         GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
         GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );

-        
+

         gtk_widget_hide( m_widget );
         gtk_widget_unrealize( m_widget );
         gtk_widget_hide( m_widget );
         gtk_widget_unrealize( m_widget );

-        
+

         m_windowStyle = wxSIMPLE_BORDER;
         m_windowStyle = wxSIMPLE_BORDER;

-        
+

         int x;
         int y;
         wxDisplaySize( &x, &y );
         SetSize( 0, 0, x, y );
         int x;
         int y;
         wxDisplaySize( &x, &y );
         SetSize( 0, 0, x, y );

-        
+

         gtk_widget_realize( m_widget );
         gtk_widget_show( m_widget );
     }
         gtk_widget_realize( m_widget );
         gtk_widget_show( m_widget );
     }


@@ -579,15 +633,15 @@ bool wxFrame::ShowFullScreen(bool show, long style )
     {
         gtk_widget_hide( m_widget );
         gtk_widget_unrealize( m_widget );
     {
         gtk_widget_hide( m_widget );
         gtk_widget_unrealize( m_widget );

-    
+

         m_windowStyle = m_fsSaveStyle;
         m_windowStyle = m_fsSaveStyle;

-        
+

         SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
         SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );

-        
+

         gtk_widget_realize( m_widget );
         gtk_widget_show( m_widget );
     }
         gtk_widget_realize( m_widget );
         gtk_widget_show( m_widget );
     }

-    
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -595,7 +649,7 @@ bool wxFrame::ShowFullScreen(bool show, long style )
 // overridden wxWindow methods
 // ----------------------------------------------------------------------------
 
 // overridden wxWindow methods
 // ----------------------------------------------------------------------------
 

-bool wxFrame::Show( bool show )
+bool wxFrameGTK::Show( bool show )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 


@@ -612,16 +666,16 @@ bool wxFrame::Show( bool show )
     return wxWindow::Show( show );
 }
 
     return wxWindow::Show( show );
 }
 

-void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
+void wxFrameGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )

 {
 {

-    wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );
+    wxFAIL_MSG( wxT("DoMoveWindow called for wxFrameGTK") );

 }
 
 }
 

-void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+void wxFrameGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

-    /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
+    /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */

     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     /* avoid recursions */
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     /* avoid recursions */


@@ -688,13 +742,14 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
     m_resizing = FALSE;
 }
 

-void wxFrame::DoGetClientSize( int *width, int *height ) const
+void wxFrameGTK::DoGetClientSize( int *width, int *height ) const

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     wxWindow::DoGetClientSize( width, height );
     if (height)
     {
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     wxWindow::DoGetClientSize( width, height );
     if (height)
     {

+#if wxUSE_MENUS

         /* menu bar */
         if (m_frameMenuBar)
         {
         /* menu bar */
         if (m_frameMenuBar)
         {


@@ -703,6 +758,7 @@ void wxFrame::DoGetClientSize( int *width, int *height ) const
             else
                 (*height) -= wxPLACE_HOLDER;
         }
             else
                 (*height) -= wxPLACE_HOLDER;
         }

+#endif // wxUSE_MENUS

 
 #if wxUSE_STATUSBAR
         /* status bar */
 
 #if wxUSE_STATUSBAR
         /* status bar */


@@ -742,10 +798,11 @@ void wxFrame::DoGetClientSize( int *width, int *height ) const
     }
 }
 
     }
 }
 

-void wxFrame::DoSetClientSize( int width, int height )
+void wxFrameGTK::DoSetClientSize( int width, int height )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

+#if wxUSE_MENUS

         /* menu bar */
         if (m_frameMenuBar)
         {
         /* menu bar */
         if (m_frameMenuBar)
         {


@@ -754,6 +811,7 @@ void wxFrame::DoSetClientSize( int width, int height )
             else
                 height += wxPLACE_HOLDER;
         }
             else
                 height += wxPLACE_HOLDER;
         }

+#endif // wxUSE_MENUS

 
 #if wxUSE_STATUSBAR
         /* status bar */
 
 #if wxUSE_STATUSBAR
         /* status bar */


@@ -787,7 +845,7 @@ void wxFrame::DoSetClientSize( int width, int height )
     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 }
 
     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 }
 

-void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
+void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),

                          int width, int height )
 {
     // due to a bug in gtk, x,y are always 0
                          int width, int height )
 {
     // due to a bug in gtk, x,y are always 0


@@ -798,7 +856,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     if (m_resizing) return;
     m_resizing = TRUE;
 
     if (m_resizing) return;
     m_resizing = TRUE;
 

-    /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
+    /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */

     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     m_width = width;
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     m_width = width;


@@ -808,9 +866,9 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     int client_area_x_offset = 0,
         client_area_y_offset = 0;
 
     int client_area_x_offset = 0,
         client_area_y_offset = 0;
 

-    /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
+    /* wxMDIChildFrame derives from wxFrameGTK but it _is_ a wxWindow as it uses

        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only

-       set in wxFrame::Create so it is used to check what kind of frame we
+       set in wxFrameGTK::Create so it is used to check what kind of frame we

        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
        importantly) m_mainWidget */
        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
        importantly) m_mainWidget */


@@ -842,6 +900,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
          * this hurts in the eye, but I don't want to call SetSize()
          * because I don't want to call any non-native functions here. */
 
          * this hurts in the eye, but I don't want to call SetSize()
          * because I don't want to call any non-native functions here. */
 

+#if wxUSE_MENUS

         if (m_frameMenuBar)
         {
             int xx = m_miniEdge;
         if (m_frameMenuBar)
         {
             int xx = m_miniEdge;


@@ -858,6 +917,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }

+#endif // wxUSE_MENUS

 
 #if wxUSE_TOOLBAR
         if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
 
 #if wxUSE_TOOLBAR
         if ((m_frameToolBar) && m_frameToolBar->IsShown() &&


@@ -865,6 +925,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
         {
             int xx = m_miniEdge;
             int yy = m_miniEdge + m_miniTitle;
         {
             int xx = m_miniEdge;
             int yy = m_miniEdge + m_miniTitle;

+#if wxUSE_MENUS

             if (m_frameMenuBar)
             {
                 if (!m_menuBarDetached)
             if (m_frameMenuBar)
             {
                 if (!m_menuBarDetached)


@@ -872,6 +933,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                 else
                     yy += wxPLACE_HOLDER;
             }
                 else
                     yy += wxPLACE_HOLDER;
             }

+#endif // wxUSE_MENUS

 
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;
 
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;


@@ -931,7 +993,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                             xx, yy, ww, hh );
         gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
     }
                             xx, yy, ww, hh );
         gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
     }

-#endif
+#endif // wxUSE_STATUSBAR

 
     m_sizeSet = TRUE;
 
 
     m_sizeSet = TRUE;
 


@@ -940,6 +1002,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( event );
 
     event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( event );
 

+#if wxUSE_STATUSBAR

     // send size event to status bar
     if (m_frameStatusBar)
     {
     // send size event to status bar
     if (m_frameStatusBar)
     {


@@ -947,11 +1010,12 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
         event2.SetEventObject( m_frameStatusBar );
         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
     }
         event2.SetEventObject( m_frameStatusBar );
         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
     }

+#endif // wxUSE_STATUSBAR

 
     m_resizing = FALSE;
 }
 
 
     m_resizing = FALSE;
 }
 

-void wxFrame::MakeModal( bool modal )
+void wxFrameGTK::MakeModal( bool modal )

 {
     if (modal)
         gtk_grab_add( m_widget );
 {
     if (modal)
         gtk_grab_add( m_widget );


@@ -959,7 +1023,7 @@ void wxFrame::MakeModal( bool modal )
         gtk_grab_remove( m_widget );
 }
 
         gtk_grab_remove( m_widget );
 }
 

-void wxFrame::OnInternalIdle()
+void wxFrameGTK::OnInternalIdle()

 {
     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
     {
 {
     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
     {


@@ -971,7 +1035,9 @@ void wxFrame::OnInternalIdle()
         return;
     }
 
         return;
     }
 

+#if wxUSE_MENUS

     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();

+#endif // wxUSE_MENUS

 #if wxUSE_TOOLBAR
     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 #endif
 #if wxUSE_TOOLBAR
     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 #endif


@@ -986,15 +1052,14 @@ void wxFrame::OnInternalIdle()
 // menu/tool/status bar stuff
 // ----------------------------------------------------------------------------
 
 // menu/tool/status bar stuff
 // ----------------------------------------------------------------------------
 

-void wxFrame::SetMenuBar( wxMenuBar *menuBar )
+#if wxUSE_MENUS_NATIVE
+
+void wxFrameGTK::DetachMenuBar()

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 

-    if (menuBar == m_frameMenuBar)
-        return;
-
-    if (m_frameMenuBar)
+    if ( m_frameMenuBar )

     {
         m_frameMenuBar->UnsetInvokingWindow( this );
 
     {
         m_frameMenuBar->UnsetInvokingWindow( this );
 


@@ -1012,7 +1077,12 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
         gtk_widget_unparent( m_frameMenuBar->m_widget );
     }
 
         gtk_widget_unparent( m_frameMenuBar->m_widget );
     }
 

-    m_frameMenuBar = menuBar;
+    wxFrameBase::DetachMenuBar();
+}
+
+void wxFrameGTK::AttachMenuBar( wxMenuBar *menuBar )
+{
+    wxFrameBase::AttachMenuBar(menuBar);

 
     if (m_frameMenuBar)
     {
 
     if (m_frameMenuBar)
     {


@@ -1042,8 +1112,11 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
     m_sizeSet = FALSE;
 }
 
     m_sizeSet = FALSE;
 }
 

+#endif // wxUSE_MENUS_NATIVE
+

 #if wxUSE_TOOLBAR
 #if wxUSE_TOOLBAR

-wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
+
+wxToolBar* wxFrameGTK::CreateToolBar( long style, wxWindowID id, const wxString& name )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 


@@ -1058,7 +1131,7 @@ wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& na
     return m_frameToolBar;
 }
 
     return m_frameToolBar;
 }
 

-void wxFrame::SetToolBar(wxToolBar *toolbar)
+void wxFrameGTK::SetToolBar(wxToolBar *toolbar)

 {
     wxFrameBase::SetToolBar(toolbar);
 
 {
     wxFrameBase::SetToolBar(toolbar);
 


@@ -1080,7 +1153,7 @@ void wxFrame::SetToolBar(wxToolBar *toolbar)
 
 #if wxUSE_STATUSBAR
 
 
 #if wxUSE_STATUSBAR
 

-wxStatusBar* wxFrame::CreateStatusBar(int number,
+wxStatusBar* wxFrameGTK::CreateStatusBar(int number,

                                       long style,
                                       wxWindowID id,
                                       const wxString& name)
                                       long style,
                                       wxWindowID id,
                                       const wxString& name)


@@ -1093,7 +1166,7 @@ wxStatusBar* wxFrame::CreateStatusBar(int number,
     return wxFrameBase::CreateStatusBar( number, style, id, name );
 }
 
     return wxFrameBase::CreateStatusBar( number, style, id, name );
 }
 

-void wxFrame::PositionStatusBar()
+void wxFrameGTK::PositionStatusBar()

 {
     if ( !m_frameStatusBar )
         return;
 {
     if ( !m_frameStatusBar )
         return;


@@ -1106,7 +1179,7 @@ void wxFrame::PositionStatusBar()
 // frame title/icon
 // ----------------------------------------------------------------------------
 
 // frame title/icon
 // ----------------------------------------------------------------------------
 

-void wxFrame::SetTitle( const wxString &title )
+void wxFrameGTK::SetTitle( const wxString &title )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 


@@ -1114,7 +1187,7 @@ void wxFrame::SetTitle( const wxString &title )
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 }
 
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 }
 

-void wxFrame::SetIcon( const wxIcon &icon )
+void wxFrameGTK::SetIcon( const wxIcon &icon )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 


@@ -1137,34 +1210,50 @@ void wxFrame::SetIcon( const wxIcon &icon )
 // frame state: maximized/iconized/normal
 // ----------------------------------------------------------------------------
 
 // frame state: maximized/iconized/normal
 // ----------------------------------------------------------------------------
 

-void wxFrame::Maximize(bool WXUNUSED(maximize))
+void wxFrameGTK::Maximize(bool WXUNUSED(maximize))

 {
     wxFAIL_MSG( _T("not implemented") );
 }
 
 {
     wxFAIL_MSG( _T("not implemented") );
 }
 

-bool wxFrame::IsMaximized() const
+bool wxFrameGTK::IsMaximized() const

 {
 {

-    wxFAIL_MSG( _T("not implemented") );
+  //    wxFAIL_MSG( _T("not implemented") );

 
 

+    // This is an approximation

     return FALSE;
 }
 
     return FALSE;
 }
 

-void wxFrame::Restore()
+void wxFrameGTK::Restore()

 {
     wxFAIL_MSG( _T("not implemented") );
 }
 
 {
     wxFAIL_MSG( _T("not implemented") );
 }
 

-void wxFrame::Iconize( bool iconize )
+void wxFrameGTK::Iconize( bool iconize )

 {
    if (iconize)
    {
 {
    if (iconize)
    {

-        XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
-                        GDK_WINDOW_XWINDOW( m_widget->window ),
-                        DefaultScreen( GDK_DISPLAY() ) );
+       GdkWindow *window = m_widget->window;
+
+       // you should do it later, for example from OnCreate() handler
+       wxCHECK_RET( window, _T("frame not created yet - can't iconize") );
+
+       XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
+                       GDK_WINDOW_XWINDOW( window ),
+                       DefaultScreen( GDK_DISPLAY() ) );

    }
 }
 
    }
 }
 

-bool wxFrame::IsIconized() const
+bool wxFrameGTK::IsIconized() const

 {
     return m_isIconized;
 }
 {
     return m_isIconized;
 }

+
+void wxFrameGTK::SetIconizeState(bool iconize)
+{
+    if ( iconize != m_isIconized )
+    {
+        m_isIconized = iconize;
+        (void)SendIconizeEvent(iconize);
+    }
+}
+