// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
#ifdef __GNUG__
#pragma implementation "frame.h"
#endif
#include "wx/app.h"
#include "wx/menu.h"
#if wxUSE_TOOLBAR
-#include "wx/toolbar.h"
+ #include "wx/toolbar.h"
#endif
#if wxUSE_STATUSBAR
-#include "wx/statusbr.h"
+ #include "wx/statusbr.h"
#endif
#include "wx/dcclient.h"
-#include "glib.h"
-#include "gdk/gdk.h"
-#include "gtk/gtk.h"
+#include <glib.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+
#include "wx/gtk/win_gtk.h"
-#include "gdk/gdkkeysyms.h"
-#include "gdk/gdkx.h"
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// constants
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
const int wxMENU_HEIGHT = 27;
const int wxSTATUS_HEIGHT = 25;
const int wxPLACE_HOLDER = 0;
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// idle system
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
extern void wxapp_install_idle_handler();
extern bool g_isIdle;
+extern int g_openDialogs;
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// event tables
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+
+// ----------------------------------------------------------------------------
// data
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
extern wxList wxPendingDelete;
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// debug
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
#endif
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// GTK callbacks
+// ----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// "focus" from m_window
+//-----------------------------------------------------------------------------
+
+static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
+{
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ // This disables GTK's tab traversal
+ gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
+ return TRUE;
+}
+
//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------
(int)alloc->width,
(int)alloc->height );
*/
-
+
win->m_width = alloc->width;
win->m_height = alloc->height;
- win->UpdateSize();
+ win->m_queuedFullRedraw = TRUE;
+ win->GtkUpdateSize();
}
}
if (g_isIdle)
wxapp_install_idle_handler();
- win->Close();
+ if ((g_openDialogs == 0) && (win->IsEnabled()))
+ win->Close();
return TRUE;
}
if (!win->m_hasVMT) return;
win->m_menuBarDetached = FALSE;
- win->UpdateSize();
+ win->GtkUpdateSize();
}
//-----------------------------------------------------------------------------
if (!win->m_hasVMT) return;
win->m_menuBarDetached = TRUE;
- win->UpdateSize();
+ win->GtkUpdateSize();
}
#if wxUSE_TOOLBAR
win->m_toolBarDetached = FALSE;
- win->UpdateSize();
+ win->GtkUpdateSize();
}
//-----------------------------------------------------------------------------
if (!win->m_hasVMT) return;
win->m_toolBarDetached = TRUE;
- win->UpdateSize();
+ win->GtkUpdateSize();
}
#endif // wxUSE_TOOLBAR
// "configure_event"
//-----------------------------------------------------------------------------
-static gint
-#if (GTK_MINOR_VERSON > 0)
+static gint
+#if (GTK_MINOR_VERSION > 0)
gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
#else
gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
#endif
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
- if (!win->m_hasVMT) return FALSE;
+ if (!win->m_hasVMT)
+ return FALSE;
-#if (GTK_MINOR_VERSON > 0)
+#if (GTK_MINOR_VERSION > 0)
int x = 0;
int y = 0;
gdk_window_get_root_origin( win->m_widget->window, &x, &y );
so we do this directly after realization */
static gint
-gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
+gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )
{
if (g_isIdle)
wxapp_install_idle_handler();
- /* I haven't been able to set the position of
- the dialog before it is shown, so I set the
- position in "realize" */
- gtk_widget_set_uposition( widget, win->m_x, win->m_y );
-
- /* all this is for Motif Window Manager "hints" and is supposed to be
- recognized by other WM as well. not tested. */
- long decor = (long) GDK_DECOR_BORDER;
- long func = (long) GDK_FUNC_MOVE;
-
- if ((win->GetWindowStyle() & wxCAPTION) != 0)
- decor |= GDK_DECOR_TITLE;
- if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
- {
- decor |= GDK_DECOR_MENU;
- func |= GDK_FUNC_CLOSE;
- }
- if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
+ if ((win->m_miniEdge > 0) || (win->HasFlag(wxSIMPLE_BORDER)))
{
- func |= GDK_FUNC_MINIMIZE;
- decor |= GDK_DECOR_MINIMIZE;
+ /* This is a mini-frame or a borderless frame. */
+ gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)0 );
+ gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)0 );
}
- if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
- {
- func |= GDK_FUNC_MAXIMIZE;
- decor |= GDK_DECOR_MAXIMIZE;
- }
- if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
+ else
{
- func |= GDK_FUNC_RESIZE;
- decor |= GDK_DECOR_RESIZEH;
- }
+ /* All this is for Motif Window Manager "hints" and is supposed to be
+ recognized by other WM as well. Not tested. */
+ long decor = (long) GDK_DECOR_BORDER;
+ long func = (long) GDK_FUNC_MOVE;
+
+ if ((win->GetWindowStyle() & wxCAPTION) != 0)
+ decor |= GDK_DECOR_TITLE;
+ if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
+ {
+ decor |= GDK_DECOR_MENU;
+ func |= GDK_FUNC_CLOSE;
+ }
+ if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
+ {
+ func |= GDK_FUNC_MINIMIZE;
+ decor |= GDK_DECOR_MINIMIZE;
+ }
+ if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
+ {
+ func |= GDK_FUNC_MAXIMIZE;
+ decor |= GDK_DECOR_MAXIMIZE;
+ }
+ if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
+ {
+ func |= GDK_FUNC_RESIZE;
+ decor |= GDK_DECOR_RESIZEH;
+ }
- gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
- gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+ gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+ gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+ }
/* GTK's shrinking/growing policy */
if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
- /* set size hints */
- gint flag = 0; // GDK_HINT_POS;
- if ((win->GetMinWidth() != -1) || (win->GetMinHeight() != -1)) flag |= GDK_HINT_MIN_SIZE;
- if ((win->GetMaxWidth() != -1) || (win->GetMaxHeight() != -1)) flag |= GDK_HINT_MAX_SIZE;
- if (flag)
- {
- gdk_window_set_hints( win->m_widget->window,
- win->m_x, win->m_y,
- win->GetMinWidth(), win->GetMinHeight(),
- win->GetMaxWidth(), win->GetMaxHeight(),
- flag );
- }
-
/* reset the icon */
- if (win->m_icon != wxNullIcon)
+ wxIcon iconOld = win->GetIcon();
+ if ( iconOld != wxNullIcon )
{
- wxIcon icon( win->m_icon );
- win->m_icon = wxNullIcon;
+ wxIcon icon( iconOld );
+ win->SetIcon( wxNullIcon );
win->SetIcon( icon );
}
return FALSE;
}
+// ----------------------------------------------------------------------------
+// wxFrame itself
+// ----------------------------------------------------------------------------
+
//-----------------------------------------------------------------------------
// InsertChild for wxFrame
//-----------------------------------------------------------------------------
static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
{
wxASSERT( GTK_IS_WIDGET(child->m_widget) );
-
+
if (!parent->m_insertInClientArea)
{
/* these are outside the client area */
child->m_width,
child->m_height );
-#if wxUSE_TOOLBAR
+#if wxUSE_TOOLBAR_NATIVE
/* we connect to these events for recalculating the client area
space when the toolbar is floating */
if (wxIS_KIND_OF(child,wxToolBar))
}
/* resize on OnInternalIdle */
- parent->UpdateSize();
+ parent->GtkUpdateSize();
}
-//-----------------------------------------------------------------------------
-// wxFrame
-//-----------------------------------------------------------------------------
-
-BEGIN_EVENT_TABLE(wxFrame, wxWindow)
- EVT_SIZE(wxFrame::OnSize)
- EVT_IDLE(wxFrame::OnIdle)
- EVT_CLOSE(wxFrame::OnCloseWindow)
- EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
-END_EVENT_TABLE()
-
-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+// ----------------------------------------------------------------------------
+// wxFrame creation
+// ----------------------------------------------------------------------------
void wxFrame::Init()
{
- m_frameMenuBar = (wxMenuBar *) NULL;
-#if wxUSE_STATUSBAR
- m_frameStatusBar = (wxStatusBar *) NULL;
-#endif // wxUSE_STATUSBAR
-#if wxUSE_TOOLBAR
- m_frameToolBar = (wxToolBar *) NULL;
-#endif // wxUSE_TOOLBAR
m_sizeSet = FALSE;
m_miniEdge = 0;
m_miniTitle = 0;
m_menuBarDetached = FALSE;
m_toolBarDetached = FALSE;
m_insertInClientArea = TRUE;
- m_isFrame = TRUE;
-}
-
-wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- Init();
-
- Create( parent, id, title, pos, size, style, name );
}
-bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+bool wxFrame::Create( wxWindow *parent,
+ wxWindowID id,
+ const wxString &title,
+ const wxPoint &pos,
+ const wxSize &size,
+ long style,
+ const wxString &name )
{
wxTopLevelWindows.Append( this );
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxFrame creation failed") );
- return FALSE;
+ return FALSE;
}
m_title = title;
m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
- GtkWindowType win_type = GTK_WINDOW_DIALOG; // this makes window placement work
- if (style & wxSIMPLE_BORDER) win_type = GTK_WINDOW_POPUP;
+ GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
m_widget = gtk_window_new( win_type );
+ if ((m_parent) && (HasFlag(wxFRAME_FLOAT_ON_PARENT)) && (GTK_IS_WINDOW(m_parent->m_widget)))
+ gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
+
if (!name.IsEmpty())
gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
PostCreation();
+ if ((m_x != -1) || (m_y != -1))
+ gtk_widget_set_uposition( m_widget, m_x, m_y );
+ gtk_widget_set_usize( m_widget, m_width, m_height );
+
/* we cannot set MWM hints and icons before the widget has
been realized, so we do this directly after realization */
gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
+ /* disable native tab traversal */
+ gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
+ GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
+
return TRUE;
}
{
m_isBeingDeleted = TRUE;
- if (m_frameMenuBar) delete m_frameMenuBar;
- m_frameMenuBar = (wxMenuBar *) NULL;
-
-#if wxUSE_STATUSBAR
- if (m_frameStatusBar) delete m_frameStatusBar;
- m_frameStatusBar = (wxStatusBar *) NULL;
-#endif // wxUSE_STATUSBAR
-
-#if wxUSE_TOOLBAR
- if (m_frameToolBar) delete m_frameToolBar;
- m_frameToolBar = (wxToolBar *) NULL;
-#endif // wxUSE_TOOLBAR
+ DeleteAllBars();
wxTopLevelWindows.DeleteObject( this );
if (wxTheApp->GetTopWindow() == this)
wxTheApp->SetTopWindow( (wxWindow*) NULL );
- if (wxTopLevelWindows.Number() == 0)
+ if ((wxTopLevelWindows.Number() == 0) &&
+ (wxTheApp->GetExitOnFrameDelete()))
+ {
wxTheApp->ExitMainLoop();
+ }
}
+// ----------------------------------------------------------------------------
+// overridden wxWindow methods
+// ----------------------------------------------------------------------------
+
bool wxFrame::Show( bool show )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
return wxWindow::Show( show );
}
-bool wxFrame::Destroy()
+void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
- if (!wxPendingDelete.Member(this)) wxPendingDelete.Append(this);
-
- return TRUE;
+ wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );
}
void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
/* avoid recursions */
- if (m_resizing) return;
+ if (m_resizing)
+ return;
m_resizing = TRUE;
int old_x = m_x;
int old_y = m_y;
+
int old_width = m_width;
int old_height = m_height;
if ((m_width != old_width) || (m_height != old_height))
{
+ gtk_widget_set_usize( m_widget, m_width, m_height );
+
/* we set the size in GtkOnSize, i.e. mostly the actual resizing is
done either directly before the frame is shown or in idle time
so that different calls to SetSize() don't lead to flicker. */
m_resizing = FALSE;
}
-void wxFrame::Centre( int direction )
-{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
- int x = 0;
- int y = 0;
-
- if ((direction & wxHORIZONTAL) == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
- if ((direction & wxVERTICAL) == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
-
- Move( x, y );
-}
-
void wxFrame::DoGetClientSize( int *width, int *height ) const
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
#if wxUSE_STATUSBAR
/* status bar */
if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
-#endif
+#endif // wxUSE_STATUSBAR
#if wxUSE_TOOLBAR
/* tool bar */
if (m_frameToolBar)
{
- if (!m_toolBarDetached)
+ if (m_toolBarDetached)
{
- int y = 0;
- m_frameToolBar->GetSize( (int *) NULL, &y );
- (*height) -= y;
+ *height -= wxPLACE_HOLDER;
}
else
- (*height) -= wxPLACE_HOLDER;
+ {
+ int x, y;
+ m_frameToolBar->GetSize( &x, &y );
+ if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+ {
+ *width -= x;
+ }
+ else
+ {
+ *height -= y;
+ }
+ }
}
-#endif
+#endif // wxUSE_TOOLBAR
/* mini edge */
- (*height) -= m_miniEdge*2 + m_miniTitle;
+ *height -= m_miniEdge*2 + m_miniTitle;
}
if (width)
{
- (*width) -= m_miniEdge*2;
+ *width -= m_miniEdge*2;
}
}
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- printf( "set size %d %d\n", width, height );
-
/* menu bar */
if (m_frameMenuBar)
{
/* tool bar */
if (m_frameToolBar)
{
- if (!m_toolBarDetached)
+ if (m_toolBarDetached)
{
- int y = 0;
- m_frameToolBar->GetSize( (int *) NULL, &y );
- height += y;
+ height += wxPLACE_HOLDER;
}
else
- height += wxPLACE_HOLDER;
+ {
+ int x, y;
+ m_frameToolBar->GetSize( &x, &y );
+ if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+ {
+ width += x;
+ }
+ else
+ {
+ height += y;
+ }
+ }
}
#endif
DoSetSize( -1, -1, width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0 );
}
-void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
+void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
+ int width, int height )
{
// due to a bug in gtk, x,y are always 0
// m_x = x;
m_width = width;
m_height = height;
-
+
/* space occupied by m_frameToolBar and m_frameMenuBar */
- int 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
wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
skip the part which handles m_frameMenuBar, m_frameToolBar and (most
importantly) m_mainWidget */
+ if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
+ if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
+ if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
+ if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
+
if (m_mainWidget)
{
- /* check if size is in legal range */
- if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
- if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
- if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
- if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
+ /* set size hints */
+ gint flag = 0; // GDK_HINT_POS;
+ if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
+ if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
+ GdkGeometry geom;
+ geom.min_width = m_minWidth;
+ geom.min_height = m_minHeight;
+ geom.max_width = m_maxWidth;
+ geom.max_height = m_maxHeight;
+ gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
+ (GtkWidget*) NULL,
+ &geom,
+ (GdkWindowHints) flag );
/* I revert back to wxGTK's original behaviour. m_mainWidget holds the
* menubar, the toolbar and the client area, which is represented by
#if wxUSE_TOOLBAR
if ((m_frameToolBar) &&
- (m_frameToolBar->m_widget->parent == m_mainWidget))
+ (m_frameToolBar->m_widget->parent == m_mainWidget))
{
int xx = m_miniEdge;
int yy = m_miniEdge + m_miniTitle;
else
yy += wxPLACE_HOLDER;
}
- int ww = m_width - 2*m_miniEdge;
- int hh = m_frameToolBar->m_height;
- if (m_toolBarDetached) hh = wxPLACE_HOLDER;
+
m_frameToolBar->m_x = xx;
m_frameToolBar->m_y = yy;
- /* m_frameToolBar->m_height = hh; don't change the toolbar's reported size
- m_frameToolBar->m_width = ww; */
+
+ /* don't change the toolbar's reported height/width */
+ int ww, hh;
+ if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+ {
+ ww = m_toolBarDetached ? wxPLACE_HOLDER
+ : m_frameToolBar->m_width;
+ hh = m_height - 2*m_miniEdge;
+
+ client_area_x_offset += ww;
+ }
+ else
+ {
+ ww = m_width - 2*m_miniEdge;
+ hh = m_toolBarDetached ? wxPLACE_HOLDER
+ : m_frameToolBar->m_height;
+
+ client_area_y_offset += hh;
+ }
+
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameToolBar->m_widget,
xx, yy, ww, hh );
- client_area_y_offset += hh;
}
-#endif
+#endif // wxUSE_TOOLBAR
- int client_x = m_miniEdge;
+ int client_x = client_area_x_offset + m_miniEdge;
int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
- int client_w = m_width - 2*m_miniEdge;
+ int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_wxwindow,
m_frameStatusBar->m_width = ww;
m_frameStatusBar->m_height = hh;
gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
- m_frameStatusBar->m_widget,
- xx, yy, ww, hh );
+ m_frameStatusBar->m_widget,
+ xx, yy, ww, hh );
+ gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
}
#endif
- /* we actually set the size of a frame here and no-where else */
- gtk_widget_set_usize( m_widget, m_width, m_height );
-
-
m_sizeSet = TRUE;
-
+
// send size event to frame
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
{
GtkOnSize( m_x, m_y, m_width, m_height );
-
- // we'll come back later
+
+ // we'll come back later
if (g_isIdle)
wxapp_install_idle_handler();
- return;
+ return;
}
if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
wxWindow::OnInternalIdle();
}
-void wxFrame::OnCloseWindow( wxCloseEvent& WXUNUSED(event) )
-{
- Destroy();
-}
+// ----------------------------------------------------------------------------
+// menu/tool/status bar stuff
+// ----------------------------------------------------------------------------
-void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
+void wxFrame::SetMenuBar( wxMenuBar *menuBar )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
+ wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
-#if wxUSE_CONSTRAINTS
- if (GetAutoLayout())
- {
- Layout();
- }
- else
-#endif // wxUSE_CONSTRAINTS
+ if (menuBar == m_frameMenuBar)
+ return;
+
+ if (m_frameMenuBar)
{
- /* do we have exactly one child? */
- wxWindow *child = (wxWindow *)NULL;
- for ( wxNode *node = GetChildren().First(); node; node = node->Next() )
+ m_frameMenuBar->UnsetInvokingWindow( this );
+
+ if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
{
- wxWindow *win = (wxWindow *)node->Data();
- if ( !wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog) )
- {
- if (child)
- {
- /* it's the second one: do nothing */
- return;
- }
+ gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
+ GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
- child = win;
- }
+ gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
+ GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
}
- /* no children at all? */
- if (child)
- {
- /* yes: set it's size to fill all the frame */
- int client_x, client_y;
- DoGetClientSize( &client_x, &client_y );
- child->SetSize( 1, 1, client_x-2, client_y-2 );
- }
+ gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
+ gtk_widget_ref( m_frameMenuBar->m_widget );
+ gtk_widget_unparent( m_frameMenuBar->m_widget );
}
-}
-
-void wxFrame::SetMenuBar( wxMenuBar *menuBar )
-{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
m_frameMenuBar = menuBar;
{
m_frameMenuBar->SetInvokingWindow( this );
- if (m_frameMenuBar->GetParent() != this)
- {
- m_frameMenuBar->SetParent(this);
- gtk_pizza_put( GTK_PIZZA(m_mainWidget),
+ m_frameMenuBar->SetParent(this);
+ gtk_pizza_put( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->m_x,
m_frameMenuBar->m_y,
m_frameMenuBar->m_width,
m_frameMenuBar->m_height );
- if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
- {
- gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
- GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
+ if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
+ {
+ gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
+ GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
- gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
- GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
- }
-
- m_frameMenuBar->Show( TRUE );
+ gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
+ GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
}
+
+ m_frameMenuBar->Show( TRUE );
}
/* resize window in OnInternalIdle */
m_sizeSet = FALSE;
}
-wxMenuBar *wxFrame::GetMenuBar() const
-{
- return m_frameMenuBar;
-}
-
-void wxFrame::OnMenuHighlight(wxMenuEvent& event)
-{
-#if wxUSE_STATUSBAR
- if (GetStatusBar())
- {
- // if no help string found, we will clear the status bar text
- wxString helpString;
-
- int menuId = event.GetMenuId();
- if ( menuId != wxID_SEPARATOR && menuId != -2 /* wxID_TITLE */ )
- {
- wxMenuBar *menuBar = GetMenuBar();
- if ( menuBar )
- {
- // it's ok if we don't find the item because it might belong to
- // the popup menu
- wxMenuItem *item = menuBar->FindItem(menuId);
- if ( item )
- helpString = item->GetHelp();
- }
- }
-
- SetStatusText(helpString);
- }
-#endif // wxUSE_STATUSBAR
-}
-
#if wxUSE_TOOLBAR
wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- wxCHECK_MSG( m_frameToolBar == NULL, FALSE, wxT("recreating toolbar in wxFrame") );
-
m_insertInClientArea = FALSE;
- m_frameToolBar = OnCreateToolBar( style, id, name );
-
- if (m_frameToolBar) GetChildren().DeleteObject( m_frameToolBar );
+ m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
m_insertInClientArea = TRUE;
return m_frameToolBar;
}
-wxToolBar* wxFrame::OnCreateToolBar( long style, wxWindowID id, const wxString& name )
+void wxFrame::SetToolBar(wxToolBar *toolbar)
{
- return new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
-}
+ wxFrameBase::SetToolBar(toolbar);
-void wxFrame::SetToolBar(wxToolBar *toolbar)
-{
- m_frameToolBar = toolbar;
if (m_frameToolBar)
{
/* insert into toolbar area if not already there */
(m_frameToolBar->m_widget->parent != m_mainWidget))
{
GetChildren().DeleteObject( m_frameToolBar );
-
- gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
- UpdateSize();
- }
+
+ gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
+ GtkUpdateSize();
+ }
}
}
-wxToolBar *wxFrame::GetToolBar() const
-{
- return m_frameToolBar;
-}
#endif // wxUSE_TOOLBAR
#if wxUSE_STATUSBAR
-wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
-{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
- wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, wxT("recreating status bar in wxFrame") );
-
- m_frameStatusBar = OnCreateStatusBar( number, style, id, name );
-
- m_sizeSet = FALSE;
-
- return m_frameStatusBar;
-}
-wxStatusBar *wxFrame::OnCreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
-{
- wxStatusBar *statusBar = (wxStatusBar *) NULL;
-
- statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20), style, name);
-
- // Set the height according to the font and the border size
- wxClientDC dc(statusBar);
- dc.SetFont( statusBar->GetFont() );
-
- long x, y;
- dc.GetTextExtent( "X", &x, &y );
-
- int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY());
-
- statusBar->SetSize( -1, -1, 100, height );
-
- statusBar->SetFieldsCount( number );
- return statusBar;
-}
-
-wxStatusBar *wxFrame::GetStatusBar() const
-{
- return m_frameStatusBar;
-}
-
-void wxFrame::SetStatusText(const wxString& text, int number)
+wxStatusBar* wxFrame::CreateStatusBar(int number,
+ long style,
+ wxWindowID id,
+ const wxString& name)
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
+ // because it will change when toolbar is added
+ m_sizeSet = FALSE;
- m_frameStatusBar->SetStatusText(text, number);
+ return wxFrameBase::CreateStatusBar( number, style, id, name );
}
-void wxFrame::SetStatusWidths(int n, const int widths_field[] )
+void wxFrame::PositionStatusBar()
{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
- wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );
+ if ( !m_frameStatusBar )
+ return;
- m_frameStatusBar->SetStatusWidths(n, widths_field);
+ m_sizeSet = FALSE;
}
#endif // wxUSE_STATUSBAR
-void wxFrame::Command( int id )
-{
- wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, id);
- commandEvent.SetInt( id );
- commandEvent.SetEventObject( this );
-
- wxMenuBar *bar = GetMenuBar();
- if (!bar) return;
-
- wxMenuItem *item = bar->FindItem(id) ;
- if (item && item->IsCheckable())
- {
- bar->Check(id, !bar->IsChecked(id)) ;
- }
-
- wxEvtHandler* evtHandler = GetEventHandler();
-
- evtHandler->ProcessEvent(commandEvent);
-}
+// ----------------------------------------------------------------------------
+// frame title/icon
+// ----------------------------------------------------------------------------
void wxFrame::SetTitle( const wxString &title )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
m_title = title;
- if (m_title.IsNull()) m_title = wxT("");
gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
}
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- m_icon = icon;
- if (!icon.Ok()) return;
+ wxFrameBase::SetIcon(icon);
- if (!m_widget->window) return;
+ if ( !m_icon.Ok() )
+ return;
+
+ if (!m_widget->window)
+ return;
wxMask *mask = icon.GetMask();
GdkBitmap *bm = (GdkBitmap *) NULL;
gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
}
-void wxFrame::Maximize(bool WXUNUSED(maximize))
+// ----------------------------------------------------------------------------
+// frame state: maximized/iconized/normal (TODO)
+// ----------------------------------------------------------------------------
+
+void wxFrame::Maximize(bool WXUNUSED(maximize))
+{
+}
+
+bool wxFrame::IsMaximized() const
{
+ return FALSE;
}
-void wxFrame::Restore()
+void wxFrame::Restore()
{
}
-void wxFrame::Iconize( bool iconize )
-{
+void wxFrame::Iconize( bool iconize )
+{
if (iconize)
{
XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
- GDK_WINDOW_XWINDOW( m_widget->window ),
- DefaultScreen( GDK_DISPLAY() ) );
+ GDK_WINDOW_XWINDOW( m_widget->window ),
+ DefaultScreen( GDK_DISPLAY() ) );
}
}
-bool wxFrame::IsIconized() const
-{
- return FALSE;
+bool wxFrame::IsIconized() const
+{
+ return FALSE;
}
projects / wxWidgets.git / blobdiff