src/gtk1/mdi.cpp

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

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "mdi.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/mdi.h"
#include "wx/notebook.h"

#if wxUSE_MDI

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

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

    /* need to set the menubar of the child */
        wxMDIChildFrame *active_child_frame = GetActiveChild();
        wxMenuBar *menu_bar = active_child_frame->m_menuBar;
        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 );
        }
    }
}

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;

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

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

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

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