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

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

    // send deactivate event to old child

    wxMDIChildFrame *child = parent->GetActiveChild();
    if (child)
    {
        wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
        event1.SetEventObject( child);
        child->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"
//-----------------------------------------------------------------------------

extern "C" {
static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
{
    if (g_isIdle) wxapp_install_idle_handler();

    if ((win->m_x == alloc->x) &&
        (win->m_y == alloc->y) &&
        (win->m_width == alloc->width) &&
        (win->m_height == alloc->height) &&
        (win->m_sizeSet))
    {
        return;
    }

    win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
}
}

//-----------------------------------------------------------------------------
// InsertChild callback for wxMDIClientWindow
//-----------------------------------------------------------------------------

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