src/gtk1/frame.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        frame.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "frame.h"
#endif

#include "wx/frame.h"
#include "wx/dialog.h"
#include "wx/control.h"
#include "wx/app.h"
#include "wx/menu.h"
#include "wx/toolbar.h"
#include "wx/statusbr.h"
#include "wx/dcclient.h"

#include "glib.h"
#include "gdk/gdk.h"
#include "gtk/gtk.h"
#include "wx/gtk/win_gtk.h"

//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------

const int wxMENU_HEIGHT    = 27;
const int wxSTATUS_HEIGHT  = 25;

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

extern wxList wxTopLevelWindows;
extern wxList wxPendingDelete;

//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------

static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
{
    if (!win->HasVMT()) return;

/*
    printf( "OnFrameResize from " );
    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
        printf( win->GetClassInfo()->GetClassName() );
    printf( ".\n" );
*/

   if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
   {
       win->m_sizeSet = FALSE;
       win->m_width = alloc->width;
       win->m_height = alloc->height;
   }
}

//-----------------------------------------------------------------------------
// "delete_event"
//-----------------------------------------------------------------------------

static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
{
/*
    printf( "OnDelete from " );
    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
        printf( win->GetClassInfo()->GetClassName() );
    printf( ".\n" );
*/

    win->Close();

    return TRUE;
}

//-----------------------------------------------------------------------------
// "configure_event"
//-----------------------------------------------------------------------------

static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
{
    if (!win->HasVMT()) return FALSE;

    win->m_x = event->x;
    win->m_y = event->y;

    return FALSE;
}

//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxFrame, wxWindow)
    EVT_SIZE(wxFrame::OnSize)
    EVT_CLOSE(wxFrame::OnCloseWindow)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)

wxFrame::wxFrame()
{
    m_frameMenuBar = (wxMenuBar *) NULL;
    m_frameStatusBar = (wxStatusBar *) NULL;
    m_frameToolBar = (wxToolBar *) NULL;
    m_sizeSet = FALSE;
    m_miniEdge = 0;
    m_miniTitle = 0;
}

wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
      const wxPoint &pos, const wxSize &size,
      long style, const wxString &name )
{
    m_frameMenuBar = (wxMenuBar *) NULL;
    m_frameStatusBar = (wxStatusBar *) NULL;
    m_frameToolBar = (wxToolBar *) NULL;
    m_sizeSet = FALSE;
    m_miniEdge = 0;
    m_miniTitle = 0;
    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 )
{
    wxTopLevelWindows.Append( this );

    m_needParent = FALSE;

    PreCreation( parent, id, pos, size, style, name );

    m_title = title;

    GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
    if (style & wxSIMPLE_BORDER) win_type = GTK_WINDOW_POPUP;

    m_widget = gtk_window_new( win_type );

#ifdef __WXDEBUG__
        debug_focus_in( m_widget, "wxFrame::m_widget", name );
#endif

    if ((size.x != -1) && (size.y != -1))
        gtk_widget_set_usize( m_widget, m_width, m_height );
    if ((pos.x != -1) && (pos.y != -1))
        gtk_widget_set_uposition( m_widget, m_x, m_y );

    gtk_window_set_title( GTK_WINDOW(m_widget), title );
    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );

    gtk_widget_set( m_widget, "GtkWindow::allow_shrink", TRUE, NULL );

    gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
        GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );

    m_wxwindow = gtk_myfixed_new();
    gtk_widget_show( m_wxwindow );
    GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

#ifdef __WXDEBUG__
        debug_focus_in( m_wxwindow, "wxFrame::m_wxwindow", name );
#endif

    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );

    gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
        GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );

    gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
        GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );

    if (m_parent) m_parent->AddChild( this );

    PostCreation();

    return TRUE;
}

wxFrame::~wxFrame()
{
    if (m_frameMenuBar) delete m_frameMenuBar;
    if (m_frameStatusBar) delete m_frameStatusBar;
    if (m_frameToolBar) delete m_frameToolBar;

    wxTopLevelWindows.DeleteObject( this );

    if (wxTheApp->GetTopWindow() == this)
    {
        wxTheApp->SetTopWindow( (wxWindow*) NULL );
    }

    if (wxTopLevelWindows.Number() == 0)
    {
        wxTheApp->ExitMainLoop();
    }
}

