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"
    #include "wx/dialog.h"
#endif

#include "wx/notebook.h"
#include "wx/gtk/private.h"

#include <gtk/gtk.h>
#include "wx/gtk/win_gtk.h"

//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------

const int wxMENU_HEIGHT = 27;

//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// "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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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::GtkOnSize()
{
    wxFrame::GtkOnSize();

    wxMDIChildFrame *child_frame = GetActiveChild();
    if (!child_frame) return;

    wxMenuBar *menu_bar = child_frame->m_menuBar;
    if (!menu_bar) return;
    if (!menu_bar->m_widget) return;

    menu_bar->m_x = 0;
    menu_bar->m_y = 0;
    menu_bar->m_width = m_width;
    menu_bar->m_height = wxMENU_HEIGHT;
    gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                          menu_bar->m_widget,
                          0, 0, m_width, wxMENU_HEIGHT );
}

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->m_width = m_width;
                menu_bar->m_height = wxMENU_HEIGHT;
                gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                    menu_bar->m_widget,
                                    0, 0, m_width, wxMENU_HEIGHT );
                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->m_width = m_width;
                        menu_bar->m_height = wxMENU_HEIGHT;
                        gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                            menu_bar->m_widget,
                                            0, 0, m_width, wxMENU_HEIGHT );
                        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 );

            m_frameMenuBar->m_width = m_width;
            m_frameMenuBar->m_height = wxMENU_HEIGHT;
            gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                m_frameMenuBar->m_widget,
                                0, 0, m_width, wxMENU_HEIGHT );
        }
    }
}

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

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 */
        gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
                         m_menuBar->m_widget,
                         0, 0,  mdi_frame->m_width, wxMENU_HEIGHT );
    }
}

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

//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------

