src/gtk/mdi.cpp

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

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

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

const int wxMENU_HEIGHT = 27;

//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// "switch_page"
//-----------------------------------------------------------------------------

extern "C" {
static void
gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
                              GtkNotebookPage *page,
                              gint WXUNUSED(page_num),
                              wxMDIParentFrame *parent )
{
    // 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 );

        // child_frame can be NULL when this is called from dtor, probably
        // because g_signal_connect (m_widget, "switch_page", (see below)
        // isn't deleted early enough
        if ( child_frame && 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()
{
    wxFrame::GtkOnSize();

    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;
    GTKDoGetSize(&menu_bar->m_width, NULL);
    menu_bar->m_height = wxMENU_HEIGHT;
    gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                          menu_bar->m_widget,
                          0, 0, menu_bar->m_width, menu_bar->m_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_current_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)
            {
                GTKDoGetSize(&menu_bar->m_width, NULL);
                menu_bar->m_height = wxMENU_HEIGHT;
                gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                    menu_bar->m_widget,
                                    0, 0, menu_bar->m_width, menu_bar->m_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))
                    {
                        GTKDoGetSize(&menu_bar->m_width, NULL);
                        menu_bar->m_height = wxMENU_HEIGHT;
                        gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                            menu_bar->m_widget,
                                            0, 0, menu_bar->m_width, menu_bar->m_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 );

            GTKDoGetSize(&m_frameMenuBar->m_width, NULL);
            m_frameMenuBar->m_height = wxMENU_HEIGHT;
            gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                m_frameMenuBar->m_widget,
                                0, 0, m_frameMenuBar->m_width, m_frameMenuBar->m_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)
    {
        if ( wxPendingDelete.Member(node->GetData()) )
            return (wxMDIChildFrame*) NULL;

        wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );

        if (!child_frame)
            return (wxMDIChildFrame*) NULL;

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

bool wxMDIParentFrame::HasVisibleMenubar() const
{
    if (wxFrame::HasVisibleMenubar())
        return true;

    wxMDIChildFrame* active_child_frame = GetActiveChild();
    wxMenuBar* menubar = NULL;
    if (active_child_frame)
        menubar = active_child_frame->m_menuBar;
    return menubar && menubar->IsShown();
}

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

bool wxMDIChildFrame::Destroy()
{
    // delayed destruction: the frame will be deleted during
    // the next idle loop iteration.
    // I'm not sure if delayed destruction really makes so
    // much sense for MDI child frames, actually, but hiding
    // it doesn't make any sense.
    if ( !wxPendingDelete.Member(this) )
        wxPendingDelete.Append(this);

    return true;
}

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

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 */
        int w;
        mdi_frame->GTKDoGetSize(&w, NULL);
        gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
                         m_menuBar->m_widget,
                         0, 0, w, 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_current_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, wxMDIChildFrame *win )
{
    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(wxWindow* parent, wxWindow* child)
{
    wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
    wxString s = child_frame->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 );

    g_signal_connect (child->m_widget, "size_allocate",
                      G_CALLBACK (gtk_page_size_callback), child);

    GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);

    gtk_notebook_append_page( notebook, child->m_widget, label_widget );

    child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);

    wxMDIParentFrame *parent_frame = wx_static_cast(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_insertCallback = 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();

    g_signal_connect (m_widget, "switch_page",
                      G_CALLBACK (gtk_mdi_page_change_callback), parent);

    gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );

    m_parent->DoAddChild( this );

    PostCreation();

    Show( true );

    return true;
}

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