src/gtk1/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 *WXUNUSED(page),
                                              gint WXUNUSED(page),
                                              wxMDIParentFrame *parent )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    wxMDIChildFrame *child = parent->GetActiveChild();

    if (!child) return;

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

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