src/gtk/mdi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/mdi.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"

#if wxUSE_MDI

#include "wx/mdi.h"

#ifndef WX_PRECOMP
    #include "wx/intl.h"
    #include "wx/menu.h"
#endif

#include "wx/gtk/private.h"

//-----------------------------------------------------------------------------
// "switch_page"
//-----------------------------------------------------------------------------

extern "C" {
static void
switch_page(GtkNotebook* widget, GtkNotebookPage*, guint page_num, wxMDIParentFrame* parent)
{
    // send deactivate event to old child

    wxMDIChildFrame *child = parent->GetActiveChild();
    if (child)
    {
        wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
        event1.SetEventObject( child);
        child->HandleWindowEvent( event1 );
    }

    // send activate event to new child

    wxMDIClientWindowBase *client_window = parent->GetClientWindow();
    if ( !client_window )
        return;

    child = NULL;
    GtkWidget* page = gtk_notebook_get_nth_page(widget, page_num);

    wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst();
    while ( node )
    {
        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        // child_frame can be NULL when this is called from dtor, probably
        // because g_signal_connect (m_widget, "switch_page", (see below)
        // isn't deleted early enough
        if (child_frame && child_frame->m_widget == page)
        {
            child = child_frame;
            break;
        }
        node = node->GetNext();
    }

    if (!child)
         return;

    wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
    event2.SetEventObject( child);
    child->HandleWindowEvent( event2 );
}
}

//-----------------------------------------------------------------------------
// wxMDIParentFrame
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)

void wxMDIParentFrame::Init()
{
    m_justInserted = false;
}

bool wxMDIParentFrame::Create(wxWindow *parent,
                              wxWindowID id,
                              const wxString& title,
                              const wxPoint& pos,
                              const wxSize& size,
                              long style,
                              const wxString& name )
{
    if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
        return false;

    m_clientWindow = OnCreateClient();
    if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
        return false;

    return true;
}

void wxMDIParentFrame::OnInternalIdle()
{
    /* if a MDI child window has just been inserted
       it has to be brought to the top in idle time. we
       simply set the last notebook page active as new
       pages can only be appended at the end */

    if (m_justInserted)
    {
        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
        gtk_notebook_set_current_page(notebook, -1);

        /* need to set the menubar of the child */
        wxMDIChildFrame *active_child_frame = GetActiveChild();
        if (active_child_frame != NULL)
        {
            wxMenuBar *menu_bar = active_child_frame->m_menuBar;
            if (menu_bar)
            {
                menu_bar->Attach(active_child_frame);
            }
        }
        m_justInserted = false;
        return;
    }

    wxFrame::OnInternalIdle();

    wxMDIChildFrame *active_child_frame = GetActiveChild();
    bool visible_child_menu = false;

    wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
    while (node)
    {
        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        if ( child_frame )
        {
            wxMenuBar *menu_bar = child_frame->m_menuBar;
            if ( menu_bar )
            {
                if (child_frame == active_child_frame)
                {
                    if (menu_bar->Show(true))
                    {
                        // Attach() asserts if we call it for an already
                        // attached menu bar so don't do it if we're already
                        // associated with this frame (it would be nice to get
                        // rid of this check and ensure that this doesn't
                        // happen...)
                        if ( menu_bar->GetFrame() != child_frame )
                            menu_bar->Attach( child_frame );
                    }
                    visible_child_menu = true;
                }
                else
                {
                    if (menu_bar->Show(false))
                    {
                        menu_bar->Detach();
                    }
                }
            }
        }

        node = node->GetNext();
    }

    /* show/hide parent menu bar as required */
    if ((m_frameMenuBar) &&
        (m_frameMenuBar->IsShown() == visible_child_menu))
    {
        if (visible_child_menu)
        {
            m_frameMenuBar->Show( false );
            m_frameMenuBar->Detach();
        }
        else
        {
            m_frameMenuBar->Show( true );
            m_frameMenuBar->Attach( this );
        }
    }
}

