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 )
{
    wxFrame::Create( parent, id, title, pos, size, style, name );

    OnCreateClient();

    return true;
}

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()
{
    m_clientWindow = new wxMDIClientWindow( this );
    return m_clientWindow;
}

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	wxFrame::Create( parent, id, title, pos, size, style, name );
	103
	104	OnCreateClient();
	105
	106	return true;
	107	}
	108
	109	void wxMDIParentFrame::OnInternalIdle()
	110	{
	111	/* if a an MDI child window has just been inserted
	112	it has to be brought to the top in idle time. we
	113	simply set the last notebook page active as new
	114	pages can only be appended at the end */
	115
	116	if (m_justInserted)
	117	{
	118	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	119	gtk_notebook_set_current_page( notebook, g_list_length( notebook->children ) - 1 );
	120
	121	/* need to set the menubar of the child */
	122	wxMDIChildFrame *active_child_frame = GetActiveChild();
	123	if (active_child_frame != NULL)
	124	{
	125	wxMenuBar *menu_bar = active_child_frame->m_menuBar;
	126	if (menu_bar)
	127	{
	128	menu_bar->SetInvokingWindow(active_child_frame);
	129	}
	130	}
	131	m_justInserted = false;
	132	return;
	133	}
	134
	135	wxFrame::OnInternalIdle();
	136
	137	wxMDIChildFrame *active_child_frame = GetActiveChild();
	138	bool visible_child_menu = false;
	139
	140	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	141	while (node)
	142	{
	143	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	144
	145	if ( child_frame )
	146	{
	147	wxMenuBar *menu_bar = child_frame->m_menuBar;
	148	if ( menu_bar )
	149	{
	150	if (child_frame == active_child_frame)
	151	{
	152	if (menu_bar->Show(true))
	153	{
	154	menu_bar->SetInvokingWindow( child_frame );
	155	}
	156	visible_child_menu = true;
	157	}
	158	else
	159	{
	160	if (menu_bar->Show(false))
	161	{
	162	menu_bar->UnsetInvokingWindow( child_frame );
	163	}
	164	}
	165	}
	166	}
	167
	168	node = node->GetNext();
	169	}
	170
	171	/* show/hide parent menu bar as required */
	172	if ((m_frameMenuBar) &&
	173	(m_frameMenuBar->IsShown() == visible_child_menu))
	174	{
	175	if (visible_child_menu)
	176	{
	177	m_frameMenuBar->Show( false );
	178	m_frameMenuBar->UnsetInvokingWindow( this );
	179	}
	180	else
	181	{
	182	m_frameMenuBar->Show( true );
	183	m_frameMenuBar->SetInvokingWindow( this );
	184	}
	185	}
	186	}
	187
	188	void wxMDIParentFrame::DoGetClientSize(int* width, int* height) const
	189	{
	190	wxFrame::DoGetClientSize(width, height);
	191
	192	if (height)
	193	{
	194	wxMDIChildFrame* active_child_frame = GetActiveChild();
	195	if (active_child_frame)
	196	{
	197	wxMenuBar* menubar = active_child_frame->m_menuBar;
	198	if (menubar && menubar->IsShown())
	199	{
	200	GtkRequisition req;
	201	gtk_widget_size_request(menubar->m_widget, &req);
	202	*height -= req.height;
	203	if (height < 0) height = 0;
	204	}
	205	}
	206	}
	207	}
	208
	209	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	210	{
	211	if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
	212
	213	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	214	if (!notebook) return (wxMDIChildFrame*) NULL;
	215
	216	gint i = gtk_notebook_get_current_page( notebook );
	217	if (i < 0) return (wxMDIChildFrame*) NULL;
	218
	219	GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
	220	if (!page) return (wxMDIChildFrame*) NULL;
	221
	222	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	223	while (node)
	224	{
	225	if ( wxPendingDelete.Member(node->GetData()) )
	226	return (wxMDIChildFrame*) NULL;
	227
	228	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	229
	230	if (!child_frame)
	231	return (wxMDIChildFrame*) NULL;
	232
	233	if (child_frame->m_page == page)
	234	return child_frame;
	235
	236	node = node->GetNext();
	237	}
	238
	239	return (wxMDIChildFrame*) NULL;
	240	}
	241
	242	wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
	243	{
	244	return m_clientWindow;
	245	}
	246
	247	wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
	248	{
	249	m_clientWindow = new wxMDIClientWindow( this );
	250	return m_clientWindow;
	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