extern "C" {
static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxMDIChildFrame *win )
{
    if ((win->m_x == alloc->x) &&
        (win->m_y == alloc->y) &&
        (win->m_width == alloc->width) &&
        (win->m_height == alloc->height) &&
        (win->m_sizeSet))
    {
        return;
    }

    win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
}
}

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

    g_signal_connect (child->m_widget, "size_allocate",
                      G_CALLBACK (gtk_page_size_callback), child);

    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	#include "wx/dialog.h"
	21	#endif
	22
	23	#include "wx/notebook.h"
	24	#include "wx/gtk/private.h"
	25
	26	#include <gtk/gtk.h>
	27	#include "wx/gtk/win_gtk.h"
	28
	29	//-----------------------------------------------------------------------------
	30	// constants
	31	//-----------------------------------------------------------------------------
	32
	33	const int wxMENU_HEIGHT = 27;
	34
	35	//-----------------------------------------------------------------------------
	36	// globals
	37	//-----------------------------------------------------------------------------
	38
	39	//-----------------------------------------------------------------------------
	40	// "switch_page"
	41	//-----------------------------------------------------------------------------
	42
	43	extern "C" {
	44	static void
	45	gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
	46	GtkNotebookPage *page,
	47	gint WXUNUSED(page_num),
	48	wxMDIParentFrame *parent )
	49	{
	50	// send deactivate event to old child
	51
	52	wxMDIChildFrame *child = parent->GetActiveChild();
	53	if (child)
	54	{
	55	wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
	56	event1.SetEventObject( child);
	57	child->GetEventHandler()->ProcessEvent( event1 );
	58	}
	59
	60	// send activate event to new child
	61
	62	wxMDIClientWindow *client_window = parent->GetClientWindow();
	63	if (!client_window)
	64	return;
	65
	66	child = (wxMDIChildFrame*) NULL;
	67
	68	wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst();
	69	while ( node )
	70	{
	71	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	72
	73	// child_frame can be NULL when this is called from dtor, probably
	74	// because g_signal_connect (m_widget, "switch_page", (see below)
	75	// isn't deleted early enough
	76	if ( child_frame && child_frame->m_page == page )
	77	{
	78	child = child_frame;
	79	break;
	80	}
	81	node = node->GetNext();
	82	}
	83
	84	if (!child)
	85	return;
	86
	87	wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
	88	event2.SetEventObject( child);
	89	child->GetEventHandler()->ProcessEvent( event2 );
	90	}
	91	}
	92
	93	//-----------------------------------------------------------------------------
	94	// wxMDIParentFrame
	95	//-----------------------------------------------------------------------------
	96
	97	IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)
	98
	99	void wxMDIParentFrame::Init()
	100	{
	101	m_justInserted = false;
	102	m_clientWindow = (wxMDIClientWindow *) NULL;
	103	}
	104
	105	wxMDIParentFrame::~wxMDIParentFrame()
	106	{
	107	}
	108
	109	bool wxMDIParentFrame::Create(wxWindow *parent,
	110	wxWindowID id,
	111	const wxString& title,
	112	const wxPoint& pos,
	113	const wxSize& size,
	114	long style,
	115	const wxString& name )
	116	{
	117	wxFrame::Create( parent, id, title, pos, size, style, name );
	118
	119	OnCreateClient();
	120
	121	return true;
	122	}
	123
	124	void wxMDIParentFrame::GtkOnSize()
	125	{
	126	wxFrame::GtkOnSize();
	127
	128	wxMDIChildFrame *child_frame = GetActiveChild();
	129	if (!child_frame) return;
	130
	131	wxMenuBar *menu_bar = child_frame->m_menuBar;
	132	if (!menu_bar) return;
	133	if (!menu_bar->m_widget) return;
	134
	135	menu_bar->m_x = 0;
	136	menu_bar->m_y = 0;
	137	menu_bar->m_width = m_width;
	138	menu_bar->m_height = wxMENU_HEIGHT;
	139	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	140	menu_bar->m_widget,
	141	0, 0, m_width, wxMENU_HEIGHT );
	142	}
	143
	144	void wxMDIParentFrame::OnInternalIdle()
	145	{
	146	/* if a an MDI child window has just been inserted
	147	it has to be brought to the top in idle time. we
	148	simply set the last notebook page active as new
	149	pages can only be appended at the end */
	150
	151	if (m_justInserted)
	152	{
	153	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	154	gtk_notebook_set_current_page( notebook, g_list_length( notebook->children ) - 1 );
	155
	156	/* need to set the menubar of the child */
	157	wxMDIChildFrame *active_child_frame = GetActiveChild();
	158	if (active_child_frame != NULL)
	159	{
	160	wxMenuBar *menu_bar = active_child_frame->m_menuBar;
	161	if (menu_bar)
	162	{
	163	menu_bar->m_width = m_width;
	164	menu_bar->m_height = wxMENU_HEIGHT;
	165	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	166	menu_bar->m_widget,
	167	0, 0, m_width, wxMENU_HEIGHT );
	168	menu_bar->SetInvokingWindow(active_child_frame);
	169	}
	170	}
	171	m_justInserted = false;
	172	return;
	173	}
	174
	175	wxFrame::OnInternalIdle();
	176
	177	wxMDIChildFrame *active_child_frame = GetActiveChild();
	178	bool visible_child_menu = false;
	179
	180	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	181	while (node)
	182	{
	183	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	184
	185	if ( child_frame )
	186	{
	187	wxMenuBar *menu_bar = child_frame->m_menuBar;
	188	if ( menu_bar )
	189	{
	190	if (child_frame == active_child_frame)
	191	{
	192	if (menu_bar->Show(true))
	193	{
	194	menu_bar->m_width = m_width;
	195	menu_bar->m_height = wxMENU_HEIGHT;
	196	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	197	menu_bar->m_widget,
	198	0, 0, m_width, wxMENU_HEIGHT );
	199	menu_bar->SetInvokingWindow( child_frame );
	200	}
	201	visible_child_menu = true;
	202	}
	203	else
	204	{
	205	if (menu_bar->Show(false))
	206	{
	207	menu_bar->UnsetInvokingWindow( child_frame );
	208	}
	209	}
	210	}
	211	}
	212
	213	node = node->GetNext();
	214	}
	215
	216	/* show/hide parent menu bar as required */
	217	if ((m_frameMenuBar) &&
	218	(m_frameMenuBar->IsShown() == visible_child_menu))
	219	{
	220	if (visible_child_menu)
	221	{
	222	m_frameMenuBar->Show( false );
	223	m_frameMenuBar->UnsetInvokingWindow( this );
	224	}
	225	else
	226	{
	227	m_frameMenuBar->Show( true );
	228	m_frameMenuBar->SetInvokingWindow( this );
	229
	230	m_frameMenuBar->m_width = m_width;
	231	m_frameMenuBar->m_height = wxMENU_HEIGHT;
	232	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	233	m_frameMenuBar->m_widget,
	234	0, 0, m_width, wxMENU_HEIGHT );
	235	}
	236	}
	237	}
	238
	239	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	240	{
	241	if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
	242
	243	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	244	if (!notebook) return (wxMDIChildFrame*) NULL;
	245
	246	gint i = gtk_notebook_get_current_page( notebook );
	247	if (i < 0) return (wxMDIChildFrame*) NULL;
	248
	249	GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
	250	if (!page) return (wxMDIChildFrame*) NULL;
	251
	252	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	253	while (node)
	254	{
	255	if ( wxPendingDelete.Member(node->GetData()) )
	256	return (wxMDIChildFrame*) NULL;
	257
	258	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	259
	260	if (!child_frame)
	261	return (wxMDIChildFrame*) NULL;
	262
	263	if (child_frame->m_page == page)
	264	return child_frame;
	265
	266	node = node->GetNext();
	267	}
	268
	269	return (wxMDIChildFrame*) NULL;
	270	}
	271
	272	wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
	273	{
	274	return m_clientWindow;
	275	}
	276
	277	wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
	278	{
	279	m_clientWindow = new wxMDIClientWindow( this );
	280	return m_clientWindow;
	281	}
	282
	283	void wxMDIParentFrame::ActivateNext()
	284	{
	285	if (m_clientWindow)
	286	gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	287	}
	288
	289	void wxMDIParentFrame::ActivatePrevious()
	290	{
	291	if (m_clientWindow)
	292	gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	293	}
	294
	295	//-----------------------------------------------------------------------------
	296	// wxMDIChildFrame
	297	//-----------------------------------------------------------------------------
	298
	299	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	300
	301	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	302	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	303	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	304	END_EVENT_TABLE()
	305
	306	wxMDIChildFrame::wxMDIChildFrame()
	307	{
	308	m_menuBar = (wxMenuBar *) NULL;
	309	m_page = (GtkNotebookPage *) NULL;
	310	}
	311
	312	wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
	313	wxWindowID id, const wxString& title,
	314	const wxPoint& WXUNUSED(pos), const wxSize& size,
	315	long style, const wxString& name )
	316	{
	317	m_menuBar = (wxMenuBar *) NULL;
	318	m_page = (GtkNotebookPage *) NULL;
	319	Create( parent, id, title, wxDefaultPosition, size, style, name );
	320	}
	321
	322	wxMDIChildFrame::~wxMDIChildFrame()
	323	{
	324	if (m_menuBar)
	325	delete m_menuBar;
	326	}
	327
	328	bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
	329	wxWindowID id, const wxString& title,
	330	const wxPoint& WXUNUSED(pos), const wxSize& size,
	331	long style, const wxString& name )
	332	{
	333	m_title = title;
	334
	335	return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
	336	}
	337
	338	bool wxMDIChildFrame::Destroy()
	339	{
	340	// delayed destruction: the frame will be deleted during
	341	// the next idle loop iteration.
	342	// I'm not sure if delayed destruction really makes so
	343	// much sense for MDI child frames, actually, but hiding
	344	// it doesn't make any sense.
	345	if ( !wxPendingDelete.Member(this) )
	346	wxPendingDelete.Append(this);
	347
	348	return true;
	349	}
	350
	351	void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	352	{
	353	wxWindow::DoSetSize( x, y, width, height, sizeFlags );
	354	}
	355
	356	void wxMDIChildFrame::AddChild( wxWindowBase *child )
	357	{
	358	wxWindow::AddChild(child);
	359	}
	360
	361	void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
	362	{
	363	wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );
	364
	365	m_menuBar = menu_bar;
	366
	367	if (m_menuBar)
	368	{
	369	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	370
	371	m_menuBar->SetParent( mdi_frame );
	372
	373	/* insert the invisible menu bar into the _parent_ mdi frame */
	374	gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
	375	m_menuBar->m_widget,
	376	0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
	377	}
	378	}
	379
	380	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	381	{
	382	return m_menuBar;
	383	}
	384
	385	void wxMDIChildFrame::Activate()
	386	{
	387	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	388	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	389	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	390	gtk_notebook_set_current_page( notebook, pageno );
	391	}
	392
	393	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	394	{
	395	}
	396
	397	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	398	{
	399	#if wxUSE_STATUSBAR
	400	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	401	if ( !ShowMenuHelp(event.GetMenuId()) )
	402	{
	403	// we don't have any help text for this item, but may be the MDI frame
	404	// does?
	405	mdi_frame->OnMenuHighlight(event);
	406	}
	407	#endif // wxUSE_STATUSBAR
	408	}
	409
	410	void wxMDIChildFrame::SetTitle( const wxString &title )
	411	{
	412	if ( title == m_title )
	413	return;
	414
	415	m_title = title;
	416
	417	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	418	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	419	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	420	}
	421
	422	//-----------------------------------------------------------------------------
	423	// "size_allocate"
	424	//-----------------------------------------------------------------------------
	425
	426	extern "C" {
	427	static void gtk_page_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxMDIChildFrame *win )
	428	{
	429	if ((win->m_x == alloc->x) &&
	430	(win->m_y == alloc->y) &&
	431	(win->m_width == alloc->width) &&
	432	(win->m_height == alloc->height) &&
	433	(win->m_sizeSet))
	434	{
	435	return;
	436	}
	437
	438	win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
	439	}
	440	}
	441
	442	//-----------------------------------------------------------------------------
	443	// InsertChild callback for wxMDIClientWindow
	444	//-----------------------------------------------------------------------------
	445
	446	static void wxInsertChildInMDI(wxWindow* parent, wxWindow* child)
	447	{
	448	wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
	449	wxString s = child_frame->GetTitle();
	450	if (s.IsNull()) s = _("MDI child");
	451
	452	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	453	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	454
	455	g_signal_connect (child->m_widget, "size_allocate",
	456	G_CALLBACK (gtk_page_size_callback), child);
	457
	458	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	459
	460	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	461
	462	child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	463
	464	wxMDIParentFrame parent_frame = wx_static_cast(wxMDIParentFrame, parent->GetParent());
	465	parent_frame->m_justInserted = true;
	466	}
	467
	468	//-----------------------------------------------------------------------------
	469	// wxMDIClientWindow
	470	//-----------------------------------------------------------------------------
	471
	472	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
	473
	474	wxMDIClientWindow::wxMDIClientWindow()
	475	{
	476	}
	477
	478	wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
	479	{
	480	CreateClient( parent, style );
	481	}
	482
	483	wxMDIClientWindow::~wxMDIClientWindow()
	484	{
	485
	486	}
	487
	488	bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
	489	{
	490	m_insertCallback = wxInsertChildInMDI;
	491
	492	if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	493	!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
	494	{
	495	wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	496	return false;
	497	}
	498
	499	m_widget = gtk_notebook_new();
	500
	501	g_signal_connect (m_widget, "switch_page",
	502	G_CALLBACK (gtk_mdi_page_change_callback), parent);
	503
	504	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	505
	506	m_parent->DoAddChild( this );
	507
	508	PostCreation();
	509
	510	Show( true );
	511
	512	return true;
	513	}
	514
	515	#endif // wxUSE_MDI