src/gtk1/mdi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk1/mdi.cpp
// Purpose:
// Author:      Robert Roebling
// 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->Attach(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 );

                        // Attach() asserts if we call it for an already
                        // attached menu bar so don't do it if we're already
                        // associated with this frame (it would be nice to get
                        // rid of this check and ensure that this doesn't
                        // happen...)
                        if ( menu_bar->GetFrame() != child_frame )
                        menu_bar->Attach( child_frame );
                    }
                    visible_child_menu = true;
                }
                else
                {
                    if (menu_bar->Show(false))
                    {
                        menu_bar->Detach();
                    }
                }
            }
        }

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