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"

#include "wx/mdi.h"
#include "wx/notebook.h"

#if wxUSE_MDI

#include "wx/dialog.h"
#include "wx/menu.h"
#include "wx/intl.h"
#include "wx/gtk/private.h"

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

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

const int wxMENU_HEIGHT = 27;

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

extern wxList wxPendingDelete;

//-----------------------------------------------------------------------------
// "switch_page"
//-----------------------------------------------------------------------------

extern "C" {
static void
gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
                              GtkNotebookPage *page,
                              gint WXUNUSED(page_num),
                              wxMDIParentFrame *parent )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    // 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 );
        // CE: we come here in the destructor with a null child_frame - I think because
        // g_signal_connect (m_widget, "switch_page", (see below)
        // isn't deleted early enough
        if (!child_frame)
          return ;

        if (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( int x, int y, int width, int height )
{
    wxFrame::GtkOnSize( x, y, width, height );

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

void wxMDIParentFrame::DoGetClientSize(int *width, int *height ) const
{
    wxFrame::DoGetClientSize( width, 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)
    {
        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        wxASSERT_MSG( child_frame, _T("child is not a wxMDIChildFrame") );

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

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

void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
    wxWindow::DoSetClientSize( width, height );
}

void wxMDIChildFrame::DoGetClientSize( int *width, int *height ) const
{
    wxWindow::DoGetClientSize( width, height );
}

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(mdi_frame->GetStatusBar(), 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, wxWindow *win )
{
    if (g_isIdle) wxapp_install_idle_handler();

    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( wxMDIClientWindow* parent, wxMDIChildFrame* child )
{
    wxString s = child->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->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);

    wxMDIParentFrame *parent_frame = (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_needParent = true;

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