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

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

    child = (wxMDIChildFrame*) 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;
    m_clientWindow = (wxMDIClientWindow *) NULL;
}

wxMDIParentFrame::~wxMDIParentFrame()
{
}

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();

    return m_clientWindow != NULL;
}

void wxMDIParentFrame::OnInternalIdle()
{
    /* if a an 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 (wxMDIChildFrame*) NULL;

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

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

    GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
    if (!page) return (wxMDIChildFrame*) NULL;

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

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

        if (!child_frame)
            return (wxMDIChildFrame*) NULL;

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

        node = node->GetNext();
    }

    return (wxMDIChildFrame*) NULL;
}

wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
{
    return m_clientWindow;
}

wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
{
    return new wxMDIClientWindow( this );
}

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()

wxMDIChildFrame::wxMDIChildFrame()
{
    m_menuBar = (wxMenuBar *) NULL;
    m_page = (GtkNotebookPage *) NULL;
}

wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
      wxWindowID id, const wxString& title,
      const wxPoint& WXUNUSED(pos), const wxSize& size,
      long style, const wxString& name )
{
    m_menuBar = (wxMenuBar *) NULL;
    m_page = (GtkNotebookPage *) NULL;
    Create( parent, id, title, wxDefaultPosition, size, style, name );
}

wxMDIChildFrame::~wxMDIChildFrame()
{
    if (m_menuBar)
        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);
}

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

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

bool wxMDIChildFrame::Destroy()
{
    // delayed destruction: the frame will be deleted during
    // the next idle loop iteration.
    // I'm not sure if delayed destruction really makes so
    // much sense for MDI child frames, actually, but hiding
    // it doesn't make any sense.
    if ( !wxPendingDelete.Member(this) )
        wxPendingDelete.Append(this);

    return true;
}

void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{
    wxWindow::DoSetSize( x, y, width, height, sizeFlags );
}

void wxMDIChildFrame::AddChild( wxWindowBase *child )
{
    wxWindow::AddChild(child);
}

void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
{
    wxASSERT_MSG( m_menuBar == NULL, wxT("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;
}

void wxMDIChildFrame::Activate()
{
    wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
    GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
    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;

    wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
    GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
    gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
}

//-----------------------------------------------------------------------------
// InsertChild callback for wxMDIClientWindow
//-----------------------------------------------------------------------------

static void wxInsertChildInMDI(wxWindow* parent, wxWindow* child)
{
    wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
    wxString s = child_frame->GetTitle();
    if (s.IsNull()) 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(parent->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 = wx_static_cast(wxMDIParentFrame*, parent->GetParent());
    parent_frame->m_justInserted = true;
}

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

IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)

wxMDIClientWindow::wxMDIClientWindow()
{
}

wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
{
    CreateClient( parent, style );
}

wxMDIClientWindow::~wxMDIClientWindow()
{

}

bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
{
    m_insertCallback = wxInsertChildInMDI;

    if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
        !CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
    {
        wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
        return false;
    }

    m_widget = gtk_notebook_new();

    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;
}

#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	wxMDIClientWindow *client_window = parent->GetClientWindow();
	48	if (!client_window)
	49	return;
	50
	51	child = (wxMDIChildFrame*) 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	m_clientWindow = (wxMDIClientWindow *) NULL;
	88	}
	89
	90	wxMDIParentFrame::~wxMDIParentFrame()
	91	{
	92	}
	93
	94	bool wxMDIParentFrame::Create(wxWindow *parent,
	95	wxWindowID id,
	96	const wxString& title,
	97	const wxPoint& pos,
	98	const wxSize& size,
	99	long style,
	100	const wxString& name )
	101	{
	102	if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
	103	return false;
	104
	105	m_clientWindow = OnCreateClient();
	106
	107	return m_clientWindow != NULL;
	108	}
	109
	110	void wxMDIParentFrame::OnInternalIdle()
	111	{
	112	/* if a an MDI child window has just been inserted
	113	it has to be brought to the top in idle time. we
	114	simply set the last notebook page active as new
	115	pages can only be appended at the end */
	116
	117	if (m_justInserted)
	118	{
	119	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	120	gtk_notebook_set_current_page( notebook, g_list_length( notebook->children ) - 1 );
	121
	122	/* need to set the menubar of the child */
	123	wxMDIChildFrame *active_child_frame = GetActiveChild();
	124	if (active_child_frame != NULL)
	125	{
	126	wxMenuBar *menu_bar = active_child_frame->m_menuBar;
	127	if (menu_bar)
	128	{
	129	menu_bar->SetInvokingWindow(active_child_frame);
	130	}
	131	}
	132	m_justInserted = false;
	133	return;
	134	}
	135
	136	wxFrame::OnInternalIdle();
	137
	138	wxMDIChildFrame *active_child_frame = GetActiveChild();
	139	bool visible_child_menu = false;
	140
	141	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	142	while (node)
	143	{
	144	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	145
	146	if ( child_frame )
	147	{
	148	wxMenuBar *menu_bar = child_frame->m_menuBar;
	149	if ( menu_bar )
	150	{
	151	if (child_frame == active_child_frame)
	152	{
	153	if (menu_bar->Show(true))
	154	{
	155	menu_bar->SetInvokingWindow( child_frame );
	156	}
	157	visible_child_menu = true;
	158	}
	159	else
	160	{
	161	if (menu_bar->Show(false))
	162	{
	163	menu_bar->UnsetInvokingWindow( child_frame );
	164	}
	165	}
	166	}
	167	}
	168
	169	node = node->GetNext();
	170	}
	171
	172	/* show/hide parent menu bar as required */
	173	if ((m_frameMenuBar) &&
	174	(m_frameMenuBar->IsShown() == visible_child_menu))
	175	{
	176	if (visible_child_menu)
	177	{
	178	m_frameMenuBar->Show( false );
	179	m_frameMenuBar->UnsetInvokingWindow( this );
	180	}
	181	else
	182	{
	183	m_frameMenuBar->Show( true );
	184	m_frameMenuBar->SetInvokingWindow( this );
	185	}
	186	}
	187	}
	188
	189	void wxMDIParentFrame::DoGetClientSize(int* width, int* height) const
	190	{
	191	wxFrame::DoGetClientSize(width, height);
	192
	193	if (height)
	194	{
	195	wxMDIChildFrame* active_child_frame = GetActiveChild();
	196	if (active_child_frame)
	197	{
	198	wxMenuBar* menubar = active_child_frame->m_menuBar;
	199	if (menubar && menubar->IsShown())
	200	{
	201	GtkRequisition req;
	202	gtk_widget_size_request(menubar->m_widget, &req);
	203	*height -= req.height;
	204	if (height < 0) height = 0;
	205	}
	206	}
	207	}
	208	}
	209
	210	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	211	{
	212	if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
	213
	214	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	215	if (!notebook) return (wxMDIChildFrame*) NULL;
	216
	217	gint i = gtk_notebook_get_current_page( notebook );
	218	if (i < 0) return (wxMDIChildFrame*) NULL;
	219
	220	GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
	221	if (!page) return (wxMDIChildFrame*) NULL;
	222
	223	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	224	while (node)
	225	{
	226	if ( wxPendingDelete.Member(node->GetData()) )
	227	return (wxMDIChildFrame*) NULL;
	228
	229	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	230
	231	if (!child_frame)
	232	return (wxMDIChildFrame*) NULL;
	233
	234	if (child_frame->m_page == page)
	235	return child_frame;
	236
	237	node = node->GetNext();
	238	}
	239
	240	return (wxMDIChildFrame*) NULL;
	241	}
	242
	243	wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
	244	{
	245	return m_clientWindow;
	246	}
	247
	248	wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
	249	{
	250	return new wxMDIClientWindow( this );
	251	}
	252
	253	void wxMDIParentFrame::ActivateNext()
	254	{
	255	if (m_clientWindow)
	256	gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	257	}
	258
	259	void wxMDIParentFrame::ActivatePrevious()
	260	{
	261	if (m_clientWindow)
	262	gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	263	}
	264
	265	//-----------------------------------------------------------------------------
	266	// wxMDIChildFrame
	267	//-----------------------------------------------------------------------------
	268
	269	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	270
	271	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	272	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	273	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	274	END_EVENT_TABLE()
	275
	276	wxMDIChildFrame::wxMDIChildFrame()
	277	{
	278	m_menuBar = (wxMenuBar *) NULL;
	279	m_page = (GtkNotebookPage *) NULL;
	280	}
	281
	282	wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
	283	wxWindowID id, const wxString& title,
	284	const wxPoint& WXUNUSED(pos), const wxSize& size,
	285	long style, const wxString& name )
	286	{
	287	m_menuBar = (wxMenuBar *) NULL;
	288	m_page = (GtkNotebookPage *) NULL;
	289	Create( parent, id, title, wxDefaultPosition, size, style, name );
	290	}
	291
	292	wxMDIChildFrame::~wxMDIChildFrame()
	293	{
	294	if (m_menuBar)
	295	delete m_menuBar;
	296
	297	// wxMDIClientWindow does not get redrawn properly after last child is removed
	298	if (m_parent && m_parent->GetChildren().size() <= 1)
	299	gtk_widget_queue_draw(m_parent->m_widget);
	300	}
	301
	302	bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
	303	wxWindowID id, const wxString& title,
	304	const wxPoint& WXUNUSED(pos), const wxSize& size,
	305	long style, const wxString& name )
	306	{
	307	m_title = title;
	308
	309	return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
	310	}
	311
	312	bool wxMDIChildFrame::Destroy()
	313	{
	314	// delayed destruction: the frame will be deleted during
	315	// the next idle loop iteration.
	316	// I'm not sure if delayed destruction really makes so
	317	// much sense for MDI child frames, actually, but hiding
	318	// it doesn't make any sense.
	319	if ( !wxPendingDelete.Member(this) )
	320	wxPendingDelete.Append(this);
	321
	322	return true;
	323	}
	324
	325	void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	326	{
	327	wxWindow::DoSetSize( x, y, width, height, sizeFlags );
	328	}
	329
	330	void wxMDIChildFrame::AddChild( wxWindowBase *child )
	331	{
	332	wxWindow::AddChild(child);
	333	}
	334
	335	void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
	336	{
	337	wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );
	338
	339	m_menuBar = menu_bar;
	340
	341	if (m_menuBar)
	342	{
	343	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	344
	345	m_menuBar->SetParent( mdi_frame );
	346
	347	/* insert the invisible menu bar into the _parent_ mdi frame */
	348	m_menuBar->Show(false);
	349	gtk_box_pack_start(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, false, false, 0);
	350	gtk_box_reorder_child(GTK_BOX(mdi_frame->m_mainWidget), m_menuBar->m_widget, 0);
	351
	352	gulong handler_id = g_signal_handler_find(
	353	m_menuBar->m_widget,
	354	GSignalMatchType(G_SIGNAL_MATCH_ID \| G_SIGNAL_MATCH_DATA),
	355	g_signal_lookup("size_request", GTK_TYPE_WIDGET),
	356	0, NULL, NULL, m_menuBar);
	357	if (handler_id != 0)
	358	g_signal_handler_disconnect(m_menuBar->m_widget, handler_id);
	359	gtk_widget_set_size_request(m_menuBar->m_widget, -1, -1);
	360	}
	361	}
	362
	363	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	364	{
	365	return m_menuBar;
	366	}
	367
	368	void wxMDIChildFrame::Activate()
	369	{
	370	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	371	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	372	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	373	gtk_notebook_set_current_page( notebook, pageno );
	374	}
	375
	376	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	377	{
	378	}
	379
	380	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	381	{
	382	#if wxUSE_STATUSBAR
	383	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	384	if ( !ShowMenuHelp(event.GetMenuId()) )
	385	{
	386	// we don't have any help text for this item, but may be the MDI frame
	387	// does?
	388	mdi_frame->OnMenuHighlight(event);
	389	}
	390	#endif // wxUSE_STATUSBAR
	391	}
	392
	393	void wxMDIChildFrame::SetTitle( const wxString &title )
	394	{
	395	if ( title == m_title )
	396	return;
	397
	398	m_title = title;
	399
	400	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	401	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	402	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	403	}
	404
	405	//-----------------------------------------------------------------------------
	406	// InsertChild callback for wxMDIClientWindow
	407	//-----------------------------------------------------------------------------
	408
	409	static void wxInsertChildInMDI(wxWindow* parent, wxWindow* child)
	410	{
	411	wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
	412	wxString s = child_frame->GetTitle();
	413	if (s.IsNull()) s = _("MDI child");
	414
	415	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	416	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	417
	418	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	419
	420	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	421
	422	child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	423
	424	wxMDIParentFrame parent_frame = wx_static_cast(wxMDIParentFrame, parent->GetParent());
	425	parent_frame->m_justInserted = true;
	426	}
	427
	428	//-----------------------------------------------------------------------------
	429	// wxMDIClientWindow
	430	//-----------------------------------------------------------------------------
	431
	432	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
	433
	434	wxMDIClientWindow::wxMDIClientWindow()
	435	{
	436	}
	437
	438	wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
	439	{
	440	CreateClient( parent, style );
	441	}
	442
	443	wxMDIClientWindow::~wxMDIClientWindow()
	444	{
	445
	446	}
	447
	448	bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
	449	{
	450	m_insertCallback = wxInsertChildInMDI;
	451
	452	if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	453	!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
	454	{
	455	wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	456	return false;
	457	}
	458
	459	m_widget = gtk_notebook_new();
	460
	461	g_signal_connect (m_widget, "switch_page",
	462	G_CALLBACK (gtk_mdi_page_change_callback), parent);
	463
	464	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	465
	466	m_parent->DoAddChild( this );
	467
	468	PostCreation();
	469
	470	Show( true );
	471
	472	return true;
	473	}
	474
	475	#endif // wxUSE_MDI