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

bool wxMDIParentFrame::HasVisibleMenubar() const
{
    if (wxFrame::HasVisibleMenubar())
        return true;

    wxMDIChildFrame* active_child_frame = GetActiveChild();
    wxMenuBar* menubar = NULL;
    if (active_child_frame)
        menubar = active_child_frame->m_menuBar;
    return menubar && menubar->IsShown();
}

//-----------------------------------------------------------------------------
// 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	bool wxMDIParentFrame::HasVisibleMenubar() const
	296	{
	297	if (wxFrame::HasVisibleMenubar())
	298	return true;
	299
	300	wxMDIChildFrame* active_child_frame = GetActiveChild();
	301	wxMenuBar* menubar = NULL;
	302	if (active_child_frame)
	303	menubar = active_child_frame->m_menuBar;
	304	return menubar && menubar->IsShown();
	305	}
	306
	307	//-----------------------------------------------------------------------------
	308	// wxMDIChildFrame
	309	//-----------------------------------------------------------------------------
	310
	311	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	312
	313	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	314	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	315	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	316	END_EVENT_TABLE()
	317
	318	wxMDIChildFrame::wxMDIChildFrame()
	319	{
	320	m_menuBar = (wxMenuBar *) NULL;
	321	m_page = (GtkNotebookPage *) NULL;
	322	}
	323
	324	wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
	325	wxWindowID id, const wxString& title,
	326	const wxPoint& WXUNUSED(pos), const wxSize& size,
	327	long style, const wxString& name )
	328	{
	329	m_menuBar = (wxMenuBar *) NULL;
	330	m_page = (GtkNotebookPage *) NULL;
	331	Create( parent, id, title, wxDefaultPosition, size, style, name );
	332	}
	333
	334	wxMDIChildFrame::~wxMDIChildFrame()
	335	{
	336	if (m_menuBar)
	337	delete m_menuBar;
	338	}
	339
	340	bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
	341	wxWindowID id, const wxString& title,
	342	const wxPoint& WXUNUSED(pos), const wxSize& size,
	343	long style, const wxString& name )
	344	{
	345	m_title = title;
	346
	347	return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
	348	}
	349
	350	bool wxMDIChildFrame::Destroy()
	351	{
	352	// delayed destruction: the frame will be deleted during
	353	// the next idle loop iteration.
	354	// I'm not sure if delayed destruction really makes so
	355	// much sense for MDI child frames, actually, but hiding
	356	// it doesn't make any sense.
	357	if ( !wxPendingDelete.Member(this) )
	358	wxPendingDelete.Append(this);
	359
	360	return true;
	361	}
	362
	363	void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	364	{
	365	wxWindow::DoSetSize( x, y, width, height, sizeFlags );
	366	}
	367
	368	void wxMDIChildFrame::AddChild( wxWindowBase *child )
	369	{
	370	wxWindow::AddChild(child);
	371	}
	372
	373	void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
	374	{
	375	wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );
	376
	377	m_menuBar = menu_bar;
	378
	379	if (m_menuBar)
	380	{
	381	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	382
	383	m_menuBar->SetParent( mdi_frame );
	384
	385	/* insert the invisible menu bar into the _parent_ mdi frame */
	386	gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
	387	m_menuBar->m_widget,
	388	0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
	389	}
	390	}
	391
	392	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	393	{
	394	return m_menuBar;
	395	}
	396
	397	void wxMDIChildFrame::Activate()
	398	{
	399	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	400	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	401	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	402	gtk_notebook_set_current_page( notebook, pageno );
	403	}
	404
	405	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	406	{
	407	}
	408
	409	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	410	{
	411	#if wxUSE_STATUSBAR
	412	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	413	if ( !ShowMenuHelp(event.GetMenuId()) )
	414	{
	415	// we don't have any help text for this item, but may be the MDI frame
	416	// does?
	417	mdi_frame->OnMenuHighlight(event);
	418	}
	419	#endif // wxUSE_STATUSBAR
	420	}
	421
	422	void wxMDIChildFrame::SetTitle( const wxString &title )
	423	{
	424	if ( title == m_title )
	425	return;
	426
	427	m_title = title;
	428
	429	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	430	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	431	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	432	}
	433
	434	//-----------------------------------------------------------------------------
	435	// "size_allocate"
	436	//-----------------------------------------------------------------------------
	437
	438	extern "C" {
	439	static void gtk_page_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxMDIChildFrame *win )
	440	{
	441	if ((win->m_x == alloc->x) &&
	442	(win->m_y == alloc->y) &&
	443	(win->m_width == alloc->width) &&
	444	(win->m_height == alloc->height) &&
	445	(win->m_sizeSet))
	446	{
	447	return;
	448	}
	449
	450	win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
	451	}
	452	}
	453
	454	//-----------------------------------------------------------------------------
	455	// InsertChild callback for wxMDIClientWindow
	456	//-----------------------------------------------------------------------------
	457
	458	static void wxInsertChildInMDI(wxWindow* parent, wxWindow* child)
	459	{
	460	wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
	461	wxString s = child_frame->GetTitle();
	462	if (s.IsNull()) s = _("MDI child");
	463
	464	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	465	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	466
	467	g_signal_connect (child->m_widget, "size_allocate",
	468	G_CALLBACK (gtk_page_size_callback), child);
	469
	470	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	471
	472	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	473
	474	child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	475
	476	wxMDIParentFrame parent_frame = wx_static_cast(wxMDIParentFrame, parent->GetParent());
	477	parent_frame->m_justInserted = true;
	478	}
	479
	480	//-----------------------------------------------------------------------------
	481	// wxMDIClientWindow
	482	//-----------------------------------------------------------------------------
	483
	484	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
	485
	486	wxMDIClientWindow::wxMDIClientWindow()
	487	{
	488	}
	489
	490	wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
	491	{
	492	CreateClient( parent, style );
	493	}
	494
	495	wxMDIClientWindow::~wxMDIClientWindow()
	496	{
	497
	498	}
	499
	500	bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
	501	{
	502	m_insertCallback = wxInsertChildInMDI;
	503
	504	if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	505	!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
	506	{
	507	wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	508	return false;
	509	}
	510
	511	m_widget = gtk_notebook_new();
	512
	513	g_signal_connect (m_widget, "switch_page",
	514	G_CALLBACK (gtk_mdi_page_change_callback), parent);
	515
	516	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	517
	518	m_parent->DoAddChild( this );
	519
	520	PostCreation();
	521
	522	Show( true );
	523
	524	return true;
	525	}
	526
	527	#endif // wxUSE_MDI