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();
        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()
{
    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	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	m_clientWindow = new wxMDIClientWindow( this );
	295	return m_clientWindow;
	296	}
	297
	298	void wxMDIParentFrame::ActivateNext()
	299	{
	300	if (m_clientWindow)
	301	gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	302	}
	303
	304	void wxMDIParentFrame::ActivatePrevious()
	305	{
	306	if (m_clientWindow)
	307	gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
	308	}
	309
	310	//-----------------------------------------------------------------------------
	311	// wxMDIChildFrame
	312	//-----------------------------------------------------------------------------
	313
	314	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
	315
	316	BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
	317	EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
	318	EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
	319	END_EVENT_TABLE()
	320
	321	wxMDIChildFrame::wxMDIChildFrame()
	322	{
	323	m_menuBar = (wxMenuBar *) NULL;
	324	m_page = (GtkNotebookPage *) NULL;
	325	}
	326
	327	wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
	328	wxWindowID id, const wxString& title,
	329	const wxPoint& WXUNUSED(pos), const wxSize& size,
	330	long style, const wxString& name )
	331	{
	332	m_menuBar = (wxMenuBar *) NULL;
	333	m_page = (GtkNotebookPage *) NULL;
	334	Create( parent, id, title, wxDefaultPosition, size, style, name );
	335	}
	336
	337	wxMDIChildFrame::~wxMDIChildFrame()
	338	{
	339	if (m_menuBar)
	340	delete m_menuBar;
	341	}
	342
	343	bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
	344	wxWindowID id, const wxString& title,
	345	const wxPoint& WXUNUSED(pos), const wxSize& size,
	346	long style, const wxString& name )
	347	{
	348	m_title = title;
	349
	350	return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
	351	}
	352
	353	void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	354	{
	355	wxWindow::DoSetSize( x, y, width, height, sizeFlags );
	356	}
	357
	358	void wxMDIChildFrame::DoSetClientSize(int width, int height)
	359	{
	360	wxWindow::DoSetClientSize( width, height );
	361	}
	362
	363	void wxMDIChildFrame::DoGetClientSize( int width, int height ) const
	364	{
	365	wxWindow::DoGetClientSize( width, height );
	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	gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
	387	m_menuBar->m_widget,
	388	0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
	389	}
	390	}
	391
	392	wxMenuBar *wxMDIChildFrame::GetMenuBar() const
	393	{
	394	return m_menuBar;
	395	}
	396
	397	void wxMDIChildFrame::Activate()
	398	{
	399	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	400	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	401	gint pageno = gtk_notebook_page_num( notebook, m_widget );
	402	gtk_notebook_set_page( notebook, pageno );
	403	}
	404
	405	void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
	406	{
	407	}
	408
	409	void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
	410	{
	411	#if wxUSE_STATUSBAR
	412	wxMDIParentFrame mdi_frame = (wxMDIParentFrame)m_parent->GetParent();
	413	if ( !ShowMenuHelp(mdi_frame->GetStatusBar(), event.GetMenuId()) )
	414	{
	415	// we don't have any help text for this item, but may be the MDI frame
	416	// does?
	417	mdi_frame->OnMenuHighlight(event);
	418	}
	419	#endif // wxUSE_STATUSBAR
	420	}
	421
	422	void wxMDIChildFrame::SetTitle( const wxString &title )
	423	{
	424	if ( title == m_title )
	425	return;
	426
	427	m_title = title;
	428
	429	wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
	430	GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
	431	gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
	432	}
	433
	434	//-----------------------------------------------------------------------------
	435	// "size_allocate"
	436	//-----------------------------------------------------------------------------
	437
	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	// InsertChild callback for wxMDIClientWindow
	456	//-----------------------------------------------------------------------------
	457
	458	static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* child )
	459	{
	460	wxString s = child->m_title;
	461	if (s.IsNull()) s = _("MDI child");
	462
	463	GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
	464	gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
	465
	466	gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
	467	GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
	468
	469	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	470
	471	gtk_notebook_append_page( notebook, child->m_widget, label_widget );
	472
	473	child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	474
	475	wxMDIParentFrame parent_frame = (wxMDIParentFrame) parent->GetParent();
	476	parent_frame->m_justInserted = true;
	477	}
	478
	479	//-----------------------------------------------------------------------------
	480	// wxMDIClientWindow
	481	//-----------------------------------------------------------------------------
	482
	483	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
	484
	485	wxMDIClientWindow::wxMDIClientWindow()
	486	{
	487	}
	488
	489	wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
	490	{
	491	CreateClient( parent, style );
	492	}
	493
	494	wxMDIClientWindow::~wxMDIClientWindow()
	495	{
	496
	497	}
	498
	499	bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
	500	{
	501	m_needParent = true;
	502
	503	m_insertCallback = (wxInsertChildFunction)wxInsertChildInMDI;
	504
	505	if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) \|\|
	506	!CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
	507	{
	508	wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
	509	return false;
	510	}
	511
	512	m_widget = gtk_notebook_new();
	513
	514	gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
	515	GTK_SIGNAL_FUNC(gtk_mdi_page_change_callback), (gpointer)parent );
	516
	517	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	518
	519	m_parent->DoAddChild( this );
	520
	521	PostCreation();
	522
	523	Show( true );
	524
	525	return true;
	526	}
	527
	528	#endif