bool wxFrame::Show( bool show )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    if (show && !m_sizeSet)
    {
  // by calling GtkOnSize here, we don't have to call
  // either after showing the frame, which would entail
  // much ugly flicker nor from within the size_allocate
  // handler, because GTK 1.1.X forbids that.

        GtkOnSize( m_x, m_y, m_width, m_height );
    }

    return wxWindow::Show( show );
}

void wxFrame::OnCloseWindow( wxCloseEvent &event )
{
    if (GetEventHandler()->OnClose() || event.GetForce()) this->Destroy();
}

bool wxFrame::Destroy()
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    if (!wxPendingDelete.Member(this)) wxPendingDelete.Append(this);

    return TRUE;
}

wxPoint wxFrame::GetClientAreaOrigin() const
{
    wxPoint pt( m_miniEdge, m_miniEdge + m_miniTitle );
    if (m_frameMenuBar)
    {
        int h = 0;
        m_frameMenuBar->GetSize( (int*)NULL, &h );
        pt.y += h;
    }
    if (m_frameToolBar)
    {
        int h = 0;
        m_frameToolBar->GetSize( (int*)NULL, &h );
        pt.y += h;
    }
    return pt;
}

void wxFrame::SetSize( int x, int y, int width, int height, int sizeFlags )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid window" );

    // Don't do anything for children of wxMDIChildFrame
    if (!m_wxwindow) return;

    if (m_resizing) return; // I don't like recursions
    m_resizing = TRUE;

    int old_x = m_x;
    int old_y = m_y;
    int old_width = m_width;
    int old_height = m_height;

    if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
    {
        if (x != -1) m_x = x;
        if (y != -1) m_y = y;
        if (width != -1) m_width = width;
        if (height != -1) m_height = height;
    }
    else
    {
        m_x = x;
        m_y = y;
        m_width = width;
        m_height = height;
    }

    if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
    {
        if (width == -1) m_width = 80;
    }

    if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
    {
       if (height == -1) m_height = 26;
    }

    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_minWidth;
    if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight;

    if ((m_x != -1) || (m_y != -1))
    {
        if ((m_x != old_x) || (m_y != old_y))
            gtk_widget_set_uposition( m_widget, m_x, m_y );
    }

    if ((m_width != old_width) || (m_height != old_height))
    {
        gtk_widget_set_usize( m_widget, m_width, m_height );
    }

    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
    event.SetEventObject( this );
    GetEventHandler()->ProcessEvent( event );

    m_resizing = FALSE;
}

void wxFrame::SetSize( int width, int height )
{
    SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
}

void wxFrame::Centre( int direction )
{
    wxASSERT_MSG( (m_widget != NULL), "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::GetClientSize( int *width, int *height ) const
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    wxWindow::GetClientSize( width, height );
    if (height)
    {
        if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
        if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
        if (m_frameToolBar)
        {
            int y = 0;
            m_frameToolBar->GetSize( (int *) NULL, &y );
            (*height) -= y;
        }
        (*height) -= m_miniEdge*2 + m_miniTitle;
    }
    if (width)
    {
        (*width) -= m_miniEdge*2;
    }
}

void wxFrame::SetClientSize( int const width, int const height )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    int h = height;
    if (m_frameMenuBar) h += wxMENU_HEIGHT;
    if (m_frameStatusBar) h += wxSTATUS_HEIGHT;
    if (m_frameToolBar)
    {
        int y = 0;
        m_frameToolBar->GetSize( (int *) NULL, &y );
        h += y;
    }
    wxWindow::SetClientSize( width + m_miniEdge*2, h  + m_miniEdge*2 + m_miniTitle );
}

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_y = y;

    if (m_resizing) return;
    m_resizing = TRUE;

    if (!m_wxwindow) return;

    m_width = width;
    m_height = height;

    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_minWidth;
    if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight;

    gtk_widget_set_usize( m_widget, m_width, m_height );

    // this emulates the new wxMSW behaviour of placing all
    // frame-subwindows (menu, toolbar..) on one native window
        // OK, 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 (m_frameMenuBar)
    {
        int xx = m_miniEdge;
        int yy = m_miniEdge + m_miniTitle;
        int ww = m_width  - 2*m_miniEdge;
        int hh = wxMENU_HEIGHT;
        m_frameMenuBar->m_x = xx;
        m_frameMenuBar->m_y = yy;
        m_frameMenuBar->m_width = ww;
        m_frameMenuBar->m_height = hh;

        gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameMenuBar->m_widget, xx, yy );
        gtk_widget_set_usize( m_frameMenuBar->m_widget, ww, hh );
    }

    if (m_frameToolBar)
    {
        int xx = m_miniEdge;
        int yy = m_miniEdge + m_miniTitle;
        if (m_frameMenuBar) yy += wxMENU_HEIGHT;
        int ww = m_width - 2*m_miniEdge;
        int hh = m_frameToolBar->m_height;

        m_frameToolBar->m_x = xx;
        m_frameToolBar->m_y = yy;
        m_frameToolBar->m_height = hh;
        m_frameToolBar->m_width = ww;

        gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameToolBar->m_widget, xx, yy );
        gtk_widget_set_usize( m_frameToolBar->m_widget, ww, hh );
    }

    if (m_frameStatusBar)
    {
        int xx = 0 + m_miniEdge;
        int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge;
        int ww = m_width - 2*m_miniEdge;
        int hh = wxSTATUS_HEIGHT;

        m_frameStatusBar->m_x = xx;
        m_frameStatusBar->m_y = yy;
        m_frameStatusBar->m_width = ww;
        m_frameStatusBar->m_height = hh;

        gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameStatusBar->m_widget, xx, yy );
        gtk_widget_set_usize( m_frameStatusBar->m_widget, ww, hh );
    }

    m_sizeSet = TRUE;

    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
    event.SetEventObject( this );
    GetEventHandler()->ProcessEvent( event );

    m_resizing = FALSE;
}