void wxMDIParentFrame::DoGetClientSize(int* width, int* height) const
{
    wxFrame::DoGetClientSize(width, height);

    if (height)
    {
        wxMDIChildFrame* active_child_frame = GetActiveChild();
        if (active_child_frame)
        {
            wxMenuBar* menubar = active_child_frame->m_menuBar;
            if (menubar && menubar->IsShown())
            {
                GtkRequisition req;
                gtk_widget_size_request(menubar->m_widget, &req);
                *height -= req.height;
                if (*height < 0) *height = 0;
            }
        }
    }
}

wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
    if (!m_clientWindow) return NULL;

    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
    if (!notebook) return NULL;

    gint i = gtk_notebook_get_current_page( notebook );
    if (i < 0) return NULL;

    GtkWidget* page = gtk_notebook_get_nth_page(notebook, i);
    if (!page) return NULL;

    wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
    while (node)
    {
        if ( wxPendingDelete.Member(node->GetData()) )
            return NULL;

        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        if (!child_frame)
            return NULL;

        if (child_frame->m_widget == page)
            return child_frame;

        node = node->GetNext();
    }

    return NULL;
}

void wxMDIParentFrame::ActivateNext()
{
    if (m_clientWindow)
      gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
}

void wxMDIParentFrame::ActivatePrevious()
{
    if (m_clientWindow)
      gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
}

//-----------------------------------------------------------------------------
// wxMDIChildFrame
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)

BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
    EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
    EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
END_EVENT_TABLE()

void wxMDIChildFrame::Init()
{
    m_menuBar = NULL;
}

bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
                             wxWindowID id,
                             const wxString& title,
                             const wxPoint& WXUNUSED(pos),
                             const wxSize& size,
                             long style,
                             const wxString& name)
{
    m_mdiParent = parent;
    m_title = title;

    return wxWindow::Create(parent->GetClientWindow(), id,
                            wxDefaultPosition, size,
                            style, name);
}

wxMDIChildFrame::~wxMDIChildFrame()
{
    delete m_menuBar;

    // wxMDIClientWindow does not get redrawn properly after last child is removed
    if (m_parent && m_parent->GetChildren().size() <= 1)
        gtk_widget_queue_draw(m_parent->m_widget);
}

void wxMDIChildFrame::GTKHandleRealized()
{
    // since m_widget is not a GtkWindow, must bypass wxTopLevelWindowGTK
    wxTopLevelWindowBase::GTKHandleRealized();
}

void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
{
    wxASSERT_MSG( m_menuBar == NULL, "Only one menubar allowed" );

    m_menuBar = menu_bar;

    if (m_menuBar)
    {
        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();

        m_menuBar->SetParent( mdi_frame );

        /* insert the invisible menu bar into the _parent_ mdi frame */
        m_menuBar->Show(false);
        gtk_box_pack_start(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, false, false, 0);
        gtk_box_reorder_child(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, 0);

        gulong handler_id = g_signal_handler_find(
            m_menuBar->m_widget,
            GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
            g_signal_lookup("size_request", GTK_TYPE_WIDGET),
            0, NULL, NULL, m_menuBar);
        if (handler_id != 0)
            g_signal_handler_disconnect(m_menuBar->m_widget, handler_id);
        gtk_widget_set_size_request(m_menuBar->m_widget, -1, -1);
    }
}

wxMenuBar *wxMDIChildFrame::GetMenuBar() const
{
    return m_menuBar;
}

GtkNotebook *wxMDIChildFrame::GTKGetNotebook() const
{
    wxMDIClientWindow * const
        client = wxStaticCast(GetParent(), wxMDIClientWindow);
    wxCHECK( client, NULL );

    return GTK_NOTEBOOK(client->m_widget);
}

