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

    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->HandleWindowEvent( 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 )
{
    if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
        return false;

    m_clientWindow = OnCreateClient();

    return m_clientWindow != NULL;
}

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

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()
{
    return new wxMDIClientWindow( this );
}

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(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"
//-----------------------------------------------------------------------------

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)

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, 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	wxMDIClientWindow *client_window = parent->GetClientWindow();
	75	if (!client_window)
	76	return;
	77
	78	child = (wxMDIChildFrame*) 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 = (wxMDIClientWindow *) NULL;
	117	}
	118
	119	wxMDIParentFrame::~wxMDIParentFrame()
	120	{
	121	}
	122
	123	bool wxMDIParentFrame::Create(wxWindow *parent,
	124	wxWindowID id,
	125	const wxString& title,
	126	const wxPoint& pos,
	127	const wxSize& size,
	128	long style,
	129	const wxString& name )
	130	{
	131	if ( !wxFrame::Create( parent, id, title, pos, size, style, name ) )
	132	return false;
	133
	134	m_clientWindow = OnCreateClient();
	135
	136	return m_clientWindow != NULL;
	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	if (active_child_frame != NULL)
	174	{
	175	wxMenuBar *menu_bar = active_child_frame->m_menuBar;
	176	if (menu_bar)
	177	{
	178	menu_bar->m_width = m_width;
	179	menu_bar->m_height = wxMENU_HEIGHT;
	180	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	181	menu_bar->m_widget,
	182	0, 0, m_width, wxMENU_HEIGHT );
	183	menu_bar->SetInvokingWindow(active_child_frame);
	184	}
	185	}
	186	m_justInserted = false;
	187	return;
	188	}
	189
	190	wxFrame::OnInternalIdle();
	191
	192	wxMDIChildFrame *active_child_frame = GetActiveChild();
	193	bool visible_child_menu = false;
	194
	195	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	196	while (node)
	197	{
	198	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	199
	200	if ( child_frame )
	201	{
	202	wxMenuBar *menu_bar = child_frame->m_menuBar;
	203	if ( menu_bar )
	204	{
	205	if (child_frame == active_child_frame)
	206	{
	207	if (menu_bar->Show(true))
	208	{
	209	menu_bar->m_width = m_width;
	210	menu_bar->m_height = wxMENU_HEIGHT;
	211	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	212	menu_bar->m_widget,
	213	0, 0, m_width, wxMENU_HEIGHT );
	214	menu_bar->SetInvokingWindow( child_frame );
	215	}
	216	visible_child_menu = true;
	217	}
	218	else
	219	{
	220	if (menu_bar->Show(false))
	221	{
	222	menu_bar->UnsetInvokingWindow( child_frame );
	223	}
	224	}
	225	}
	226	}
	227
	228	node = node->GetNext();
	229	}
	230
	231	/* show/hide parent menu bar as required */
	232	if ((m_frameMenuBar) &&
	233	(m_frameMenuBar->IsShown() == visible_child_menu))
	234	{
	235	if (visible_child_menu)
	236	{
	237	m_frameMenuBar->Show( false );
	238	m_frameMenuBar->UnsetInvokingWindow( this );
	239	}
	240	else
	241	{
	242	m_frameMenuBar->Show( true );
	243	m_frameMenuBar->SetInvokingWindow( this );
	244
	245	m_frameMenuBar->m_width = m_width;
	246	m_frameMenuBar->m_height = wxMENU_HEIGHT;
	247	gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
	248	m_frameMenuBar->m_widget,
	249	0, 0, m_width, wxMENU_HEIGHT );
	250	}
	251	}
	252	}
	253
	254	void wxMDIParentFrame::DoGetClientSize(int width, int height ) const
	255	{
	256	wxFrame::DoGetClientSize( width, height );
	257	}
	258
	259	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	260	{
	261	if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
	262
	263	GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
	264	if (!notebook) return (wxMDIChildFrame*) NULL;
	265
	266	gint i = gtk_notebook_get_current_page( notebook );
	267	if (i < 0) return (wxMDIChildFrame*) NULL;
	268
	269	GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
	270	if (!page) return (wxMDIChildFrame*) NULL;
	271
	272	wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
	273	while (node)
	274	{
	275	wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
	276
	277	wxASSERT_MSG( child_frame, _T("child is not a wxMDIChildFrame") );
	278
	279	if (child_frame->m_page == page)
	280	return child_frame;
	281	node = node->GetNext();
	282	}
	283
	284	return (wxMDIChildFrame*) NULL;
	285	}
	286
	287	wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
	288	{
	289	return m_clientWindow;
	290	}
	291
	292	wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
	293	{
	294	return new wxMDIClientWindow( this );
	295	}
	296
	297	void wxMDIParentFrame::ActivateNext()
	298	{
	299	if (m_clientWindow)
	300	gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	301	}
	302
	303	void wxMDIParentFrame::ActivatePrevious()
	304	{
	305	if (m_clientWindow)
	306	gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	307	}
	308
	309	//-----------------------------------------------------------------------------
	310	// wxMDIChildFrame
	311	//-----------------------------------------------------------------------------
	312
	313	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	314
	315	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	316	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	317	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	318	END_EVENT_TABLE()
	319
	320	wxMDIChildFrame::wxMDIChildFrame()
	321	{
	322	m_menuBar = (wxMenuBar *) NULL;
	323	m_page = (GtkNotebookPage *) NULL;
	324	}
	325
	326	wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
	327	wxWindowID id, const wxString& title,
	328	const wxPoint& WXUNUSED(pos), const wxSize& size,
	329	long style, const wxString& name )
	330	{
	331	m_menuBar = (wxMenuBar *) NULL;
	332	m_page = (GtkNotebookPage *) NULL;
	333	Create( parent, id, title, wxDefaultPosition, size, style, name );
	334	}
	335
	336	wxMDIChildFrame::~wxMDIChildFrame()
	337	{
	338	if (m_menuBar)
	339	delete m_menuBar;
	340	}
	341
	342	bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
	343	wxWindowID id, const wxString& title,
	344	const wxPoint& WXUNUSED(pos), const wxSize& size,
	345	long style, const wxString& name )
	346	{
	347	m_title = title;
	348
	349	return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
	350	}
	351
	352	void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	353	{
	354	wxWindow::DoSetSize( x, y, width, height, sizeFlags );
	355	}
	356
	357	void wxMDIChildFrame::DoSetClientSize(int width, int height)
	358	{
	359	wxWindow::DoSetClientSize( width, height );
	360	}
	361
	362	void wxMDIChildFrame::DoGetClientSize( int width, int height ) const
	363	{
	364	wxWindow::DoGetClientSize( width, height );
	365	}
	366
	367	void wxMDIChildFrame::AddChild( wxWindowBase *child )
	368	{
	369	wxWindow::AddChild(child);
	370	}
	371
	372	void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
	373	{
	374	wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );
	375
	376	m_menuBar = menu_bar;
	377
	378	if (m_menuBar)
	379	{
	380	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	381
	382	m_menuBar->SetParent( mdi_frame );
	383
	384	/* insert the invisible menu bar into the _parent_ mdi frame */
	385	gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
	386	m_menuBar->m_widget,
	387	0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
	388	}
	389	}
	390
	391	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	392	{
	393	return m_menuBar;
	394	}
	395
	396	void wxMDIChildFrame::Activate()
	397	{
	398	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	399	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	400	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	401	gtk_notebook_set_page( notebook, pageno );
	402	}
	403
	404	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	405	{
	406	}
	407
	408	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	409	{
	410	#if wxUSE_STATUSBAR
	411	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	412	if ( !ShowMenuHelp(event.GetMenuId()) )
	413	{
	414	// we don't have any help text for this item, but may be the MDI frame
	415	// does?
	416	mdi_frame->OnMenuHighlight(event);
	417	}
	418	#endif // wxUSE_STATUSBAR
	419	}
	420
	421	void wxMDIChildFrame::SetTitle( const wxString &title )
	422	{
	423	if ( title == m_title )
	424	return;
	425
	426	m_title = title;
	427
	428	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	429	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	430	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	431	}
	432
	433	//-----------------------------------------------------------------------------
	434	// "size_allocate"
	435	//-----------------------------------------------------------------------------
	436
	437	extern "C" {
	438	static void gtk_page_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxWindow *win )
	439	{
	440	if (g_isIdle) wxapp_install_idle_handler();
	441
	442	if ((win->m_x == alloc->x) &&
	443	(win->m_y == alloc->y) &&
	444	(win->m_width == alloc->width) &&
	445	(win->m_height == alloc->height) &&
	446	(win->m_sizeSet))
	447	{
	448	return;
	449	}
	450
	451	win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
	452	}
	453	}
	454
	455	//-----------------------------------------------------------------------------
	456	// InsertChild callback for wxMDIClientWindow
	457	//-----------------------------------------------------------------------------
	458
	459	static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* child )
	460	{
	461	wxString s = child->GetTitle();
	462	if (s.IsNull()) s = _("MDI child");
	463
	464	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	465	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	466
	467	gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
	468	GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
	469
	470	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	471
	472	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	473
	474	child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	475
	476	wxMDIParentFrame parent_frame = (wxMDIParentFrame) parent->GetParent();
	477	parent_frame->m_justInserted = true;
	478	}
	479
	480	//-----------------------------------------------------------------------------
	481	// wxMDIClientWindow
	482	//-----------------------------------------------------------------------------
	483
	484	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
	485
	486	wxMDIClientWindow::wxMDIClientWindow()
	487	{
	488	}
	489
	490	wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
	491	{
	492	CreateClient( parent, style );
	493	}
	494
	495	wxMDIClientWindow::~wxMDIClientWindow()
	496	{
	497
	498	}
	499
	500	bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
	501	{
	502	m_needParent = true;
	503
	504	m_insertCallback = (wxInsertChildFunction)wxInsertChildInMDI;
	505
	506	if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	507	!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
	508	{
	509	wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	510	return false;
	511	}
	512
	513	m_widget = gtk_notebook_new();
	514
	515	gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
	516	GTK_SIGNAL_FUNC(gtk_mdi_page_change_callback), (gpointer)parent );
	517
	518	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	519
	520	m_parent->DoAddChild( this );
	521
	522	PostCreation();
	523
	524	Show( true );
	525
	526	return true;
	527	}
	528
	529	#endif