src/gtk1/mdi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk1/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/gtk1/private.h"

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

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

const int wxMENU_HEIGHT = 27;

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

extern void wxapp_install_idle_handler();
extern bool g_isIdle;

//-----------------------------------------------------------------------------
// 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->HandleWindowEvent( event1 );
    }

    // send activate event to new child

    wxMDIClientWindowBase * const client_window = parent->GetClientWindow();
    if ( !client_window )
        return;

    child = 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
        // gtk_signal_connect( GTK_OBJECT(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->HandleWindowEvent( event2 );
}
}

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

IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)

void wxMDIParentFrame::Init()
{
    m_justInserted = false;
    m_clientWindow = NULL;
}

bool wxMDIParentFrame::Create(wxWindow *parent,
                              wxWindowID id,
                              const wxString& title,
                              const wxPoint& pos,
                              const wxSize& size,
                              long style,
                              const wxString& name )
{
    if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
        return false;

    m_clientWindow = OnCreateClient();
    if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
        return false;

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

        /* need to set the menubar of the child */
        wxMDIChildFrame *active_child_frame = GetActiveChild();
        if (active_child_frame != NULL)
        {
            wxMenuBar *menu_bar = active_child_frame->m_menuBar;
            if (menu_bar)
            {
                menu_bar->m_width = m_width;
                menu_bar->m_height = wxMENU_HEIGHT;
                gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                    menu_bar->m_widget,
                                    0, 0, m_width, wxMENU_HEIGHT );
                menu_bar->SetInvokingWindow(active_child_frame);
            }
        }
        m_justInserted = false;
        return;
    }

    wxFrame::OnInternalIdle();

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

    wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
    while (node)
    {
        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        if ( child_frame )
        {
            wxMenuBar *menu_bar = child_frame->m_menuBar;
            if ( menu_bar )
            {
                if (child_frame == active_child_frame)
                {
                    if (menu_bar->Show(true))
                    {
                        menu_bar->m_width = m_width;
                        menu_bar->m_height = wxMENU_HEIGHT;
                        gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                            menu_bar->m_widget,
                                            0, 0, m_width, wxMENU_HEIGHT );
                        menu_bar->SetInvokingWindow( child_frame );
                    }
                    visible_child_menu = true;
                }
                else
                {
                    if (menu_bar->Show(false))
                    {
                        menu_bar->UnsetInvokingWindow( child_frame );
                    }
                }
            }
        }

        node = node->GetNext();
    }

    /* show/hide parent menu bar as required */
    if ((m_frameMenuBar) &&
        (m_frameMenuBar->IsShown() == visible_child_menu))
    {
        if (visible_child_menu)
        {
            m_frameMenuBar->Show( false );
            m_frameMenuBar->UnsetInvokingWindow( this );
        }
        else
        {
            m_frameMenuBar->Show( true );
            m_frameMenuBar->SetInvokingWindow( this );

            m_frameMenuBar->m_width = m_width;
            m_frameMenuBar->m_height = wxMENU_HEIGHT;
            gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                m_frameMenuBar->m_widget,
                                0, 0, m_width, wxMENU_HEIGHT );
        }
    }
}

wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
    if (!m_clientWindow) return NULL;

    GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
    if (!notebook) return NULL;

    gint i = gtk_notebook_get_current_page( notebook );
    if (i < 0) return NULL;

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

    wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
    while (node)
    {
        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

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

        if (child_frame->m_page == page)
            return child_frame;
        node = node->GetNext();
    }

    return NULL;
}

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()

void wxMDIChildFrame::Init()
{
    m_menuBar = NULL;
    m_page = NULL;
}

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

wxMDIChildFrame::~wxMDIChildFrame()
{
    delete m_menuBar;
}

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

GtkNotebook *wxMDIChildFrame::GTKGetNotebook() const
{
    wxMDIClientWindow * const
        client = wxStaticCast(GetParent(), wxMDIClientWindow);
    wxCHECK( client, NULL );

    return GTK_NOTEBOOK(client->m_widget);
}

void wxMDIChildFrame::Activate()
{
    GtkNotebook * const notebook = GTKGetNotebook();
    wxCHECK_RET( notebook, "no parent notebook?" );

    gint pageno = gtk_notebook_page_num( notebook, m_widget );
    gtk_notebook_set_page( notebook, pageno );
}

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

void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
{
#if wxUSE_STATUSBAR
    wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
    if ( !ShowMenuHelp(event.GetMenuId()) )
    {
        // we don't have any help text for this item, but may be the MDI frame
        // does?
        mdi_frame->OnMenuHighlight(event);
    }
#endif // wxUSE_STATUSBAR
}

void wxMDIChildFrame::SetTitle( const wxString &title )
{
    if ( title == m_title )
        return;

    m_title = title;

    GtkNotebook * const notebook = GTKGetNotebook();
    wxCHECK_RET( notebook, "no parent notebook?" );

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

    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)

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

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