void wxFrame::OnInternalIdle()
{
    if (!m_sizeSet)
        GtkOnSize( m_x, m_y, m_width, m_height );

    DoMenuUpdates();
}

void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    if (GetAutoLayout())
    {
        Layout();
    }
    else
    {
        // no child: go out !
        if (!GetChildren().First()) return;

        // do we have exactly one child?
        wxWindow *child = (wxWindow *) NULL;
        for(wxNode *node = GetChildren().First(); node; node = node->Next())
        {
            wxWindow *win = (wxWindow *)node->Data();
            if (!wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog)
#if 0  // not in m_children anyway ?
              && (win != m_frameMenuBar) &&
              (win != m_frameToolBar) &&
              (win != m_frameStatusBar)
#endif
            )
            {
          // it's the second one: do nothing
                if (child) return;
                child = win;
            }
        }

        // yes: set it's size to fill all the frame
        int client_x, client_y;
        GetClientSize( &client_x, &client_y );
        child->SetSize( 1, 1, client_x-2, client_y-2 );
    }
}

static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
    menu->SetInvokingWindow( win );
    wxNode *node = menu->m_items.First();
    while (node)
    {
        wxMenuItem *menuitem = (wxMenuItem*)node->Data();
        if (menuitem->IsSubMenu())
            SetInvokingWindow( menuitem->GetSubMenu(), win );
        node = node->Next();
    }
}

void wxFrame::SetMenuBar( wxMenuBar *menuBar )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
    wxASSERT_MSG( (m_wxwindow != NULL), "invalid frame" );

    m_frameMenuBar = menuBar;

    if (m_frameMenuBar)
    {
        wxNode *node = m_frameMenuBar->m_menus.First();
        while (node)
        {
            wxMenu *menu = (wxMenu*)node->Data();
            SetInvokingWindow( menu, this );
            node = node->Next();
        }

        if (m_frameMenuBar->m_parent != this)
        {
            m_frameMenuBar->m_parent = this;
            gtk_myfixed_put( GTK_MYFIXED(m_wxwindow),
                m_frameMenuBar->m_widget, m_frameMenuBar->m_x, m_frameMenuBar->m_y );
        }
    }

    m_sizeSet = FALSE;
}

wxMenuBar *wxFrame::GetMenuBar() const
{
    return m_frameMenuBar;
}

wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    wxCHECK_MSG( m_frameToolBar == NULL, FALSE, "recreating toolbar in wxFrame" );

    m_frameToolBar = OnCreateToolBar( style, id, name );

    GetChildren().DeleteObject( m_frameToolBar );

    m_sizeSet = FALSE;

    return m_frameToolBar;
}

