src/gtk/frame.cpp

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

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/frame.h"

#ifndef WX_PRECOMP
    #include "wx/menu.h"
    #include "wx/toolbar.h"
    #include "wx/statusbr.h"
#endif // WX_PRECOMP

#include <gtk/gtk.h>

#if wxUSE_LIBHILDON
    #include <hildon-widgets/hildon-window.h>
#endif // wxUSE_LIBHILDON

#if wxUSE_LIBHILDON2
    #include <hildon/hildon.h>
#endif // wxUSE_LIBHILDON2

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxFrame creation
// ----------------------------------------------------------------------------

void wxFrame::Init()
{
    m_fsSaveFlag = 0;
}

bool wxFrame::Create( wxWindow *parent,
                      wxWindowID id,
                      const wxString& title,
                      const wxPoint& pos,
                      const wxSize& sizeOrig,
                      long style,
                      const wxString &name )
{
    return wxFrameBase::Create(parent, id, title, pos, sizeOrig, style, name);
}

wxFrame::~wxFrame()
{
    SendDestroyEvent();

    DeleteAllBars();
}

// ----------------------------------------------------------------------------
// overridden wxWindow methods
// ----------------------------------------------------------------------------

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

    wxFrameBase::DoGetClientSize(width, height);

    if (height)
    {
#if wxUSE_MENUS_NATIVE
        // menu bar
        if (m_frameMenuBar && m_frameMenuBar->IsShown())
        {
            GtkRequisition req;
            gtk_widget_size_request(m_frameMenuBar->m_widget, &req);
#if !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
            *height -= req.height;
#endif
        }
#endif // wxUSE_MENUS_NATIVE

#if wxUSE_STATUSBAR
        // status bar
        if (m_frameStatusBar && m_frameStatusBar->IsShown())
            *height -= m_frameStatusBar->m_height;
#endif // wxUSE_STATUSBAR
    }

#if wxUSE_TOOLBAR
    // tool bar
    if (m_frameToolBar && m_frameToolBar->IsShown())
    {
        GtkRequisition req;
        gtk_widget_size_request(m_frameToolBar->m_widget, &req);
        if (m_frameToolBar->IsVertical())
        {
            if (width)
                *width -= req.width;
        }
        else
        {
            if (height)
                *height -= req.height;
        }
    }
#endif // wxUSE_TOOLBAR

    if (width != NULL && *width < 0)
        *width = 0;
    if (height != NULL && *height < 0)
        *height = 0;
}

#if wxUSE_MENUS && wxUSE_ACCEL
// Helper for wxCreateAcceleratorTableForMenuBar
static void wxAddAccelerators(wxList& accelEntries, wxMenu* menu)
{
    size_t i;
    for (i = 0; i < menu->GetMenuItems().GetCount(); i++)
    {
        wxMenuItem* item = (wxMenuItem*) menu->GetMenuItems().Item(i)->GetData();
        if (item->GetSubMenu())
        {
            wxAddAccelerators(accelEntries, item->GetSubMenu());
        }
        else if (!item->GetItemLabel().IsEmpty())
        {
            wxAcceleratorEntry* entry = wxAcceleratorEntry::Create(item->GetItemLabel());
            if (entry)
            {
                entry->Set(entry->GetFlags(), entry->GetKeyCode(), item->GetId());
                accelEntries.Append((wxObject*) entry);
            }
        }
    }
}

// Create an accelerator table consisting of all the accelerators
// from the menubar in the given menus
static wxAcceleratorTable wxCreateAcceleratorTableForMenuBar(wxMenuBar* menuBar)
{
    wxList accelEntries;

    size_t i;
    for (i = 0; i < menuBar->GetMenuCount(); i++)
    {
        wxAddAccelerators(accelEntries, menuBar->GetMenu(i));
    }

    size_t n = accelEntries.GetCount();

    if (n == 0)
        return wxAcceleratorTable();

    wxAcceleratorEntry* entries = new wxAcceleratorEntry[n];

    for (i = 0; i < accelEntries.GetCount(); i++)
    {
        wxAcceleratorEntry* entry = (wxAcceleratorEntry*) accelEntries.Item(i)->GetData();
        entries[i] = (*entry);
        delete entry;

    }

    wxAcceleratorTable table(n, entries);
    delete[] entries;

    return table;
}
#endif // wxUSE_MENUS && wxUSE_ACCEL

