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
gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
                              GtkNotebookPage *page,
                              gint WXUNUSED(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;

    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_page == 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, g_list_length( notebook->children ) - 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->SetInvokingWindow(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))
                    {
                        menu_bar->SetInvokingWindow( child_frame );
                    }
                    visible_child_menu = true;
                }
                else
                {
                    if (menu_bar->Show(false))
                    {
                        menu_bar->UnsetInvokingWindow( child_frame );
                    }
                }
            }
        }

        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->UnsetInvokingWindow( this );
        }
        else
        {
            m_frameMenuBar->Show( true );
            m_frameMenuBar->SetInvokingWindow( 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;

    GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
    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_page == 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;
    m_page = 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::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,
                                         (gpointer)gtk_mdi_page_change_callback,
                                         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 (gtk_mdi_page_change_callback), 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 );

    child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);

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