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 <glib.h>
#include <gdk/gdk.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 )
{
    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 );

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