bool wxFrame::ShowFullScreen(bool show, long style)
{
    if (!wxFrameBase::ShowFullScreen(show, style))
        return false;

#if wxUSE_MENUS && wxUSE_ACCEL
    if (show && GetMenuBar())
    {
        wxAcceleratorTable table(wxCreateAcceleratorTableForMenuBar(GetMenuBar()));
        if (table.IsOk())
            SetAcceleratorTable(table);
    }
#endif // wxUSE_MENUS && wxUSE_ACCEL

    wxWindow* const bar[] = {
#if wxUSE_MENUS
        m_frameMenuBar,
#else
        NULL,
#endif
#if wxUSE_TOOLBAR
        m_frameToolBar,
#else
        NULL,
#endif
#if wxUSE_STATUSBAR
        m_frameStatusBar,
#else
        NULL,
#endif
    };
    const long fsNoBar[] = {
        wxFULLSCREEN_NOMENUBAR, wxFULLSCREEN_NOTOOLBAR, wxFULLSCREEN_NOSTATUSBAR
    };
    for (int i = 0; i < 3; i++)
    {
        if (show)
        {
            if (bar[i] && (style & fsNoBar[i]))
            {
                if (bar[i]->IsShown())
                    bar[i]->Show(false);
                else
                    style &= ~fsNoBar[i];
            }
        }
        else
        {
            if (bar[i] && (m_fsSaveFlag & fsNoBar[i]))
                bar[i]->Show(true);
        }
    }
    if (show)
        m_fsSaveFlag = style;

    return true;
}

void wxFrame::OnInternalIdle()
{
    wxFrameBase::OnInternalIdle();

#if wxUSE_MENUS_NATIVE
    if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
#endif // wxUSE_MENUS_NATIVE
#if wxUSE_TOOLBAR
    if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
#endif
#if wxUSE_STATUSBAR
    if (m_frameStatusBar)
    {
        m_frameStatusBar->OnInternalIdle();

        // There may be controls in the status bar that
        // need to be updated
        for ( wxWindowList::compatibility_iterator node = m_frameStatusBar->GetChildren().GetFirst();
          node;
          node = node->GetNext() )
        {
            wxWindow *child = node->GetData();
            child->OnInternalIdle();
        }
    }
#endif
}

// ----------------------------------------------------------------------------
// menu/tool/status bar stuff
// ----------------------------------------------------------------------------

#if wxUSE_MENUS_NATIVE

void wxFrame::DetachMenuBar()
{
    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
    wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );

    if ( m_frameMenuBar )
    {
#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
        hildon_window_set_menu(HILDON_WINDOW(m_widget), NULL);
#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
        m_frameMenuBar->UnsetInvokingWindow( this );

        gtk_widget_ref( m_frameMenuBar->m_widget );

        gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
    }

    wxFrameBase::DetachMenuBar();

    // make sure next size_allocate causes a wxSizeEvent
    m_oldClientWidth = 0;
}