void wxMDIChildFrame::Activate()
{
    GtkNotebook * const notebook = GTKGetNotebook();
    wxCHECK_RET( notebook, "no parent notebook?" );

    gint pageno = gtk_notebook_page_num( notebook, m_widget );
    gtk_notebook_set_current_page( notebook, pageno );
}

void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
{
}

void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
{
#if wxUSE_STATUSBAR
    wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
    if ( !ShowMenuHelp(event.GetMenuId()) )
    {
        // we don't have any help text for this item, but may be the MDI frame
        // does?
        mdi_frame->OnMenuHighlight(event);
    }
#endif // wxUSE_STATUSBAR
}

void wxMDIChildFrame::SetTitle( const wxString &title )
{
    if ( title == m_title )
        return;

    m_title = title;

    GtkNotebook * const notebook = GTKGetNotebook();
    wxCHECK_RET( notebook, "no parent notebook?" );
    gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
}

//-----------------------------------------------------------------------------
// wxMDIClientWindow
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)

wxMDIClientWindow::~wxMDIClientWindow()
{
    // disconnect our handler because our ~wxWindow (which is going to be called
    // after this dtor) will call DestroyChildren(); in turns our children
    // ~wxWindow dtors will call wxWindow::Show(false) and this will generate
    // a call to gtk_mdi_page_change_callback with an invalid parent
    // (because gtk_mdi_page_change_callback expects a wxMDIClientWindow but
    //  at that point of the dtor chain we are a simple wxWindow!)
    g_signal_handlers_disconnect_by_func(m_widget, (void*)switch_page, GetParent());
}

bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
    if ( !PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
         !CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                       style, wxDefaultValidator, "wxMDIClientWindow" ))
    {
        wxFAIL_MSG( "wxMDIClientWindow creation failed" );
        return false;
    }

    m_widget = gtk_notebook_new();
    g_object_ref(m_widget);

    g_signal_connect(m_widget, "switch_page", G_CALLBACK(switch_page), parent);

    gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );

    m_parent->DoAddChild( this );

    PostCreation();

    Show( true );

    return true;
}

void wxMDIClientWindow::AddChildGTK(wxWindowGTK* child)
{
    wxMDIChildFrame* child_frame = static_cast<wxMDIChildFrame*>(child);
    wxString s = child_frame->GetTitle();
    if ( s.empty() )
        s = _("MDI child");

    GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
    gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );

    GtkNotebook* notebook = GTK_NOTEBOOK(m_widget);

    gtk_notebook_append_page( notebook, child->m_widget, label_widget );

    wxMDIParentFrame* parent_frame = static_cast<wxMDIParentFrame*>(GetParent());
    parent_frame->m_justInserted = true;
}

