src/gtk/mdi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        mdi.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "mdi.h"
#endif

#include "wx/mdi.h"

#if wxUSE_MDI_ARCHITECTURE

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

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

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

const int wxMENU_HEIGHT = 27;

//-----------------------------------------------------------------------------
// idle system
//-----------------------------------------------------------------------------

extern void wxapp_install_idle_handler();
extern bool g_isIdle;

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

extern wxList wxPendingDelete;

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

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;

    wxNode *node = client_window->GetChildren().First();
    while (node)
    {
        wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
        if (child_frame->m_page == page)
	{
            child = child_frame;
	    break;
	}
        node = node->Next();
    }

    if (!child)
         return;

    wxActivateEvent event2( wxEVT_ACTIVATE, TRUE, child->GetId() );
    event2.SetEventObject( child);
    child->GetEventHandler()->ProcessEvent( event2 );
}

//-----------------------------------------------------------------------------
// wxMDIParentFrame
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)

BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
END_EVENT_TABLE()

wxMDIParentFrame::wxMDIParentFrame()
{
    m_justInserted = FALSE;
    m_clientWindow = (wxMDIClientWindow *) NULL;
}

wxMDIParentFrame::wxMDIParentFrame( wxWindow *parent,
      wxWindowID id, const wxString& title,
      const wxPoint& pos, const wxSize& size,
      long style, const wxString& name )
{
    m_justInserted = FALSE;
    m_clientWindow = (wxMDIClientWindow *) NULL;
    Create( parent, id, title, pos, size, style, name );
}

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_page( notebook, g_list_length( notebook->children ) - 1 );

        m_justInserted = FALSE;
        return;
    }

    wxFrame::OnInternalIdle();

    wxMDIChildFrame *active_child_frame = GetActiveChild();
    bool visible_child_menu = FALSE;

    wxNode *node = m_clientWindow->GetChildren().First();
    while (node)
    {
        wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
	wxMenuBar *menu_bar = child_frame->m_menuBar;
        if (child_frame->m_menuBar)
        {
            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->Next();
    }

    /* 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::GetClientSize(int *width, int *height ) const
{
    wxFrame::GetClientSize( 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;

#if (GTK_MINOR_VERSION > 0)
    gint i = gtk_notebook_get_current_page( notebook );
#else
    gint i = gtk_notebook_current_page( notebook );
#endif
    if (i < 0) return (wxMDIChildFrame*) NULL;

    GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
    if (!page) return (wxMDIChildFrame*) NULL;

    wxNode *node = m_clientWindow->GetChildren().First();
    while (node)
    {
        wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
        if (child_frame->m_page == page)
            return child_frame;
        node = node->Next();
    }

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

void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
{
}

void wxMDIParentFrame::OnSysColourChanged( wxSysColourChangedEvent& WXUNUSED(event) )
{
}

//-----------------------------------------------------------------------------
// wxMDIChildFrame
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)

BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
    EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
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::GetClientSize( int *width, int *height ) const
{
    wxWindow::GetClientSize( 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()
{
#if (GTK_MINOR_VERSION > 0)
    wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
    GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
    gint pageno = gtk_notebook_page_num( notebook, m_page->child );
    gtk_notebook_set_page( notebook, pageno );
#else
    // the only way I can see to do this under gtk+ 1.0.X would
    // be to keep track of page numbers, start at first and
    // do "next" enough times to get to this page number - messy
    // - J. Russell Smyth
#endif
}

void wxMDIChildFrame::OnActivate( wxActivateEvent &WXUNUSED(event) )
{
}

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

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

    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
      GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)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, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
    {
        wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	return FALSE;
    }

    m_widget = gtk_notebook_new();

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