void wxFrame::AttachMenuBar( wxMenuBar *menuBar )
{
    wxFrameBase::AttachMenuBar(menuBar);

    if (m_frameMenuBar)
    {
#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
        hildon_window_set_menu(HILDON_WINDOW(m_widget),
                               GTK_MENU(m_frameMenuBar->m_menubar));
#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
        m_frameMenuBar->SetInvokingWindow( this );

        m_frameMenuBar->SetParent(this);

        // menubar goes into top of vbox (m_mainWidget)
        gtk_box_pack_start(
            GTK_BOX(m_mainWidget), menuBar->m_widget, false, false, 0);
        gtk_box_reorder_child(GTK_BOX(m_mainWidget), menuBar->m_widget, 0);

        // disconnect wxWindowGTK "size_request" handler,
        // it interferes with sizing of detached GtkHandleBox
        gulong handler_id = g_signal_handler_find(
            menuBar->m_widget,
            GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
            g_signal_lookup("size_request", GTK_TYPE_WIDGET),
            0, NULL, NULL, menuBar);
        if (handler_id != 0)
            g_signal_handler_disconnect(menuBar->m_widget, handler_id);

        // reset size request to allow native sizing to work
        gtk_widget_set_size_request(menuBar->m_widget, -1, -1);

        gtk_widget_show( m_frameMenuBar->m_widget );
#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
    }
    // make sure next size_allocate causes a wxSizeEvent
    m_oldClientWidth = 0;
}
#endif // wxUSE_MENUS_NATIVE

#if wxUSE_TOOLBAR

void wxFrame::SetToolBar(wxToolBar *toolbar)
{
    m_frameToolBar = toolbar;
    if (toolbar)
    {
        if (toolbar->IsVertical())
        {
            // Vertical toolbar and m_wxwindow go into an hbox, inside the
            // vbox (m_mainWidget). hbox is created on demand.
            GtkWidget* hbox = m_wxwindow->parent;
            if (!GTK_IS_HBOX(hbox))
            {
                hbox = gtk_hbox_new(false, 0);
                gtk_widget_show(hbox);
                gtk_container_add(GTK_CONTAINER(m_mainWidget), hbox);
                gtk_widget_reparent(m_wxwindow, hbox);
            }
            gtk_widget_reparent(toolbar->m_widget, hbox);
            gtk_box_set_child_packing(GTK_BOX(hbox),
                toolbar->m_widget, false, false, 0, GTK_PACK_START);

            int pos = 0;  // left
            if (toolbar->HasFlag(wxTB_RIGHT))
                pos = 1;  // right
            gtk_box_reorder_child(GTK_BOX(hbox), toolbar->m_widget, pos);
        }
        else
        {
            // Horizontal toolbar goes into vbox (m_mainWidget)
            gtk_widget_reparent(toolbar->m_widget, m_mainWidget);
            gtk_box_set_child_packing(GTK_BOX(m_mainWidget),
                toolbar->m_widget, false, false, 0, GTK_PACK_START);

            int pos = 0;  // top
            if (m_frameMenuBar)
                pos = 1;  // below menubar
            if (toolbar->HasFlag(wxTB_BOTTOM))
                pos += 2;  // below client area (m_wxwindow)
            gtk_box_reorder_child(
                GTK_BOX(m_mainWidget), toolbar->m_widget, pos);
        }

        // disconnect wxWindowGTK "size_request" handler,
        // it interferes with sizing of detached GtkHandleBox
        gulong handler_id = g_signal_handler_find(
            toolbar->m_widget,
            GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
            g_signal_lookup("size_request", GTK_TYPE_WIDGET),
            0, NULL, NULL, toolbar);
        if (handler_id != 0)
            g_signal_handler_disconnect(toolbar->m_widget, handler_id);

        // reset size request to allow native sizing to work
        gtk_widget_set_size_request(toolbar->m_widget, -1, -1);
    }
    // make sure next size_allocate causes a wxSizeEvent
    m_oldClientWidth = 0;
}

#endif // wxUSE_TOOLBAR

#if wxUSE_STATUSBAR