#endif // wxUSE_MDI
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/mdi.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	#if wxUSE_MDI
	14
	15	#include "wx/mdi.h"
	16
	17	#ifndef WX_PRECOMP
	18	#include "wx/intl.h"
	19	#include "wx/menu.h"
	20	#endif
	21
	22	#include "wx/gtk/private.h"
	23
	24	//-----------------------------------------------------------------------------
	25	// "switch_page"
	26	//-----------------------------------------------------------------------------
	27
	28	extern "C" {
	29	static void
	30	switch_page(GtkNotebook* widget, GtkNotebookPage, guint page_num, wxMDIParentFrame parent)
	31	{
	32	// send deactivate event to old child
	33
	34	wxMDIChildFrame *child = parent->GetActiveChild();
	35	if (child)
	36	{
	37	wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
	38	event1.SetEventObject( child);
	39	child->HandleWindowEvent( event1 );
	40	}
	41
	42	// send activate event to new child
	43
	44	wxMDIClientWindowBase *client_window = parent->GetClientWindow();
	45	if ( !client_window )
	46	return;
	47
	48	child = NULL;
	49	GtkWidget* page = gtk_notebook_get_nth_page(widget, page_num);
	50
	51	wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst();
	52	while ( node )
	53	{
	54	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	55
	56	// child_frame can be NULL when this is called from dtor, probably
	57	// because g_signal_connect (m_widget, "switch_page", (see below)
	58	// isn't deleted early enough
	59	if (child_frame && child_frame->m_widget == page)
	60	{
	61	child = child_frame;
	62	break;
	63	}
	64	node = node->GetNext();
	65	}
	66
	67	if (!child)
	68	return;
	69
	70	wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
	71	event2.SetEventObject( child);
	72	child->HandleWindowEvent( event2 );
	73	}
	74	}
	75
	76	//-----------------------------------------------------------------------------
	77	// wxMDIParentFrame
	78	//-----------------------------------------------------------------------------
	79
	80	IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)
	81
	82	void wxMDIParentFrame::Init()
	83	{
	84	m_justInserted = false;
	85	}
	86
	87	bool wxMDIParentFrame::Create(wxWindow *parent,
	88	wxWindowID id,
	89	const wxString& title,
	90	const wxPoint& pos,
	91	const wxSize& size,
	92	long style,
	93	const wxString& name )
	94	{
	95	if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
	96	return false;
	97
	98	m_clientWindow = OnCreateClient();
	99	if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
	100	return false;
	101
	102	return true;
	103	}
	104
	105	void wxMDIParentFrame::OnInternalIdle()
	106	{
	107	/* if a MDI child window has just been inserted
	108	it has to be brought to the top in idle time. we
	109	simply set the last notebook page active as new
	110	pages can only be appended at the end */
	111
	112	if (m_justInserted)
	113	{
	114	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	115	gtk_notebook_set_current_page(notebook, -1);
	116
	117	/* need to set the menubar of the child */
	118	wxMDIChildFrame *active_child_frame = GetActiveChild();
	119	if (active_child_frame != NULL)
	120	{
	121	wxMenuBar *menu_bar = active_child_frame->m_menuBar;
	122	if (menu_bar)
	123	{
	124	menu_bar->Attach(active_child_frame);
	125	}
	126	}
	127	m_justInserted = false;
	128	return;
	129	}
	130
	131	wxFrame::OnInternalIdle();
	132
	133	wxMDIChildFrame *active_child_frame = GetActiveChild();
	134	bool visible_child_menu = false;
	135
	136	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	137	while (node)
	138	{
	139	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	140
	141	if ( child_frame )
	142	{
	143	wxMenuBar *menu_bar = child_frame->m_menuBar;
	144	if ( menu_bar )
	145	{
	146	if (child_frame == active_child_frame)
	147	{
	148	if (menu_bar->Show(true))
	149	{
	150	// Attach() asserts if we call it for an already
	151	// attached menu bar so don't do it if we're already
	152	// associated with this frame (it would be nice to get
	153	// rid of this check and ensure that this doesn't
	154	// happen...)
	155	if ( menu_bar->GetFrame() != child_frame )
	156	menu_bar->Attach( child_frame );
	157	}
	158	visible_child_menu = true;
	159	}
	160	else
	161	{
	162	if (menu_bar->Show(false))
	163	{
	164	menu_bar->Detach();
	165	}
	166	}
	167	}
	168	}
	169
	170	node = node->GetNext();
	171	}
	172
	173	/* show/hide parent menu bar as required */
	174	if ((m_frameMenuBar) &&
	175	(m_frameMenuBar->IsShown() == visible_child_menu))
	176	{
	177	if (visible_child_menu)
	178	{
	179	m_frameMenuBar->Show( false );
	180	m_frameMenuBar->Detach();
	181	}
	182	else
	183	{
	184	m_frameMenuBar->Show( true );
	185	m_frameMenuBar->Attach( this );
	186	}
	187	}
	188	}
	189
	190	void wxMDIParentFrame::DoGetClientSize(int* width, int* height) const
	191	{
	192	wxFrame::DoGetClientSize(width, height);
	193
	194	if (height)
	195	{
	196	wxMDIChildFrame* active_child_frame = GetActiveChild();
	197	if (active_child_frame)
	198	{
	199	wxMenuBar* menubar = active_child_frame->m_menuBar;
	200	if (menubar && menubar->IsShown())
	201	{
	202	GtkRequisition req;
	203	gtk_widget_size_request(menubar->m_widget, &req);
	204	*height -= req.height;
	205	if (height < 0) height = 0;
	206	}
	207	}
	208	}
	209	}
	210
	211	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	212	{
	213	if (!m_clientWindow) return NULL;
	214
	215	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	216	if (!notebook) return NULL;
	217
	218	gint i = gtk_notebook_get_current_page( notebook );
	219	if (i < 0) return NULL;
	220
	221	GtkWidget* page = gtk_notebook_get_nth_page(notebook, i);
	222	if (!page) return NULL;
	223
	224	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	225	while (node)
	226	{
	227	if ( wxPendingDelete.Member(node->GetData()) )
	228	return NULL;
	229
	230	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	231
	232	if (!child_frame)
	233	return NULL;
	234
	235	if (child_frame->m_widget == page)
	236	return child_frame;
	237
	238	node = node->GetNext();
	239	}
	240
	241	return NULL;
	242	}
	243
	244	void wxMDIParentFrame::ActivateNext()
	245	{
	246	if (m_clientWindow)
	247	gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	248	}
	249
	250	void wxMDIParentFrame::ActivatePrevious()
	251	{
	252	if (m_clientWindow)
	253	gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	254	}
	255
	256	//-----------------------------------------------------------------------------
	257	// wxMDIChildFrame
	258	//-----------------------------------------------------------------------------
	259
	260	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	261
	262	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	263	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	264	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	265	END_EVENT_TABLE()
	266
	267	void wxMDIChildFrame::Init()
	268	{
	269	m_menuBar = NULL;
	270	}
	271
	272	bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
	273	wxWindowID id,
	274	const wxString& title,
	275	const wxPoint& WXUNUSED(pos),
	276	const wxSize& size,
	277	long style,
	278	const wxString& name)
	279	{
	280	m_mdiParent = parent;
	281	m_title = title;
	282
	283	return wxWindow::Create(parent->GetClientWindow(), id,
	284	wxDefaultPosition, size,
	285	style, name);
	286	}
	287
	288	wxMDIChildFrame::~wxMDIChildFrame()
	289	{
	290	delete m_menuBar;
	291
	292	// wxMDIClientWindow does not get redrawn properly after last child is removed
	293	if (m_parent && m_parent->GetChildren().size() <= 1)
	294	gtk_widget_queue_draw(m_parent->m_widget);
	295	}
	296
	297	void wxMDIChildFrame::GTKHandleRealized()
	298	{
	299	// since m_widget is not a GtkWindow, must bypass wxTopLevelWindowGTK
	300	wxTopLevelWindowBase::GTKHandleRealized();
	301	}
	302
	303	void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
	304	{
	305	wxASSERT_MSG( m_menuBar == NULL, "Only one menubar allowed" );
	306
	307	m_menuBar = menu_bar;
	308
	309	if (m_menuBar)
	310	{
	311	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	312
	313	m_menuBar->SetParent( mdi_frame );
	314
	315	/* insert the invisible menu bar into the _parent_ mdi frame */
	316	m_menuBar->Show(false);
	317	gtk_box_pack_start(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, false, false, 0);
	318	gtk_box_reorder_child(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, 0);
	319
	320	gulong handler_id = g_signal_handler_find(
	321	m_menuBar->m_widget,
	322	GSignalMatchType(G_SIGNAL_MATCH_ID \| G_SIGNAL_MATCH_DATA),
	323	g_signal_lookup("size_request", GTK_TYPE_WIDGET),
	324	0, NULL, NULL, m_menuBar);
	325	if (handler_id != 0)
	326	g_signal_handler_disconnect(m_menuBar->m_widget, handler_id);
	327	gtk_widget_set_size_request(m_menuBar->m_widget, -1, -1);
	328	}
	329	}
	330
	331	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	332	{
	333	return m_menuBar;
	334	}
	335
	336	GtkNotebook *wxMDIChildFrame::GTKGetNotebook() const
	337	{
	338	wxMDIClientWindow * const
	339	client = wxStaticCast(GetParent(), wxMDIClientWindow);
	340	wxCHECK( client, NULL );
	341
	342	return GTK_NOTEBOOK(client->m_widget);
	343	}
	344
	345	void wxMDIChildFrame::Activate()
	346	{
	347	GtkNotebook * const notebook = GTKGetNotebook();
	348	wxCHECK_RET( notebook, "no parent notebook?" );
	349
	350	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	351	gtk_notebook_set_current_page( notebook, pageno );
	352	}
	353
	354	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	355	{
	356	}
	357
	358	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	359	{
	360	#if wxUSE_STATUSBAR
	361	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	362	if ( !ShowMenuHelp(event.GetMenuId()) )
	363	{
	364	// we don't have any help text for this item, but may be the MDI frame
	365	// does?
	366	mdi_frame->OnMenuHighlight(event);
	367	}
	368	#endif // wxUSE_STATUSBAR
	369	}
	370
	371	void wxMDIChildFrame::SetTitle( const wxString &title )
	372	{
	373	if ( title == m_title )
	374	return;
	375
	376	m_title = title;
	377
	378	GtkNotebook * const notebook = GTKGetNotebook();
	379	wxCHECK_RET( notebook, "no parent notebook?" );
	380	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	381	}
	382
	383	//-----------------------------------------------------------------------------
	384	// wxMDIClientWindow
	385	//-----------------------------------------------------------------------------
	386
	387	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
	388
	389	wxMDIClientWindow::~wxMDIClientWindow()
	390	{
	391	// disconnect our handler because our ~wxWindow (which is going to be called
	392	// after this dtor) will call DestroyChildren(); in turns our children
	393	// ~wxWindow dtors will call wxWindow::Show(false) and this will generate
	394	// a call to gtk_mdi_page_change_callback with an invalid parent
	395	// (because gtk_mdi_page_change_callback expects a wxMDIClientWindow but
	396	// at that point of the dtor chain we are a simple wxWindow!)
	397	g_signal_handlers_disconnect_by_func(m_widget, (void*)switch_page, GetParent());
	398	}
	399
	400	bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
	401	{
	402	if ( !PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	403	!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
	404	style, wxDefaultValidator, "wxMDIClientWindow" ))
	405	{
	406	wxFAIL_MSG( "wxMDIClientWindow creation failed" );
	407	return false;
	408	}
	409
	410	m_widget = gtk_notebook_new();
	411	g_object_ref(m_widget);
	412
	413	g_signal_connect(m_widget, "switch_page", G_CALLBACK(switch_page), parent);
	414
	415	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	416
	417	m_parent->DoAddChild( this );
	418
	419	PostCreation();
	420
	421	Show( true );
	422
	423	return true;
	424	}
	425
	426	void wxMDIClientWindow::AddChildGTK(wxWindowGTK* child)
	427	{
	428	wxMDIChildFrame* child_frame = static_cast<wxMDIChildFrame*>(child);
	429	wxString s = child_frame->GetTitle();
	430	if ( s.empty() )
	431	s = _("MDI child");
	432
	433	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	434	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	435
	436	GtkNotebook* notebook = GTK_NOTEBOOK(m_widget);
	437
	438	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	439
	440	wxMDIParentFrame* parent_frame = static_cast<wxMDIParentFrame*>(GetParent());
	441	parent_frame->m_justInserted = true;
	442	}
	443
	444	#endif // wxUSE_MDI