#define XIconifyWindow XICONIFYWINDOW
#endif
-#include "wx/frame.h"
+#include "wx/defs.h"
+
#include "wx/dialog.h"
#include "wx/control.h"
#include "wx/app.h"
// event tables
// ----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+#ifndef __WXUNIVERSAL__
+ IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif
// ----------------------------------------------------------------------------
// data
// "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();
// "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();
return TRUE;
}
+#if wxUSE_MENUS_NATIVE
+
//-----------------------------------------------------------------------------
// "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;
// "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;
win->GtkUpdateSize();
}
+#endif // wxUSE_MENUS_NATIVE
+
#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;
// "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();
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
-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)
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();
GdkEvent * WXUNUSED(event),
wxFrame *win )
{
- win->m_isIconized = FALSE;
+ win->SetIconizeState(FALSE);
}
//-----------------------------------------------------------------------------
GdkEvent * WXUNUSED(event),
wxFrame *win )
{
- win->m_isIconized = TRUE;
+ win->SetIconizeState(TRUE);
}
//-----------------------------------------------------------------------------
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);
-
+ GTK_SHADOW_NONE, &gdk_event->area, win->m_widget, "base", 0, 0, -1, -1);
+
return TRUE;
}
{
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);
+ 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. */
-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 */
- wxFrame* frame = (wxFrame*) parent;
+ wxFrameGTK* frame = (wxFrameGTK*) parent;
gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
GTK_WIDGET(child->m_widget),
child->m_x,
}
// ----------------------------------------------------------------------------
-// wxFrame creation
+// wxFrameGTK creation
// ----------------------------------------------------------------------------
-void wxFrame::Init()
+void wxFrameGTK::Init()
{
m_sizeSet = FALSE;
m_miniEdge = 0;
m_themeEnabled = TRUE;
}
-bool wxFrame::Create( wxWindow *parent,
+bool wxFrameGTK::Create( wxWindow *parent,
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 )
{
+ // 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;
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;
}
m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
-
+
if (style & wxFRAME_TOOL_WINDOW)
win_type = GTK_WINDOW_POPUP;
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() );
GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
#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 */
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
- 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 );
return TRUE;
}
-wxFrame::~wxFrame()
+wxFrameGTK::~wxFrameGTK()
{
m_isBeingDeleted = TRUE;
}
}
-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_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 );
-
+
m_windowStyle = wxSIMPLE_BORDER;
-
+
int x;
int y;
wxDisplaySize( &x, &y );
SetSize( 0, 0, x, y );
-
+
gtk_widget_realize( m_widget );
gtk_widget_show( m_widget );
}
{
gtk_widget_hide( m_widget );
gtk_widget_unrealize( m_widget );
-
+
m_windowStyle = m_fsSaveStyle;
-
+
SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
-
+
gtk_widget_realize( m_widget );
gtk_widget_show( m_widget );
}
-
+
return TRUE;
}
// overridden wxWindow methods
// ----------------------------------------------------------------------------
-bool wxFrame::Show( bool show )
+bool wxFrameGTK::Show( bool show )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
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") );
- /* 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 */
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)
{
+#if wxUSE_MENUS_NATIVE
/* menu bar */
if (m_frameMenuBar)
{
else
(*height) -= wxPLACE_HOLDER;
}
+#endif // wxUSE_MENUS_NATIVE
#if wxUSE_STATUSBAR
/* status bar */
}
}
-void wxFrame::DoSetClientSize( int width, int height )
+void wxFrameGTK::DoSetClientSize( int width, int height )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
+#if wxUSE_MENUS_NATIVE
/* menu bar */
if (m_frameMenuBar)
{
else
height += wxPLACE_HOLDER;
}
+#endif // wxUSE_MENUS_NATIVE
#if wxUSE_STATUSBAR
/* status bar */
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
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;
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
- 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 */
* 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_NATIVE
if (m_frameMenuBar)
{
int xx = m_miniEdge;
xx, yy, ww, hh );
client_area_y_offset += hh;
}
+#endif // wxUSE_MENUS_NATIVE
#if wxUSE_TOOLBAR
if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
{
int xx = m_miniEdge;
int yy = m_miniEdge + m_miniTitle;
+#if wxUSE_MENUS_NATIVE
if (m_frameMenuBar)
{
if (!m_menuBarDetached)
else
yy += wxPLACE_HOLDER;
}
+#endif // wxUSE_MENUS_NATIVE
m_frameToolBar->m_x = xx;
m_frameToolBar->m_y = yy;
xx, yy, ww, hh );
gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
}
-#endif
+#endif // wxUSE_STATUSBAR
m_sizeSet = TRUE;
event.SetEventObject( this );
GetEventHandler()->ProcessEvent( event );
+#if wxUSE_STATUSBAR
// send size event to status bar
if (m_frameStatusBar)
{
event2.SetEventObject( m_frameStatusBar );
m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
}
+#endif // wxUSE_STATUSBAR
m_resizing = FALSE;
}
-void wxFrame::MakeModal( bool modal )
+void wxFrameGTK::MakeModal( bool modal )
{
if (modal)
gtk_grab_add( m_widget );
gtk_grab_remove( m_widget );
}
-void wxFrame::OnInternalIdle()
+void wxFrameGTK::OnInternalIdle()
{
if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
{
return;
}
+#if wxUSE_MENUS_NATIVE
if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
+#endif // wxUSE_MENUS_NATIVE
#if wxUSE_TOOLBAR
if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
#endif
// 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") );
- if (menuBar == m_frameMenuBar)
- return;
-
- if (m_frameMenuBar)
+ if ( m_frameMenuBar )
{
m_frameMenuBar->UnsetInvokingWindow( this );
gtk_widget_unparent( m_frameMenuBar->m_widget );
}
- m_frameMenuBar = menuBar;
+ wxFrameBase::DetachMenuBar();
+}
+
+void wxFrameGTK::AttachMenuBar( wxMenuBar *menuBar )
+{
+ wxFrameBase::AttachMenuBar(menuBar);
if (m_frameMenuBar)
{
m_sizeSet = FALSE;
}
+#endif // wxUSE_MENUS_NATIVE
+
#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") );
return m_frameToolBar;
}
-void wxFrame::SetToolBar(wxToolBar *toolbar)
+void wxFrameGTK::SetToolBar(wxToolBar *toolbar)
{
wxFrameBase::SetToolBar(toolbar);
#if wxUSE_STATUSBAR
-wxStatusBar* wxFrame::CreateStatusBar(int number,
+wxStatusBar* wxFrameGTK::CreateStatusBar(int number,
long style,
wxWindowID id,
const wxString& name)
return wxFrameBase::CreateStatusBar( number, style, id, name );
}
-void wxFrame::PositionStatusBar()
+void wxFrameGTK::PositionStatusBar()
{
if ( !m_frameStatusBar )
return;
// frame title/icon
// ----------------------------------------------------------------------------
-void wxFrame::SetTitle( const wxString &title )
+void wxFrameGTK::SetTitle( const wxString &title )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
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") );
// frame state: maximized/iconized/normal
// ----------------------------------------------------------------------------
-void wxFrame::Maximize(bool WXUNUSED(maximize))
+void wxFrameGTK::Maximize(bool WXUNUSED(maximize))
{
wxFAIL_MSG( _T("not implemented") );
}
-bool wxFrame::IsMaximized() const
+bool wxFrameGTK::IsMaximized() const
{
// wxFAIL_MSG( _T("not implemented") );
return FALSE;
}
-void wxFrame::Restore()
+void wxFrameGTK::Restore()
{
wxFAIL_MSG( _T("not implemented") );
}
-void wxFrame::Iconize( bool iconize )
+void wxFrameGTK::Iconize( bool 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;
}
+
+void wxFrameGTK::SetIconizeState(bool iconize)
+{
+ if ( iconize != m_isIconized )
+ {
+ m_isIconized = iconize;
+ (void)SendIconizeEvent(iconize);
+ }
+}
+
projects / wxWidgets.git / blobdiff