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 "wx/gtk/private.h"

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

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

const int wxMENU_HEIGHT = 27;

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

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

wxMDIParentFrame::~wxMDIParentFrame()
{
}

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

    OnCreateClient();

    return TRUE;
}

void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
{
    wxFrame::GtkOnSize( x, y, width, height );

    wxMDIChildFrame *child_frame = GetActiveChild();
    if (!child_frame) return;

    wxMenuBar *menu_bar = child_frame->m_menuBar;
    if (!menu_bar) return;
    if (!menu_bar->m_widget) return;

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

void wxMDIParentFrame::OnInternalIdle()
{
    /* if a an MDI child window has just been inserted
       it has to be brought to the top in idle time. we
       simply set the last notebook page active as new
       pages can only be appended at the end */

    if (m_justInserted)
    {
        GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
        gtk_notebook_set_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)
    {
        wxObject *child = node->Data();
        wxMDIChildFrame *child_frame = wxDynamicCast(child, 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->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::DoGetClientSize(int *width, int *height ) const
{
    wxFrame::DoGetClientSize( width, height );
}

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

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

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

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

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

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

IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)

BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
    EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
    EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
END_EVENT_TABLE()

wxMDIChildFrame::wxMDIChildFrame()
{
    m_menuBar = (wxMenuBar *) NULL;
    m_page = (GtkNotebookPage *) NULL;
}

wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
      wxWindowID id, const wxString& title,
      const wxPoint& WXUNUSED(pos), const wxSize& size,
      long style, const wxString& name )
{
    m_menuBar = (wxMenuBar *) NULL;
    m_page = (GtkNotebookPage *) NULL;
    Create( parent, id, title, wxDefaultPosition, size, style, name );
}

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

bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
      wxWindowID id, const wxString& title,
      const wxPoint& WXUNUSED(pos), const wxSize& size,
      long style, const wxString& name )
{
    m_title = title;

    return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
}

void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{
    wxWindow::DoSetSize( x, y, width, height, sizeFlags );
}

void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
    wxWindow::DoSetClientSize( width, height );
}

void wxMDIChildFrame::DoGetClientSize( int *width, int *height ) const
{
    wxWindow::DoGetClientSize( width, height );
}

void wxMDIChildFrame::AddChild( wxWindowBase *child )
{
    wxWindow::AddChild(child);
}

void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
{
    wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );

    m_menuBar = menu_bar;

    if (m_menuBar)
    {
        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();

        m_menuBar->SetParent( mdi_frame );

        /* insert the invisible menu bar into the _parent_ mdi frame */
        gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
                         m_menuBar->m_widget,
                         0, 0,  mdi_frame->m_width, wxMENU_HEIGHT );
    }
}

wxMenuBar *wxMDIChildFrame::GetMenuBar() const
{
    return m_menuBar;
}

void wxMDIChildFrame::Activate()
{
    wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
    GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
    gint pageno = gtk_notebook_page_num( notebook, m_widget );
    gtk_notebook_set_page( notebook, pageno );
}

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

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

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

    m_title = title;

    wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
    GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
    gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
}

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

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