src/gtk/mdi.cpp

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

#ifdef __GNUG__
#pragma implementation "mdi.h"
#endif

#include "wx/mdi.h"

#if wxUSE_MDI_ARCHITECTURE

#include "wx/dialog.h"
#include "wx/menu.h"
#include "wx/intl.h"
#include "wx/gtk/private.h"

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

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

const int wxMENU_HEIGHT = 27;

//-----------------------------------------------------------------------------
// idle system
//-----------------------------------------------------------------------------

extern void wxapp_install_idle_handler();
extern bool g_isIdle;

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

extern wxList wxPendingDelete;

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

static void
gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
                              GtkNotebookPage *page,
                              gint WXUNUSED(page_num),
                              wxMDIParentFrame *parent )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    // send deactivate event to old child

    wxMDIChildFrame *child = parent->GetActiveChild();
    if (child)
    {
        wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
        event1.SetEventObject( child);
        child->GetEventHandler()->ProcessEvent( event1 );
    }

    // send activate event to new child

    wxMDIClientWindow *client_window = parent->GetClientWindow();
    if (!client_window)
        return;

    child = (wxMDIChildFrame*) NULL;

    wxWindowList::Node  *node = client_window->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)
        {
            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 );

        m_justInserted = false;
        return;
    }

    wxFrame::OnInternalIdle();

    wxMDIChildFrame *active_child_frame = GetActiveChild();
    bool visible_child_menu = false;

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