wxToolBar* wxFrame::OnCreateToolBar( long style, wxWindowID id, const wxString& name )
{
    return new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
}

wxToolBar *wxFrame::GetToolBar() const
{
    return m_frameToolBar;
}

wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, "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;
}

void wxFrame::SetStatusText(const wxString& text, int number)
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );

    m_frameStatusBar->SetStatusText(text, number);
}

void wxFrame::SetStatusWidths(int n, const int widths_field[] )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );

    m_frameStatusBar->SetStatusWidths(n, widths_field);
}

wxStatusBar *wxFrame::GetStatusBar() const
{
    return m_frameStatusBar;
}

void wxFrame::SetTitle( const wxString &title )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    m_title = title;
    if (m_title.IsNull()) m_title = "";
    gtk_window_set_title( GTK_WINDOW(m_widget), title );
}

void wxFrame::SetIcon( const wxIcon &icon )
{
    wxASSERT_MSG( (m_widget != NULL), "invalid frame" );

    m_icon = icon;
    if (!icon.Ok()) return;

    wxMask *mask = icon.GetMask();
    GdkBitmap *bm = (GdkBitmap *) NULL;
    if (mask) bm = mask->GetBitmap();

    gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: frame.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation "frame.h"
	12	#endif
	13
	14	#include "wx/frame.h"
	15	#include "wx/dialog.h"
	16	#include "wx/control.h"
	17	#include "wx/app.h"
	18	#include "wx/menu.h"
	19	#include "wx/toolbar.h"
	20	#include "wx/statusbr.h"
	21	#include "wx/dcclient.h"
	22
	23	#include "glib.h"
	24	#include "gdk/gdk.h"
	25	#include "gtk/gtk.h"
	26	#include "wx/gtk/win_gtk.h"
	27
	28	//-----------------------------------------------------------------------------
	29	// constants
	30	//-----------------------------------------------------------------------------
	31
	32	const int wxMENU_HEIGHT = 27;
	33	const int wxSTATUS_HEIGHT = 25;
	34
	35	//-----------------------------------------------------------------------------
	36	// data
	37	//-----------------------------------------------------------------------------
	38
	39	extern wxList wxTopLevelWindows;
	40	extern wxList wxPendingDelete;
	41
	42	//-----------------------------------------------------------------------------
	43	// "size_allocate"
	44	//-----------------------------------------------------------------------------
	45
	46	static void gtk_frame_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxFrame *win )
	47	{
	48	if (!win->HasVMT()) return;
	49
	50	/*
	51	printf( "OnFrameResize from " );
	52	if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
	53	printf( win->GetClassInfo()->GetClassName() );
	54	printf( ".\n" );
	55	*/
	56
	57	if ((win->m_width != alloc->width) \|\| (win->m_height != alloc->height))
	58	{
	59	win->m_sizeSet = FALSE;
	60	win->m_width = alloc->width;
	61	win->m_height = alloc->height;
	62	}
	63	}
	64
	65	//-----------------------------------------------------------------------------
	66	// "delete_event"
	67	//-----------------------------------------------------------------------------
	68
	69	static gint gtk_frame_delete_callback( GtkWidget WXUNUSED(widget), GdkEvent WXUNUSED(event), wxFrame *win )
	70	{
	71	/*
	72	printf( "OnDelete from " );
	73	if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
	74	printf( win->GetClassInfo()->GetClassName() );
	75	printf( ".\n" );
	76	*/
	77
	78	win->Close();
	79
	80	return TRUE;
	81	}
	82
	83	//-----------------------------------------------------------------------------
	84	// "configure_event"
	85	//-----------------------------------------------------------------------------
	86
	87	static gint gtk_frame_configure_callback( GtkWidget WXUNUSED(widget), GdkEventConfigure event, wxFrame *win )
	88	{
	89	if (!win->HasVMT()) return FALSE;
	90
	91	win->m_x = event->x;
	92	win->m_y = event->y;
	93
	94	return FALSE;
	95	}
	96
	97	//-----------------------------------------------------------------------------
	98	// wxFrame
	99	//-----------------------------------------------------------------------------
	100
	101	BEGIN_EVENT_TABLE(wxFrame, wxWindow)
	102	EVT_SIZE(wxFrame::OnSize)
	103	EVT_CLOSE(wxFrame::OnCloseWindow)
	104	END_EVENT_TABLE()
	105
	106	IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
	107
	108	wxFrame::wxFrame()
	109	{
	110	m_frameMenuBar = (wxMenuBar *) NULL;
	111	m_frameStatusBar = (wxStatusBar *) NULL;
	112	m_frameToolBar = (wxToolBar *) NULL;
	113	m_sizeSet = FALSE;
	114	m_miniEdge = 0;
	115	m_miniTitle = 0;
	116	}
	117
	118	wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
	119	const wxPoint &pos, const wxSize &size,
	120	long style, const wxString &name )
	121	{
	122	m_frameMenuBar = (wxMenuBar *) NULL;
	123	m_frameStatusBar = (wxStatusBar *) NULL;
	124	m_frameToolBar = (wxToolBar *) NULL;
	125	m_sizeSet = FALSE;
	126	m_miniEdge = 0;
	127	m_miniTitle = 0;
	128	Create( parent, id, title, pos, size, style, name );
	129	}
	130
	131	bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
	132	const wxPoint &pos, const wxSize &size,
	133	long style, const wxString &name )
	134	{
	135	wxTopLevelWindows.Append( this );
	136
	137	m_needParent = FALSE;
	138
	139	PreCreation( parent, id, pos, size, style, name );
	140
	141	m_title = title;
	142
	143	GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
	144	if (style & wxSIMPLE_BORDER) win_type = GTK_WINDOW_POPUP;
	145
	146	m_widget = gtk_window_new( win_type );
	147
	148	#ifdef __WXDEBUG__
	149	debug_focus_in( m_widget, "wxFrame::m_widget", name );
	150	#endif
	151
	152	if ((size.x != -1) && (size.y != -1))
	153	gtk_widget_set_usize( m_widget, m_width, m_height );
	154	if ((pos.x != -1) && (pos.y != -1))
	155	gtk_widget_set_uposition( m_widget, m_x, m_y );
	156
	157	gtk_window_set_title( GTK_WINDOW(m_widget), title );
	158	GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
	159
	160	gtk_widget_set( m_widget, "GtkWindow::allow_shrink", TRUE, NULL );
	161
	162	gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
	163	GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
	164
	165	m_wxwindow = gtk_myfixed_new();
	166	gtk_widget_show( m_wxwindow );
	167	GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
	168
	169	#ifdef __WXDEBUG__
	170	debug_focus_in( m_wxwindow, "wxFrame::m_wxwindow", name );
	171	#endif
	172
	173	gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
	174
	175	gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
	176	GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
	177
	178	gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
	179	GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
	180
	181	if (m_parent) m_parent->AddChild( this );
	182
	183	PostCreation();
	184
	185	return TRUE;
	186	}
	187
	188	wxFrame::~wxFrame()
	189	{
	190	if (m_frameMenuBar) delete m_frameMenuBar;
	191	if (m_frameStatusBar) delete m_frameStatusBar;
	192	if (m_frameToolBar) delete m_frameToolBar;
	193
	194	wxTopLevelWindows.DeleteObject( this );
	195
	196	if (wxTheApp->GetTopWindow() == this)
	197	{
	198	wxTheApp->SetTopWindow( (wxWindow*) NULL );
	199	}
	200
	201	if (wxTopLevelWindows.Number() == 0)
	202	{
	203	wxTheApp->ExitMainLoop();
	204	}
	205	}
	206
	207	bool wxFrame::Show( bool show )
	208	{
	209	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	210
	211	if (show && !m_sizeSet)
	212	{
	213	// by calling GtkOnSize here, we don't have to call
	214	// either after showing the frame, which would entail
	215	// much ugly flicker nor from within the size_allocate
	216	// handler, because GTK 1.1.X forbids that.
	217
	218	GtkOnSize( m_x, m_y, m_width, m_height );
	219	}
	220
	221	return wxWindow::Show( show );
	222	}
	223
	224	void wxFrame::OnCloseWindow( wxCloseEvent &event )
	225	{
	226	if (GetEventHandler()->OnClose() \|\| event.GetForce()) this->Destroy();
	227	}
	228
	229	bool wxFrame::Destroy()
	230	{
	231	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	232
	233	if (!wxPendingDelete.Member(this)) wxPendingDelete.Append(this);
	234
	235	return TRUE;
	236	}
	237
	238	wxPoint wxFrame::GetClientAreaOrigin() const
	239	{
	240	wxPoint pt( m_miniEdge, m_miniEdge + m_miniTitle );
	241	if (m_frameMenuBar)
	242	{
	243	int h = 0;
	244	m_frameMenuBar->GetSize( (int*)NULL, &h );
	245	pt.y += h;
	246	}
	247	if (m_frameToolBar)
	248	{
	249	int h = 0;
	250	m_frameToolBar->GetSize( (int*)NULL, &h );
	251	pt.y += h;
	252	}
	253	return pt;
	254	}
	255
	256	void wxFrame::SetSize( int x, int y, int width, int height, int sizeFlags )
	257	{
	258	wxASSERT_MSG( (m_widget != NULL), "invalid window" );
	259
	260	// Don't do anything for children of wxMDIChildFrame
	261	if (!m_wxwindow) return;
	262
	263	if (m_resizing) return; // I don't like recursions
	264	m_resizing = TRUE;
	265
	266	int old_x = m_x;
	267	int old_y = m_y;
	268	int old_width = m_width;
	269	int old_height = m_height;
	270
	271	if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
	272	{
	273	if (x != -1) m_x = x;
	274	if (y != -1) m_y = y;
	275	if (width != -1) m_width = width;
	276	if (height != -1) m_height = height;
	277	}
	278	else
	279	{
	280	m_x = x;
	281	m_y = y;
	282	m_width = width;
	283	m_height = height;
	284	}
	285
	286	if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
	287	{
	288	if (width == -1) m_width = 80;
	289	}
	290
	291	if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
	292	{
	293	if (height == -1) m_height = 26;
	294	}
	295
	296	if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
	297	if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
	298	if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_minWidth;
	299	if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight;
	300
	301	if ((m_x != -1) \|\| (m_y != -1))
	302	{
	303	if ((m_x != old_x) \|\| (m_y != old_y))
	304	gtk_widget_set_uposition( m_widget, m_x, m_y );
	305	}
	306
	307	if ((m_width != old_width) \|\| (m_height != old_height))
	308	{
	309	gtk_widget_set_usize( m_widget, m_width, m_height );
	310	}
	311
	312	wxSizeEvent event( wxSize(m_width,m_height), GetId() );
	313	event.SetEventObject( this );
	314	GetEventHandler()->ProcessEvent( event );
	315
	316	m_resizing = FALSE;
	317	}
	318
	319	void wxFrame::SetSize( int width, int height )
	320	{
	321	SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
	322	}
	323
	324	void wxFrame::Centre( int direction )
	325	{
	326	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	327
	328	int x = 0;
	329	int y = 0;
	330
	331	if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
	332	if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
	333
	334	Move( x, y );
	335	}
	336
	337	void wxFrame::GetClientSize( int width, int height ) const
	338	{
	339	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	340
	341	wxWindow::GetClientSize( width, height );
	342	if (height)
	343	{
	344	if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
	345	if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
	346	if (m_frameToolBar)
	347	{
	348	int y = 0;
	349	m_frameToolBar->GetSize( (int *) NULL, &y );
	350	(*height) -= y;
	351	}
	352	(height) -= m_miniEdge2 + m_miniTitle;
	353	}
	354	if (width)
	355	{
	356	(width) -= m_miniEdge2;
	357	}
	358	}
	359
	360	void wxFrame::SetClientSize( int const width, int const height )
	361	{
	362	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	363
	364	int h = height;
	365	if (m_frameMenuBar) h += wxMENU_HEIGHT;
	366	if (m_frameStatusBar) h += wxSTATUS_HEIGHT;
	367	if (m_frameToolBar)
	368	{
	369	int y = 0;
	370	m_frameToolBar->GetSize( (int *) NULL, &y );
	371	h += y;
	372	}
	373	wxWindow::SetClientSize( width + m_miniEdge2, h + m_miniEdge2 + m_miniTitle );
	374	}
	375
	376	void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
	377	{
	378	// due to a bug in gtk, x,y are always 0
	379	// m_x = x;
	380	// m_y = y;
	381
	382	if (m_resizing) return;
	383	m_resizing = TRUE;
	384
	385	if (!m_wxwindow) return;
	386
	387	m_width = width;
	388	m_height = height;
	389
	390	if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
	391	if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
	392	if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_minWidth;
	393	if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight;
	394
	395	gtk_widget_set_usize( m_widget, m_width, m_height );
	396
	397	// this emulates the new wxMSW behaviour of placing all
	398	// frame-subwindows (menu, toolbar..) on one native window
	399	// OK, this hurts in the eye, but I don't want to call SetSize()
	400	// because I don't want to call any non-native functions here.
	401
	402	if (m_frameMenuBar)
	403	{
	404	int xx = m_miniEdge;
	405	int yy = m_miniEdge + m_miniTitle;
	406	int ww = m_width - 2*m_miniEdge;
	407	int hh = wxMENU_HEIGHT;
	408	m_frameMenuBar->m_x = xx;
	409	m_frameMenuBar->m_y = yy;
	410	m_frameMenuBar->m_width = ww;
	411	m_frameMenuBar->m_height = hh;
	412
	413	gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameMenuBar->m_widget, xx, yy );
	414	gtk_widget_set_usize( m_frameMenuBar->m_widget, ww, hh );
	415	}
	416
	417	if (m_frameToolBar)
	418	{
	419	int xx = m_miniEdge;
	420	int yy = m_miniEdge + m_miniTitle;
	421	if (m_frameMenuBar) yy += wxMENU_HEIGHT;
	422	int ww = m_width - 2*m_miniEdge;
	423	int hh = m_frameToolBar->m_height;
	424
	425	m_frameToolBar->m_x = xx;
	426	m_frameToolBar->m_y = yy;
	427	m_frameToolBar->m_height = hh;
	428	m_frameToolBar->m_width = ww;
	429
	430	gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameToolBar->m_widget, xx, yy );
	431	gtk_widget_set_usize( m_frameToolBar->m_widget, ww, hh );
	432	}
	433
	434	if (m_frameStatusBar)
	435	{
	436	int xx = 0 + m_miniEdge;
	437	int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge;
	438	int ww = m_width - 2*m_miniEdge;
	439	int hh = wxSTATUS_HEIGHT;
	440
	441	m_frameStatusBar->m_x = xx;
	442	m_frameStatusBar->m_y = yy;
	443	m_frameStatusBar->m_width = ww;
	444	m_frameStatusBar->m_height = hh;
	445
	446	gtk_myfixed_move( GTK_MYFIXED(m_wxwindow), m_frameStatusBar->m_widget, xx, yy );
	447	gtk_widget_set_usize( m_frameStatusBar->m_widget, ww, hh );
	448	}
	449
	450	m_sizeSet = TRUE;
	451
	452	wxSizeEvent event( wxSize(m_width,m_height), GetId() );
	453	event.SetEventObject( this );
	454	GetEventHandler()->ProcessEvent( event );
	455
	456	m_resizing = FALSE;
	457	}
	458
	459	void wxFrame::OnInternalIdle()
	460	{
	461	if (!m_sizeSet)
	462	GtkOnSize( m_x, m_y, m_width, m_height );
	463
	464	DoMenuUpdates();
	465	}
	466
	467	void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
	468	{
	469	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	470
	471	if (GetAutoLayout())
	472	{
	473	Layout();
	474	}
	475	else
	476	{
	477	// no child: go out !
	478	if (!GetChildren().First()) return;
	479
	480	// do we have exactly one child?
	481	wxWindow child = (wxWindow ) NULL;
	482	for(wxNode *node = GetChildren().First(); node; node = node->Next())
	483	{
	484	wxWindow win = (wxWindow )node->Data();
	485	if (!wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog)
	486	#if 0 // not in m_children anyway ?
	487	&& (win != m_frameMenuBar) &&
	488	(win != m_frameToolBar) &&
	489	(win != m_frameStatusBar)
	490	#endif
	491	)
	492	{
	493	// it's the second one: do nothing
	494	if (child) return;
	495	child = win;
	496	}
	497	}
	498
	499	// yes: set it's size to fill all the frame
	500	int client_x, client_y;
	501	GetClientSize( &client_x, &client_y );
	502	child->SetSize( 1, 1, client_x-2, client_y-2 );
	503	}
	504	}
	505
	506	static void SetInvokingWindow( wxMenu menu, wxWindow win )
	507	{
	508	menu->SetInvokingWindow( win );
	509	wxNode *node = menu->m_items.First();
	510	while (node)
	511	{
	512	wxMenuItem menuitem = (wxMenuItem)node->Data();
	513	if (menuitem->IsSubMenu())
	514	SetInvokingWindow( menuitem->GetSubMenu(), win );
	515	node = node->Next();
	516	}
	517	}
	518
	519	void wxFrame::SetMenuBar( wxMenuBar *menuBar )
	520	{
	521	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	522	wxASSERT_MSG( (m_wxwindow != NULL), "invalid frame" );
	523
	524	m_frameMenuBar = menuBar;
	525
	526	if (m_frameMenuBar)
	527	{
	528	wxNode *node = m_frameMenuBar->m_menus.First();
	529	while (node)
	530	{
	531	wxMenu menu = (wxMenu)node->Data();
	532	SetInvokingWindow( menu, this );
	533	node = node->Next();
	534	}
	535
	536	if (m_frameMenuBar->m_parent != this)
	537	{
	538	m_frameMenuBar->m_parent = this;
	539	gtk_myfixed_put( GTK_MYFIXED(m_wxwindow),
	540	m_frameMenuBar->m_widget, m_frameMenuBar->m_x, m_frameMenuBar->m_y );
	541	}
	542	}
	543
	544	m_sizeSet = FALSE;
	545	}
	546
	547	wxMenuBar *wxFrame::GetMenuBar() const
	548	{
	549	return m_frameMenuBar;
	550	}
	551
	552	wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
	553	{
	554	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	555
	556	wxCHECK_MSG( m_frameToolBar == NULL, FALSE, "recreating toolbar in wxFrame" );
	557
	558	m_frameToolBar = OnCreateToolBar( style, id, name );
	559
	560	GetChildren().DeleteObject( m_frameToolBar );
	561
	562	m_sizeSet = FALSE;
	563
	564	return m_frameToolBar;
	565	}
	566
	567	wxToolBar* wxFrame::OnCreateToolBar( long style, wxWindowID id, const wxString& name )
	568	{
	569	return new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
	570	}
	571
	572	wxToolBar *wxFrame::GetToolBar() const
	573	{
	574	return m_frameToolBar;
	575	}
	576
	577	wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
	578	{
	579	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	580
	581	wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, "recreating status bar in wxFrame" );
	582
	583	m_frameStatusBar = OnCreateStatusBar( number, style, id, name );
	584
	585	m_sizeSet = FALSE;
	586
	587	return m_frameStatusBar;
	588	}
	589
	590	wxStatusBar *wxFrame::OnCreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
	591	{
	592	wxStatusBar statusBar = (wxStatusBar ) NULL;
	593
	594	statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20), style, name);
	595
	596	// Set the height according to the font and the border size
	597	wxClientDC dc(statusBar);
	598	dc.SetFont( statusBar->GetFont() );
	599
	600	long x, y;
	601	dc.GetTextExtent( "X", &x, &y );
	602
	603	int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY());
	604
	605	statusBar->SetSize( -1, -1, 100, height );
	606
	607	statusBar->SetFieldsCount( number );
	608	return statusBar;
	609	}
	610
	611	void wxFrame::SetStatusText(const wxString& text, int number)
	612	{
	613	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	614
	615	wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
	616
	617	m_frameStatusBar->SetStatusText(text, number);
	618	}
	619
	620	void wxFrame::SetStatusWidths(int n, const int widths_field[] )
	621	{
	622	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	623
	624	wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
	625
	626	m_frameStatusBar->SetStatusWidths(n, widths_field);
	627	}
	628
	629	wxStatusBar *wxFrame::GetStatusBar() const
	630	{
	631	return m_frameStatusBar;
	632	}
	633
	634	void wxFrame::SetTitle( const wxString &title )
	635	{
	636	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	637
	638	m_title = title;
	639	if (m_title.IsNull()) m_title = "";
	640	gtk_window_set_title( GTK_WINDOW(m_widget), title );
	641	}
	642
	643	void wxFrame::SetIcon( const wxIcon &icon )
	644	{
	645	wxASSERT_MSG( (m_widget != NULL), "invalid frame" );
	646
	647	m_icon = icon;
	648	if (!icon.Ok()) return;
	649
	650	wxMask *mask = icon.GetMask();
	651	GdkBitmap bm = (GdkBitmap ) NULL;
	652	if (mask) bm = mask->GetBitmap();
	653
	654	gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
	655	}
	656