void wxFrame::SetStatusBar(wxStatusBar *statbar)
{
    m_frameStatusBar = statbar;
    if (statbar)
    {
        // statusbar goes into bottom of vbox (m_mainWidget)
        gtk_widget_reparent(statbar->m_widget, m_mainWidget);
        gtk_box_set_child_packing(GTK_BOX(m_mainWidget),
            statbar->m_widget, false, false, 0, GTK_PACK_END);
        // make sure next size_allocate on statusbar causes a size event
        statbar->m_oldClientWidth = 0;
    }
    // make sure next size_allocate causes a wxSizeEvent
    m_oldClientWidth = 0;
}
#endif // wxUSE_STATUSBAR
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/frame.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// For compilers that support precompilation, includes "wx.h".
	11	#include "wx/wxprec.h"
	12
	13	#include "wx/frame.h"
	14
	15	#ifndef WX_PRECOMP
	16	#include "wx/menu.h"
	17	#include "wx/toolbar.h"
	18	#include "wx/statusbr.h"
	19	#endif // WX_PRECOMP
	20
	21	#include <gtk/gtk.h>
	22
	23	#if wxUSE_LIBHILDON
	24	#include <hildon-widgets/hildon-window.h>
	25	#endif // wxUSE_LIBHILDON
	26
	27	#if wxUSE_LIBHILDON2
	28	#include <hildon/hildon.h>
	29	#endif // wxUSE_LIBHILDON2
	30
	31	// ----------------------------------------------------------------------------
	32	// event tables
	33	// ----------------------------------------------------------------------------
	34
	35	IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
	36
	37	// ============================================================================
	38	// implementation
	39	// ============================================================================
	40
	41	// ----------------------------------------------------------------------------
	42	// wxFrame creation
	43	// ----------------------------------------------------------------------------
	44
	45	void wxFrame::Init()
	46	{
	47	m_fsSaveFlag = 0;
	48	}
	49
	50	bool wxFrame::Create( wxWindow *parent,
	51	wxWindowID id,
	52	const wxString& title,
	53	const wxPoint& pos,
	54	const wxSize& sizeOrig,
	55	long style,
	56	const wxString &name )
	57	{
	58	return wxFrameBase::Create(parent, id, title, pos, sizeOrig, style, name);
	59	}
	60
	61	wxFrame::~wxFrame()
	62	{
	63	SendDestroyEvent();
	64
	65	DeleteAllBars();
	66	}
	67
	68	// ----------------------------------------------------------------------------
	69	// overridden wxWindow methods
	70	// ----------------------------------------------------------------------------
	71
	72	void wxFrame::DoGetClientSize( int width, int height ) const
	73	{
	74	wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
	75
	76	wxFrameBase::DoGetClientSize(width, height);
	77
	78	if (height)
	79	{
	80	#if wxUSE_MENUS_NATIVE
	81	// menu bar
	82	if (m_frameMenuBar && m_frameMenuBar->IsShown())
	83	{
	84	GtkRequisition req;
	85	gtk_widget_size_request(m_frameMenuBar->m_widget, &req);
	86	#if !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
	87	*height -= req.height;
	88	#endif
	89	}
	90	#endif // wxUSE_MENUS_NATIVE
	91
	92	#if wxUSE_STATUSBAR
	93	// status bar
	94	if (m_frameStatusBar && m_frameStatusBar->IsShown())
	95	*height -= m_frameStatusBar->m_height;
	96	#endif // wxUSE_STATUSBAR
	97	}
	98
	99	#if wxUSE_TOOLBAR
	100	// tool bar
	101	if (m_frameToolBar && m_frameToolBar->IsShown())
	102	{
	103	GtkRequisition req;
	104	gtk_widget_size_request(m_frameToolBar->m_widget, &req);
	105	if (m_frameToolBar->IsVertical())
	106	{
	107	if (width)
	108	*width -= req.width;
	109	}
	110	else
	111	{
	112	if (height)
	113	*height -= req.height;
	114	}
	115	}
	116	#endif // wxUSE_TOOLBAR
	117
	118	if (width != NULL && *width < 0)
	119	*width = 0;
	120	if (height != NULL && *height < 0)
	121	*height = 0;
	122	}
	123
	124	#if wxUSE_MENUS && wxUSE_ACCEL
	125	// Helper for wxCreateAcceleratorTableForMenuBar
	126	static void wxAddAccelerators(wxList& accelEntries, wxMenu* menu)
	127	{
	128	size_t i;
	129	for (i = 0; i < menu->GetMenuItems().GetCount(); i++)
	130	{
	131	wxMenuItem* item = (wxMenuItem*) menu->GetMenuItems().Item(i)->GetData();
	132	if (item->GetSubMenu())
	133	{
	134	wxAddAccelerators(accelEntries, item->GetSubMenu());
	135	}
	136	else if (!item->GetItemLabel().IsEmpty())
	137	{
	138	wxAcceleratorEntry* entry = wxAcceleratorEntry::Create(item->GetItemLabel());
	139	if (entry)
	140	{
	141	entry->Set(entry->GetFlags(), entry->GetKeyCode(), item->GetId());
	142	accelEntries.Append((wxObject*) entry);
	143	}
	144	}
	145	}
	146	}
	147
	148	// Create an accelerator table consisting of all the accelerators
	149	// from the menubar in the given menus
	150	static wxAcceleratorTable wxCreateAcceleratorTableForMenuBar(wxMenuBar* menuBar)
	151	{
	152	wxList accelEntries;
	153
	154	size_t i;
	155	for (i = 0; i < menuBar->GetMenuCount(); i++)
	156	{
	157	wxAddAccelerators(accelEntries, menuBar->GetMenu(i));
	158	}
	159
	160	size_t n = accelEntries.GetCount();
	161
	162	if (n == 0)
	163	return wxAcceleratorTable();
	164
	165	wxAcceleratorEntry* entries = new wxAcceleratorEntry[n];
	166
	167	for (i = 0; i < accelEntries.GetCount(); i++)
	168	{
	169	wxAcceleratorEntry* entry = (wxAcceleratorEntry*) accelEntries.Item(i)->GetData();
	170	entries[i] = (*entry);
	171	delete entry;
	172
	173	}
	174
	175	wxAcceleratorTable table(n, entries);
	176	delete[] entries;
	177
	178	return table;
	179	}
	180	#endif // wxUSE_MENUS && wxUSE_ACCEL
	181
	182	bool wxFrame::ShowFullScreen(bool show, long style)
	183	{
	184	if (!wxFrameBase::ShowFullScreen(show, style))
	185	return false;
	186
	187	#if wxUSE_MENUS && wxUSE_ACCEL
	188	if (show && GetMenuBar())
	189	{
	190	wxAcceleratorTable table(wxCreateAcceleratorTableForMenuBar(GetMenuBar()));
	191	if (table.IsOk())
	192	SetAcceleratorTable(table);
	193	}
	194	#endif // wxUSE_MENUS && wxUSE_ACCEL
	195
	196	wxWindow* const bar[] = {
	197	#if wxUSE_MENUS
	198	m_frameMenuBar,
	199	#else
	200	NULL,
	201	#endif
	202	#if wxUSE_TOOLBAR
	203	m_frameToolBar,
	204	#else
	205	NULL,
	206	#endif
	207	#if wxUSE_STATUSBAR
	208	m_frameStatusBar,
	209	#else
	210	NULL,
	211	#endif
	212	};
	213	const long fsNoBar[] = {
	214	wxFULLSCREEN_NOMENUBAR, wxFULLSCREEN_NOTOOLBAR, wxFULLSCREEN_NOSTATUSBAR
	215	};
	216	for (int i = 0; i < 3; i++)
	217	{
	218	if (show)
	219	{
	220	if (bar[i] && (style & fsNoBar[i]))
	221	{
	222	if (bar[i]->IsShown())
	223	bar[i]->Show(false);
	224	else
	225	style &= ~fsNoBar[i];
	226	}
	227	}
	228	else
	229	{
	230	if (bar[i] && (m_fsSaveFlag & fsNoBar[i]))
	231	bar[i]->Show(true);
	232	}
	233	}
	234	if (show)
	235	m_fsSaveFlag = style;
	236
	237	return true;
	238	}
	239
	240	void wxFrame::OnInternalIdle()
	241	{
	242	wxFrameBase::OnInternalIdle();
	243
	244	#if wxUSE_MENUS_NATIVE
	245	if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
	246	#endif // wxUSE_MENUS_NATIVE
	247	#if wxUSE_TOOLBAR
	248	if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
	249	#endif
	250	#if wxUSE_STATUSBAR
	251	if (m_frameStatusBar)
	252	{
	253	m_frameStatusBar->OnInternalIdle();
	254
	255	// There may be controls in the status bar that
	256	// need to be updated
	257	for ( wxWindowList::compatibility_iterator node = m_frameStatusBar->GetChildren().GetFirst();
	258	node;
	259	node = node->GetNext() )
	260	{
	261	wxWindow *child = node->GetData();
	262	child->OnInternalIdle();
	263	}
	264	}
	265	#endif
	266	}
	267
	268	// ----------------------------------------------------------------------------
	269	// menu/tool/status bar stuff
	270	// ----------------------------------------------------------------------------
	271
	272	#if wxUSE_MENUS_NATIVE
	273
	274	void wxFrame::DetachMenuBar()
	275	{
	276	wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
	277	wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
	278
	279	if ( m_frameMenuBar )
	280	{
	281	#if wxUSE_LIBHILDON \|\| wxUSE_LIBHILDON2
	282	hildon_window_set_menu(HILDON_WINDOW(m_widget), NULL);
	283	#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
	284	m_frameMenuBar->UnsetInvokingWindow( this );
	285
	286	gtk_widget_ref( m_frameMenuBar->m_widget );
	287
	288	gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
	289	#endif // wxUSE_LIBHILDON \|\| wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
	290	}
	291
	292	wxFrameBase::DetachMenuBar();
	293
	294	// make sure next size_allocate causes a wxSizeEvent
	295	m_oldClientWidth = 0;
	296	}
	297
	298	void wxFrame::AttachMenuBar( wxMenuBar *menuBar )
	299	{
	300	wxFrameBase::AttachMenuBar(menuBar);
	301
	302	if (m_frameMenuBar)
	303	{
	304	#if wxUSE_LIBHILDON \|\| wxUSE_LIBHILDON2
	305	hildon_window_set_menu(HILDON_WINDOW(m_widget),
	306	GTK_MENU(m_frameMenuBar->m_menubar));
	307	#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
	308	m_frameMenuBar->SetInvokingWindow( this );
	309
	310	m_frameMenuBar->SetParent(this);
	311
	312	// menubar goes into top of vbox (m_mainWidget)
	313	gtk_box_pack_start(
	314	GTK_BOX(m_mainWidget), menuBar->m_widget, false, false, 0);
	315	gtk_box_reorder_child(GTK_BOX(m_mainWidget), menuBar->m_widget, 0);
	316
	317	// disconnect wxWindowGTK "size_request" handler,
	318	// it interferes with sizing of detached GtkHandleBox
	319	gulong handler_id = g_signal_handler_find(
	320	menuBar->m_widget,
	321	GSignalMatchType(G_SIGNAL_MATCH_ID \| G_SIGNAL_MATCH_DATA),
	322	g_signal_lookup("size_request", GTK_TYPE_WIDGET),
	323	0, NULL, NULL, menuBar);
	324	if (handler_id != 0)
	325	g_signal_handler_disconnect(menuBar->m_widget, handler_id);
	326
	327	// reset size request to allow native sizing to work
	328	gtk_widget_set_size_request(menuBar->m_widget, -1, -1);
	329
	330	gtk_widget_show( m_frameMenuBar->m_widget );
	331	#endif // wxUSE_LIBHILDON \|\| wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
	332	}
	333	// make sure next size_allocate causes a wxSizeEvent
	334	m_oldClientWidth = 0;
	335	}
	336	#endif // wxUSE_MENUS_NATIVE
	337
	338	#if wxUSE_TOOLBAR
	339
	340	void wxFrame::SetToolBar(wxToolBar *toolbar)
	341	{
	342	m_frameToolBar = toolbar;
	343	if (toolbar)
	344	{
	345	if (toolbar->IsVertical())
	346	{
	347	// Vertical toolbar and m_wxwindow go into an hbox, inside the
	348	// vbox (m_mainWidget). hbox is created on demand.
	349	GtkWidget* hbox = m_wxwindow->parent;
	350	if (!GTK_IS_HBOX(hbox))
	351	{
	352	hbox = gtk_hbox_new(false, 0);
	353	gtk_widget_show(hbox);
	354	gtk_container_add(GTK_CONTAINER(m_mainWidget), hbox);
	355	gtk_widget_reparent(m_wxwindow, hbox);
	356	}
	357	gtk_widget_reparent(toolbar->m_widget, hbox);
	358	gtk_box_set_child_packing(GTK_BOX(hbox),
	359	toolbar->m_widget, false, false, 0, GTK_PACK_START);
	360
	361	int pos = 0; // left
	362	if (toolbar->HasFlag(wxTB_RIGHT))
	363	pos = 1; // right
	364	gtk_box_reorder_child(GTK_BOX(hbox), toolbar->m_widget, pos);
	365	}
	366	else
	367	{
	368	// Horizontal toolbar goes into vbox (m_mainWidget)
	369	gtk_widget_reparent(toolbar->m_widget, m_mainWidget);
	370	gtk_box_set_child_packing(GTK_BOX(m_mainWidget),
	371	toolbar->m_widget, false, false, 0, GTK_PACK_START);
	372
	373	int pos = 0; // top
	374	if (m_frameMenuBar)
	375	pos = 1; // below menubar
	376	if (toolbar->HasFlag(wxTB_BOTTOM))
	377	pos += 2; // below client area (m_wxwindow)
	378	gtk_box_reorder_child(
	379	GTK_BOX(m_mainWidget), toolbar->m_widget, pos);
	380	}
	381
	382	// disconnect wxWindowGTK "size_request" handler,
	383	// it interferes with sizing of detached GtkHandleBox
	384	gulong handler_id = g_signal_handler_find(
	385	toolbar->m_widget,
	386	GSignalMatchType(G_SIGNAL_MATCH_ID \| G_SIGNAL_MATCH_DATA),
	387	g_signal_lookup("size_request", GTK_TYPE_WIDGET),
	388	0, NULL, NULL, toolbar);
	389	if (handler_id != 0)
	390	g_signal_handler_disconnect(toolbar->m_widget, handler_id);
	391
	392	// reset size request to allow native sizing to work
	393	gtk_widget_set_size_request(toolbar->m_widget, -1, -1);
	394	}
	395	// make sure next size_allocate causes a wxSizeEvent
	396	m_oldClientWidth = 0;
	397	}
	398
	399	#endif // wxUSE_TOOLBAR
	400
	401	#if wxUSE_STATUSBAR
	402
	403	void wxFrame::SetStatusBar(wxStatusBar *statbar)
	404	{
	405	m_frameStatusBar = statbar;
	406	if (statbar)
	407	{
	408	// statusbar goes into bottom of vbox (m_mainWidget)
	409	gtk_widget_reparent(statbar->m_widget, m_mainWidget);
	410	gtk_box_set_child_packing(GTK_BOX(m_mainWidget),
	411	statbar->m_widget, false, false, 0, GTK_PACK_END);
	412	// make sure next size_allocate on statusbar causes a size event
	413	statbar->m_oldClientWidth = 0;
	414	}
	415	// make sure next size_allocate causes a wxSizeEvent
	416	m_oldClientWidth = 0;
	417	}
	418	#endif // wxUSE_STATUSBAR