src/motif/mdi.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        mdi.cpp
// Purpose:     MDI classes
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __VMS
#define XtDisplay XTDISPLAY
#define XtWindow XTWINDOW
#endif

#include "wx/mdi.h"
#include "wx/menu.h"
#include "wx/settings.h"

#ifdef __VMS__
#pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#include <Xm/BulletinB.h>
#include <Xm/Form.h>
#include <Xm/MainW.h>
#include <Xm/RowColumn.h>
#include <Xm/CascadeBG.h>
#include <Xm/Text.h>
#include <Xm/PushBG.h>
#include <Xm/AtomMgr.h>
#include <Xm/Protocols.h>
#ifdef __VMS__
#pragma message enable nosimpint
#endif

#include "wx/motif/private.h"

extern wxList wxModelessWindows;

// Implemented in frame.cpp
extern void wxFrameFocusProc(Widget workArea, XtPointer clientData,
                             XmAnyCallbackStruct *cbs);

#define wxID_NOTEBOOK_CLIENT_AREA wxID_HIGHEST + 100

IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxNotebook)

BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
    EVT_SIZE(wxMDIParentFrame::OnSize)
    EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
    EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
    EVT_MENU_HIGHLIGHT_ALL(wxMDIParentFrame::OnMenuHighlight)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(wxMDIClientWindow, wxNotebook)
    EVT_SCROLL(wxMDIClientWindow::OnScroll)
    EVT_NOTEBOOK_PAGE_CHANGED(wxID_NOTEBOOK_CLIENT_AREA, wxMDIClientWindow::OnPageChanged)
END_EVENT_TABLE()


// Parent frame

wxMDIParentFrame::wxMDIParentFrame()
{
    m_clientWindow = (wxMDIClientWindow*) NULL;
    m_activeChild = (wxMDIChildFrame*) NULL;
    m_activeMenuBar = (wxMenuBar*) NULL;
}

bool wxMDIParentFrame::Create(wxWindow *parent,
                              wxWindowID id,
                              const wxString& title,
                              const wxPoint& pos,
                              const wxSize& size,
                              long style,
                              const wxString& name)
{
    m_clientWindow = (wxMDIClientWindow*) NULL;
    m_activeChild = (wxMDIChildFrame*) NULL;
    m_activeMenuBar = (wxMenuBar*) NULL;

    bool success = wxFrame::Create(parent, id, title, pos, size, style, name);
    if (success)
    {
        // TODO: app cannot override OnCreateClient since
        // wxMDIParentFrame::OnCreateClient will still be called
        // (we're in the constructor). How to resolve?

        m_clientWindow = OnCreateClient();

        // Uses own style for client style
        m_clientWindow->CreateClient(this, GetWindowStyleFlag());

        int w, h;
        GetClientSize(& w, & h);
        m_clientWindow->SetSize(0, 0, w, h);
        return TRUE;
    }
    else
        return FALSE;
}

wxMDIParentFrame::~wxMDIParentFrame()
{
    // Make sure we delete the client window last of all
    RemoveChild(m_clientWindow);

    DestroyChildren();

    delete m_clientWindow;
    m_clientWindow = NULL;
}

void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
{
    m_frameMenuBar = menu_bar;

    SetChildMenuBar((wxMDIChildFrame*) NULL);
}

void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))
{
#if wxUSE_CONSTRAINTS
    if (GetAutoLayout())
        Layout();
#endif
    int x = 0;
    int y = 0;
    int width, height;
    GetClientSize(&width, &height);

    if ( GetClientWindow() )
        GetClientWindow()->SetSize(x, y, width, height);
}

void wxMDIParentFrame::DoGetClientSize(int *width, int *height) const
{
    wxFrame::DoGetClientSize(width, height);
}

void wxMDIParentFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
{
    // Do nothing
}

// Returns the active MDI child window
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
    return m_activeChild;
}

// Create the client window class (don't Create the window,
// just return a new class)
wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
{
    return new wxMDIClientWindow ;
}

// Set the child's menu into the parent frame
void wxMDIParentFrame::SetChildMenuBar(wxMDIChildFrame* child)
{
    wxMenuBar* oldMenuBar = m_activeMenuBar;

    if (child == (wxMDIChildFrame*) NULL)  // No child: use parent frame
    {
        if (GetMenuBar() && (GetMenuBar() != m_activeMenuBar))
        {
            //            if (m_activeMenuBar)
            //                m_activeMenuBar->DestroyMenuBar();

            m_activeMenuBar = GetMenuBar();
            m_activeMenuBar->CreateMenuBar(this);
            /*
            if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
            XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
            */
            if (oldMenuBar && oldMenuBar->GetMainWidget())
                XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());

        }
    }
    else if (child->GetMenuBar() == (wxMenuBar*) NULL) // No child menu bar: use parent frame
    {
        if (GetMenuBar() && (GetMenuBar() != m_activeMenuBar))
        {
            //            if (m_activeMenuBar)
            //                m_activeMenuBar->DestroyMenuBar();
            m_activeMenuBar = GetMenuBar();
            m_activeMenuBar->CreateMenuBar(this);
            /*
            if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
            XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
            */
            if (oldMenuBar && oldMenuBar->GetMainWidget())
                XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());
        }
    }
    else // The child has a menubar
    {
        if (child->GetMenuBar() != m_activeMenuBar)
        {
            //            if (m_activeMenuBar)
            //                m_activeMenuBar->DestroyMenuBar();

            m_activeMenuBar = child->GetMenuBar();
            m_activeMenuBar->CreateMenuBar(this);
            /*
            if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
            XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
            */
            if (oldMenuBar && oldMenuBar->GetMainWidget())
                XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());
        }
    }
}

// Redirect events to active child first
bool wxMDIParentFrame::ProcessEvent(wxEvent& event)
{
    // Stops the same event being processed repeatedly
    static wxEventType inEvent = wxEVT_NULL;
    if (inEvent == event.GetEventType())
        return FALSE;

    inEvent = event.GetEventType();

    bool res = FALSE;
    if (m_activeChild && event.IsKindOf(CLASSINFO(wxCommandEvent)))
    {
        res = m_activeChild->GetEventHandler()->ProcessEvent(event);
    }

    if (!res)
        res = GetEventHandler()->wxEvtHandler::ProcessEvent(event);

    inEvent = wxEVT_NULL;

    return res;
}

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

void wxMDIParentFrame::DoSetClientSize(int width, int height)
{
    wxWindow::DoSetClientSize(width, height);
}

// Responds to colour changes, and passes event on to children.
void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
    // TODO

    // Propagate the event to the non-top-level children
    wxFrame::OnSysColourChanged(event);
}

// MDI operations
void wxMDIParentFrame::Cascade()
{
    // TODO
}

void wxMDIParentFrame::Tile()
{
    // TODO
}

void wxMDIParentFrame::ArrangeIcons()
{
    // TODO
}

void wxMDIParentFrame::ActivateNext()
{
    // TODO
}

void wxMDIParentFrame::ActivatePrevious()
{
    // TODO
}

// Default menu selection behaviour - display a help string
void wxMDIParentFrame::OnMenuHighlight(wxMenuEvent& event)
{
    if (GetStatusBar())
    {
        if (event.GetMenuId() == -1)
            SetStatusText("");
        else
        {
            wxMenuBar *menuBar = (wxMenuBar*) NULL;
            if (GetActiveChild())
              menuBar = GetActiveChild()->GetMenuBar();
            else
              menuBar = GetMenuBar();
            if (menuBar)
            {
                wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
                if (helpString != "")
                    SetStatusText(helpString);
            }
        }
    }
}

// Child frame

wxMDIChildFrame::wxMDIChildFrame()
{
    m_mdiParentFrame = (wxMDIParentFrame*) NULL;
}

bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
                             wxWindowID id,
                             const wxString& title,
                             const wxPoint& pos,
                             const wxSize& size,
                             long style,
                             const wxString& name)
{
    SetName(name);
    SetWindowStyleFlag(style);

    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
    m_foregroundColour = *wxBLACK;
    m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);

    if ( id > -1 )
        m_windowId = id;
    else
        m_windowId = (int)NewControlId();

    wxMDIClientWindow* clientWindow = parent->GetClientWindow();

    wxASSERT_MSG( (clientWindow != (wxWindow*) NULL), "Missing MDI client window.");

    if (clientWindow) clientWindow->AddChild(this);

    SetMDIParentFrame(parent);

    int width = size.x;
    int height = size.y;
    if (width == -1)
        width = 200; // TODO: give reasonable default
    if (height == -1)
        height = 200; // TODO: give reasonable default

    // We're deactivating the old child
    wxMDIChildFrame* oldActiveChild = parent->GetActiveChild();
    if (oldActiveChild)
    {
        wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
        event.SetEventObject( oldActiveChild );
        oldActiveChild->GetEventHandler()->ProcessEvent(event);
    }

    // This is the currently active child
    parent->SetActiveChild((wxMDIChildFrame*) this);

    // This time we'll try a bog-standard bulletin board for
    // the 'frame'. A main window doesn't seem to work.

    m_mainWidget = (WXWidget) XtVaCreateWidget("client",
        xmBulletinBoardWidgetClass, (Widget) clientWindow->GetTopWidget(),
        XmNmarginWidth, 0,
        XmNmarginHeight, 0,
        /*
        XmNrightAttachment, XmATTACH_FORM,
        XmNleftAttachment, XmATTACH_FORM,
        XmNtopAttachment, XmATTACH_FORM,
        XmNbottomAttachment, XmATTACH_FORM,
        */
        XmNresizePolicy, XmRESIZE_NONE,
        NULL);

    XtAddEventHandler((Widget) m_mainWidget, ExposureMask,FALSE,
        wxUniversalRepaintProc, (XtPointer) this);

    SetCanAddEventHandler(TRUE);
    AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);

    ChangeBackgroundColour();

    XtManageChild((Widget) m_mainWidget);

    SetTitle(title);

    clientWindow->AddPage(this, title, TRUE);
    clientWindow->Refresh();

    // Positions the toolbar and status bar -- but we don't have any.
    //    PreResize();

    wxModelessWindows.Append(this);
    return TRUE;
}


wxMDIChildFrame::~wxMDIChildFrame()
{
    if (m_mainWidget)
      XtRemoveEventHandler((Widget) m_mainWidget, ExposureMask,FALSE,
        wxUniversalRepaintProc, (XtPointer) this);

    if (GetMDIParentFrame())
    {
        wxMDIParentFrame* parentFrame = GetMDIParentFrame();

        if (parentFrame->GetActiveChild() == this)
            parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
        wxMDIClientWindow* clientWindow = parentFrame->GetClientWindow();

        // Remove page if still there
        if (clientWindow->RemovePage(this))
            clientWindow->Refresh();

        // Set the selection to the first remaining page
        if (clientWindow->GetPageCount() > 0)
        {
            wxMDIChildFrame* child = (wxMDIChildFrame*)  clientWindow->GetPage(0);
            parentFrame->SetActiveChild(child);
            parentFrame->SetChildMenuBar(child);
        }
        else
        {
            parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
            parentFrame->SetChildMenuBar((wxMDIChildFrame*) NULL);
        }
    }
}

#if 0
// Implementation: intercept and act upon raise and lower commands.
void wxMDIChildFrame::OnRaise()
{
    wxMDIParentFrame* parentFrame = (wxMDIParentFrame*) GetParent() ;
    wxMDIChildFrame* oldActiveChild = parentFrame->GetActiveChild();
    parentFrame->SetActiveChild(this);

    if (oldActiveChild)
    {
        wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
        event.SetEventObject( oldActiveChild );
        oldActiveChild->GetEventHandler()->ProcessEvent(event);
    }

    wxActivateEvent event(wxEVT_ACTIVATE, TRUE, this->GetId());
    event.SetEventObject( this );
    this->GetEventHandler()->ProcessEvent(event);
}

void wxMDIChildFrame::OnLower()
{
    wxMDIParentFrame* parentFrame = (wxMDIParentFrame*) GetParent() ;
    wxMDIChildFrame* oldActiveChild = parentFrame->GetActiveChild();

    if (oldActiveChild == this)
    {
        wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
        event.SetEventObject( oldActiveChild );
        oldActiveChild->GetEventHandler()->ProcessEvent(event);
    }
    // TODO: unfortunately we don't now know which is the top-most child,
    // so make the active child NULL.
    parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
}
#endif

// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
    wxWindow::DoSetClientSize(width, height);
}

void wxMDIChildFrame::DoGetClientSize(int* width, int* height) const
{
    wxWindow::DoGetSize(width, height);
}

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

void wxMDIChildFrame::DoGetSize(int* width, int* height) const
{
    wxWindow::DoGetSize(width, height);
}

void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
{
    wxWindow::DoGetPosition(x, y);
}

bool wxMDIChildFrame::Show(bool show)
{
    m_visibleStatus = show; /* show-&-hide fix */
    return wxWindow::Show(show);
}

void wxMDIChildFrame::SetMenuBar(wxMenuBar *menuBar)
{
    // Don't create the underlying menubar yet; need to recreate
    // it every time the child is activated.
    m_frameMenuBar = menuBar;

    // We make the assumption that if you're setting the menubar,
    // this is the currently active child.
    GetMDIParentFrame()->SetChildMenuBar(this);
}

// Set icon
void wxMDIChildFrame::SetIcon(const wxIcon& icon)
{
    m_icons = wxIconBundle( icon );

    if (icon.Ok())
    {
        // Not appropriate since there are no icons in
        // a tabbed window
    }
}

void wxMDIChildFrame::SetIcons(const wxIconBundle& icons)
{
    m_icons = icons;
}

void wxMDIChildFrame::SetTitle(const wxString& title)
{
    m_title = title;
    wxMDIClientWindow* clientWindow = GetMDIParentFrame()->GetClientWindow();
    int pageNo = clientWindow->FindPagePosition(this);
    if (pageNo > -1)
        clientWindow->SetPageText(pageNo, title);
}

// MDI operations
void wxMDIChildFrame::Maximize()
{
    // TODO
}

void wxMDIChildFrame::Iconize(bool WXUNUSED(iconize))
{
    // TODO
}

bool wxMDIChildFrame::IsIconized() const
{
    return FALSE;
}

// Is it maximized? Always maximized under Motif, using the
// tabbed MDI implementation.
bool wxMDIChildFrame::IsMaximized(void) const
{
    return TRUE;
}

void wxMDIChildFrame::Restore()
{
    // TODO
}

void wxMDIChildFrame::Activate()
{
    // TODO
}

void wxMDIChildFrame::CaptureMouse()
{
    wxWindow::CaptureMouse();
}

void wxMDIChildFrame::ReleaseMouse()
{
    wxWindow::ReleaseMouse();
}

void wxMDIChildFrame::Raise()
{
    wxWindow::Raise();
}

void wxMDIChildFrame::Lower(void)
{
    wxWindow::Raise();
}

void wxMDIChildFrame::SetSizeHints(int WXUNUSED(minW), int WXUNUSED(minH), int WXUNUSED(maxW), int WXUNUSED(maxH), int WXUNUSED(incW), int WXUNUSED(incH))
{
}

// Client window

wxMDIClientWindow::wxMDIClientWindow()
{
}

wxMDIClientWindow::~wxMDIClientWindow()
{
    // By the time this destructor is called, the child frames will have been
    // deleted and removed from the notebook/client window.
    DestroyChildren();

    m_mainWidget = (WXWidget) 0;
}

bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
    SetWindowStyleFlag(style);

    //    m_windowParent = parent;
    //    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);

    bool success = wxNotebook::Create(parent, wxID_NOTEBOOK_CLIENT_AREA, wxPoint(0, 0), wxSize(100, 100), 0);
    if (success)
    {
        wxFont font(10, wxSWISS, wxNORMAL, wxNORMAL);
        wxFont selFont(10, wxSWISS, wxNORMAL, wxBOLD);
        GetTabView()->SetTabFont(font);
        GetTabView()->SetSelectedTabFont(selFont);
        GetTabView()->SetTabSize(120, 18);
        GetTabView()->SetTabSelectionHeight(20);
        return TRUE;
    }
    else
        return FALSE;
}

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

void wxMDIClientWindow::DoSetClientSize(int width, int height)
{
    wxWindow::DoSetClientSize(width, height);
}

void wxMDIClientWindow::DoGetClientSize(int *width, int *height) const
{
    wxWindow::DoGetClientSize(width, height);
}

void wxMDIClientWindow::DoGetSize(int *width, int *height) const
{
    wxWindow::DoGetSize(width, height);
}

void wxMDIClientWindow::DoGetPosition(int *x, int *y) const
{
    wxWindow::DoGetPosition(x, y);
}

void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
{
    //    Default(); // Default processing: OBSOLETE FUNCTION
    event.Skip();
}

void wxMDIClientWindow::OnPageChanged(wxNotebookEvent& event)
{
    // Notify child that it has been activated
    if (event.GetOldSelection() != -1)
    {
        wxMDIChildFrame* oldChild = (wxMDIChildFrame*) GetPage(event.GetOldSelection());
        if (oldChild)
        {
            wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldChild->GetId());
            event.SetEventObject( oldChild );
            oldChild->GetEventHandler()->ProcessEvent(event);
        }
    }
    if (event.GetSelection() != -1)
    {
        wxMDIChildFrame* activeChild = (wxMDIChildFrame*) GetPage(event.GetSelection());
        if (activeChild)
        {
            wxActivateEvent event(wxEVT_ACTIVATE, TRUE, activeChild->GetId());
            event.SetEventObject( activeChild );
            activeChild->GetEventHandler()->ProcessEvent(event);

            if (activeChild->GetMDIParentFrame())
            {
                activeChild->GetMDIParentFrame()->SetActiveChild(activeChild);
                activeChild->GetMDIParentFrame()->SetChildMenuBar(activeChild);
            }
        }
    }
    event.Skip();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: mdi.cpp
	3	// Purpose: MDI classes
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "mdi.h"
	14	#endif
	15
	16	#ifdef __VMS
	17	#define XtDisplay XTDISPLAY
	18	#define XtWindow XTWINDOW
	19	#endif
	20
	21	#include "wx/mdi.h"
	22	#include "wx/menu.h"
	23	#include "wx/settings.h"
	24
	25	#ifdef __VMS__
	26	#pragma message disable nosimpint
	27	#endif
	28	#include <Xm/Xm.h>
	29	#include <Xm/BulletinB.h>
	30	#include <Xm/Form.h>
	31	#include <Xm/MainW.h>
	32	#include <Xm/RowColumn.h>
	33	#include <Xm/CascadeBG.h>
	34	#include <Xm/Text.h>
	35	#include <Xm/PushBG.h>
	36	#include <Xm/AtomMgr.h>
	37	#include <Xm/Protocols.h>
	38	#ifdef __VMS__
	39	#pragma message enable nosimpint
	40	#endif
	41
	42	#include "wx/motif/private.h"
	43
	44	extern wxList wxModelessWindows;
	45
	46	// Implemented in frame.cpp
	47	extern void wxFrameFocusProc(Widget workArea, XtPointer clientData,
	48	XmAnyCallbackStruct *cbs);
	49
	50	#define wxID_NOTEBOOK_CLIENT_AREA wxID_HIGHEST + 100
	51
	52	IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
	53	IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
	54	IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxNotebook)
	55
	56	BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
	57	EVT_SIZE(wxMDIParentFrame::OnSize)
	58	EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
	59	EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
	60	EVT_MENU_HIGHLIGHT_ALL(wxMDIParentFrame::OnMenuHighlight)
	61	END_EVENT_TABLE()
	62
	63	BEGIN_EVENT_TABLE(wxMDIClientWindow, wxNotebook)
	64	EVT_SCROLL(wxMDIClientWindow::OnScroll)
	65	EVT_NOTEBOOK_PAGE_CHANGED(wxID_NOTEBOOK_CLIENT_AREA, wxMDIClientWindow::OnPageChanged)
	66	END_EVENT_TABLE()
	67
	68
	69	// Parent frame
	70
	71	wxMDIParentFrame::wxMDIParentFrame()
	72	{
	73	m_clientWindow = (wxMDIClientWindow*) NULL;
	74	m_activeChild = (wxMDIChildFrame*) NULL;
	75	m_activeMenuBar = (wxMenuBar*) NULL;
	76	}
	77
	78	bool wxMDIParentFrame::Create(wxWindow *parent,
	79	wxWindowID id,
	80	const wxString& title,
	81	const wxPoint& pos,
	82	const wxSize& size,
	83	long style,
	84	const wxString& name)
	85	{
	86	m_clientWindow = (wxMDIClientWindow*) NULL;
	87	m_activeChild = (wxMDIChildFrame*) NULL;
	88	m_activeMenuBar = (wxMenuBar*) NULL;
	89
	90	bool success = wxFrame::Create(parent, id, title, pos, size, style, name);
	91	if (success)
	92	{
	93	// TODO: app cannot override OnCreateClient since
	94	// wxMDIParentFrame::OnCreateClient will still be called
	95	// (we're in the constructor). How to resolve?
	96
	97	m_clientWindow = OnCreateClient();
	98
	99	// Uses own style for client style
	100	m_clientWindow->CreateClient(this, GetWindowStyleFlag());
	101
	102	int w, h;
	103	GetClientSize(& w, & h);
	104	m_clientWindow->SetSize(0, 0, w, h);
	105	return TRUE;
	106	}
	107	else
	108	return FALSE;
	109	}
	110
	111	wxMDIParentFrame::~wxMDIParentFrame()
	112	{
	113	// Make sure we delete the client window last of all
	114	RemoveChild(m_clientWindow);
	115
	116	DestroyChildren();
	117
	118	delete m_clientWindow;
	119	m_clientWindow = NULL;
	120	}
	121
	122	void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
	123	{
	124	m_frameMenuBar = menu_bar;
	125
	126	SetChildMenuBar((wxMDIChildFrame*) NULL);
	127	}
	128
	129	void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))
	130	{
	131	#if wxUSE_CONSTRAINTS
	132	if (GetAutoLayout())
	133	Layout();
	134	#endif
	135	int x = 0;
	136	int y = 0;
	137	int width, height;
	138	GetClientSize(&width, &height);
	139
	140	if ( GetClientWindow() )
	141	GetClientWindow()->SetSize(x, y, width, height);
	142	}
	143
	144	void wxMDIParentFrame::DoGetClientSize(int width, int height) const
	145	{
	146	wxFrame::DoGetClientSize(width, height);
	147	}
	148
	149	void wxMDIParentFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
	150	{
	151	// Do nothing
	152	}
	153
	154	// Returns the active MDI child window
	155	wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
	156	{
	157	return m_activeChild;
	158	}
	159
	160	// Create the client window class (don't Create the window,
	161	// just return a new class)
	162	wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
	163	{
	164	return new wxMDIClientWindow ;
	165	}
	166
	167	// Set the child's menu into the parent frame
	168	void wxMDIParentFrame::SetChildMenuBar(wxMDIChildFrame* child)
	169	{
	170	wxMenuBar* oldMenuBar = m_activeMenuBar;
	171
	172	if (child == (wxMDIChildFrame*) NULL) // No child: use parent frame
	173	{
	174	if (GetMenuBar() && (GetMenuBar() != m_activeMenuBar))
	175	{
	176	// if (m_activeMenuBar)
	177	// m_activeMenuBar->DestroyMenuBar();
	178
	179	m_activeMenuBar = GetMenuBar();
	180	m_activeMenuBar->CreateMenuBar(this);
	181	/*
	182	if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
	183	XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
	184	*/
	185	if (oldMenuBar && oldMenuBar->GetMainWidget())
	186	XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());
	187
	188	}
	189	}
	190	else if (child->GetMenuBar() == (wxMenuBar*) NULL) // No child menu bar: use parent frame
	191	{
	192	if (GetMenuBar() && (GetMenuBar() != m_activeMenuBar))
	193	{
	194	// if (m_activeMenuBar)
	195	// m_activeMenuBar->DestroyMenuBar();
	196	m_activeMenuBar = GetMenuBar();
	197	m_activeMenuBar->CreateMenuBar(this);
	198	/*
	199	if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
	200	XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
	201	*/
	202	if (oldMenuBar && oldMenuBar->GetMainWidget())
	203	XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());
	204	}
	205	}
	206	else // The child has a menubar
	207	{
	208	if (child->GetMenuBar() != m_activeMenuBar)
	209	{
	210	// if (m_activeMenuBar)
	211	// m_activeMenuBar->DestroyMenuBar();
	212
	213	m_activeMenuBar = child->GetMenuBar();
	214	m_activeMenuBar->CreateMenuBar(this);
	215	/*
	216	if (oldMenuBar && XtIsManaged((Widget) oldMenuBar->GetMainWidget()))
	217	XtUnmanageChild((Widget) oldMenuBar->GetMainWidget());
	218	*/
	219	if (oldMenuBar && oldMenuBar->GetMainWidget())
	220	XtUnmapWidget((Widget) oldMenuBar->GetMainWidget());
	221	}
	222	}
	223	}
	224
	225	// Redirect events to active child first
	226	bool wxMDIParentFrame::ProcessEvent(wxEvent& event)
	227	{
	228	// Stops the same event being processed repeatedly
	229	static wxEventType inEvent = wxEVT_NULL;
	230	if (inEvent == event.GetEventType())
	231	return FALSE;
	232
	233	inEvent = event.GetEventType();
	234
	235	bool res = FALSE;
	236	if (m_activeChild && event.IsKindOf(CLASSINFO(wxCommandEvent)))
	237	{
	238	res = m_activeChild->GetEventHandler()->ProcessEvent(event);
	239	}
	240
	241	if (!res)
	242	res = GetEventHandler()->wxEvtHandler::ProcessEvent(event);
	243
	244	inEvent = wxEVT_NULL;
	245
	246	return res;
	247	}
	248
	249	void wxMDIParentFrame::DoSetSize(int x, int y,
	250	int width, int height,
	251	int sizeFlags)
	252	{
	253	wxWindow::DoSetSize(x, y, width, height, sizeFlags);
	254	}
	255
	256	void wxMDIParentFrame::DoSetClientSize(int width, int height)
	257	{
	258	wxWindow::DoSetClientSize(width, height);
	259	}
	260
	261	// Responds to colour changes, and passes event on to children.
	262	void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
	263	{
	264	// TODO
	265
	266	// Propagate the event to the non-top-level children
	267	wxFrame::OnSysColourChanged(event);
	268	}
	269
	270	// MDI operations
	271	void wxMDIParentFrame::Cascade()
	272	{
	273	// TODO
	274	}
	275
	276	void wxMDIParentFrame::Tile()
	277	{
	278	// TODO
	279	}
	280
	281	void wxMDIParentFrame::ArrangeIcons()
	282	{
	283	// TODO
	284	}
	285
	286	void wxMDIParentFrame::ActivateNext()
	287	{
	288	// TODO
	289	}
	290
	291	void wxMDIParentFrame::ActivatePrevious()
	292	{
	293	// TODO
	294	}
	295
	296	// Default menu selection behaviour - display a help string
	297	void wxMDIParentFrame::OnMenuHighlight(wxMenuEvent& event)
	298	{
	299	if (GetStatusBar())
	300	{
	301	if (event.GetMenuId() == -1)
	302	SetStatusText("");
	303	else
	304	{
	305	wxMenuBar menuBar = (wxMenuBar) NULL;
	306	if (GetActiveChild())
	307	menuBar = GetActiveChild()->GetMenuBar();
	308	else
	309	menuBar = GetMenuBar();
	310	if (menuBar)
	311	{
	312	wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
	313	if (helpString != "")
	314	SetStatusText(helpString);
	315	}
	316	}
	317	}
	318	}
	319
	320	// Child frame
	321
	322	wxMDIChildFrame::wxMDIChildFrame()
	323	{
	324	m_mdiParentFrame = (wxMDIParentFrame*) NULL;
	325	}
	326
	327	bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
	328	wxWindowID id,
	329	const wxString& title,
	330	const wxPoint& pos,
	331	const wxSize& size,
	332	long style,
	333	const wxString& name)
	334	{
	335	SetName(name);
	336	SetWindowStyleFlag(style);
	337
	338	m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
	339	m_foregroundColour = *wxBLACK;
	340	m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
	341
	342	if ( id > -1 )
	343	m_windowId = id;
	344	else
	345	m_windowId = (int)NewControlId();
	346
	347	wxMDIClientWindow* clientWindow = parent->GetClientWindow();
	348
	349	wxASSERT_MSG( (clientWindow != (wxWindow*) NULL), "Missing MDI client window.");
	350
	351	if (clientWindow) clientWindow->AddChild(this);
	352
	353	SetMDIParentFrame(parent);
	354
	355	int width = size.x;
	356	int height = size.y;
	357	if (width == -1)
	358	width = 200; // TODO: give reasonable default
	359	if (height == -1)
	360	height = 200; // TODO: give reasonable default
	361
	362	// We're deactivating the old child
	363	wxMDIChildFrame* oldActiveChild = parent->GetActiveChild();
	364	if (oldActiveChild)
	365	{
	366	wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
	367	event.SetEventObject( oldActiveChild );
	368	oldActiveChild->GetEventHandler()->ProcessEvent(event);
	369	}
	370
	371	// This is the currently active child
	372	parent->SetActiveChild((wxMDIChildFrame*) this);
	373
	374	// This time we'll try a bog-standard bulletin board for
	375	// the 'frame'. A main window doesn't seem to work.
	376
	377	m_mainWidget = (WXWidget) XtVaCreateWidget("client",
	378	xmBulletinBoardWidgetClass, (Widget) clientWindow->GetTopWidget(),
	379	XmNmarginWidth, 0,
	380	XmNmarginHeight, 0,
	381	/*
	382	XmNrightAttachment, XmATTACH_FORM,
	383	XmNleftAttachment, XmATTACH_FORM,
	384	XmNtopAttachment, XmATTACH_FORM,
	385	XmNbottomAttachment, XmATTACH_FORM,
	386	*/
	387	XmNresizePolicy, XmRESIZE_NONE,
	388	NULL);
	389
	390	XtAddEventHandler((Widget) m_mainWidget, ExposureMask,FALSE,
	391	wxUniversalRepaintProc, (XtPointer) this);
	392
	393	SetCanAddEventHandler(TRUE);
	394	AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
	395
	396	ChangeBackgroundColour();
	397
	398	XtManageChild((Widget) m_mainWidget);
	399
	400	SetTitle(title);
	401
	402	clientWindow->AddPage(this, title, TRUE);
	403	clientWindow->Refresh();
	404
	405	// Positions the toolbar and status bar -- but we don't have any.
	406	// PreResize();
	407
	408	wxModelessWindows.Append(this);
	409	return TRUE;
	410	}
	411
	412
	413	wxMDIChildFrame::~wxMDIChildFrame()
	414	{
	415	if (m_mainWidget)
	416	XtRemoveEventHandler((Widget) m_mainWidget, ExposureMask,FALSE,
	417	wxUniversalRepaintProc, (XtPointer) this);
	418
	419	if (GetMDIParentFrame())
	420	{
	421	wxMDIParentFrame* parentFrame = GetMDIParentFrame();
	422
	423	if (parentFrame->GetActiveChild() == this)
	424	parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
	425	wxMDIClientWindow* clientWindow = parentFrame->GetClientWindow();
	426
	427	// Remove page if still there
	428	if (clientWindow->RemovePage(this))
	429	clientWindow->Refresh();
	430
	431	// Set the selection to the first remaining page
	432	if (clientWindow->GetPageCount() > 0)
	433	{
	434	wxMDIChildFrame* child = (wxMDIChildFrame*) clientWindow->GetPage(0);
	435	parentFrame->SetActiveChild(child);
	436	parentFrame->SetChildMenuBar(child);
	437	}
	438	else
	439	{
	440	parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
	441	parentFrame->SetChildMenuBar((wxMDIChildFrame*) NULL);
	442	}
	443	}
	444	}
	445
	446	#if 0
	447	// Implementation: intercept and act upon raise and lower commands.
	448	void wxMDIChildFrame::OnRaise()
	449	{
	450	wxMDIParentFrame* parentFrame = (wxMDIParentFrame*) GetParent() ;
	451	wxMDIChildFrame* oldActiveChild = parentFrame->GetActiveChild();
	452	parentFrame->SetActiveChild(this);
	453
	454	if (oldActiveChild)
	455	{
	456	wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
	457	event.SetEventObject( oldActiveChild );
	458	oldActiveChild->GetEventHandler()->ProcessEvent(event);
	459	}
	460
	461	wxActivateEvent event(wxEVT_ACTIVATE, TRUE, this->GetId());
	462	event.SetEventObject( this );
	463	this->GetEventHandler()->ProcessEvent(event);
	464	}
	465
	466	void wxMDIChildFrame::OnLower()
	467	{
	468	wxMDIParentFrame* parentFrame = (wxMDIParentFrame*) GetParent() ;
	469	wxMDIChildFrame* oldActiveChild = parentFrame->GetActiveChild();
	470
	471	if (oldActiveChild == this)
	472	{
	473	wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldActiveChild->GetId());
	474	event.SetEventObject( oldActiveChild );
	475	oldActiveChild->GetEventHandler()->ProcessEvent(event);
	476	}
	477	// TODO: unfortunately we don't now know which is the top-most child,
	478	// so make the active child NULL.
	479	parentFrame->SetActiveChild((wxMDIChildFrame*) NULL);
	480	}
	481	#endif
	482
	483	// Set the client size (i.e. leave the calculation of borders etc.
	484	// to wxWindows)
	485	void wxMDIChildFrame::DoSetClientSize(int width, int height)
	486	{
	487	wxWindow::DoSetClientSize(width, height);
	488	}
	489
	490	void wxMDIChildFrame::DoGetClientSize(int* width, int* height) const
	491	{
	492	wxWindow::DoGetSize(width, height);
	493	}
	494
	495	void wxMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
	496	{
	497	wxWindow::DoSetSize(x, y, width, height, sizeFlags);
	498	}
	499
	500	void wxMDIChildFrame::DoGetSize(int* width, int* height) const
	501	{
	502	wxWindow::DoGetSize(width, height);
	503	}
	504
	505	void wxMDIChildFrame::DoGetPosition(int x, int y) const
	506	{
	507	wxWindow::DoGetPosition(x, y);
	508	}
	509
	510	bool wxMDIChildFrame::Show(bool show)
	511	{
	512	m_visibleStatus = show; /* show-&-hide fix */
	513	return wxWindow::Show(show);
	514	}
	515
	516	void wxMDIChildFrame::SetMenuBar(wxMenuBar *menuBar)
	517	{
	518	// Don't create the underlying menubar yet; need to recreate
	519	// it every time the child is activated.
	520	m_frameMenuBar = menuBar;
	521
	522	// We make the assumption that if you're setting the menubar,
	523	// this is the currently active child.
	524	GetMDIParentFrame()->SetChildMenuBar(this);
	525	}
	526
	527	// Set icon
	528	void wxMDIChildFrame::SetIcon(const wxIcon& icon)
	529	{
	530	m_icons = wxIconBundle( icon );
	531
	532	if (icon.Ok())
	533	{
	534	// Not appropriate since there are no icons in
	535	// a tabbed window
	536	}
	537	}
	538
	539	void wxMDIChildFrame::SetIcons(const wxIconBundle& icons)
	540	{
	541	m_icons = icons;
	542	}
	543
	544	void wxMDIChildFrame::SetTitle(const wxString& title)
	545	{
	546	m_title = title;
	547	wxMDIClientWindow* clientWindow = GetMDIParentFrame()->GetClientWindow();
	548	int pageNo = clientWindow->FindPagePosition(this);
	549	if (pageNo > -1)
	550	clientWindow->SetPageText(pageNo, title);
	551	}
	552
	553	// MDI operations
	554	void wxMDIChildFrame::Maximize()
	555	{
	556	// TODO
	557	}
	558
	559	void wxMDIChildFrame::Iconize(bool WXUNUSED(iconize))
	560	{
	561	// TODO
	562	}
	563
	564	bool wxMDIChildFrame::IsIconized() const
	565	{
	566	return FALSE;
	567	}
	568
	569	// Is it maximized? Always maximized under Motif, using the
	570	// tabbed MDI implementation.
	571	bool wxMDIChildFrame::IsMaximized(void) const
	572	{
	573	return TRUE;
	574	}
	575
	576	void wxMDIChildFrame::Restore()
	577	{
	578	// TODO
	579	}
	580
	581	void wxMDIChildFrame::Activate()
	582	{
	583	// TODO
	584	}
	585
	586	void wxMDIChildFrame::CaptureMouse()
	587	{
	588	wxWindow::CaptureMouse();
	589	}
	590
	591	void wxMDIChildFrame::ReleaseMouse()
	592	{
	593	wxWindow::ReleaseMouse();
	594	}
	595
	596	void wxMDIChildFrame::Raise()
	597	{
	598	wxWindow::Raise();
	599	}
	600
	601	void wxMDIChildFrame::Lower(void)
	602	{
	603	wxWindow::Raise();
	604	}
	605
	606	void wxMDIChildFrame::SetSizeHints(int WXUNUSED(minW), int WXUNUSED(minH), int WXUNUSED(maxW), int WXUNUSED(maxH), int WXUNUSED(incW), int WXUNUSED(incH))
	607	{
	608	}
	609
	610	// Client window
	611
	612	wxMDIClientWindow::wxMDIClientWindow()
	613	{
	614	}
	615
	616	wxMDIClientWindow::~wxMDIClientWindow()
	617	{
	618	// By the time this destructor is called, the child frames will have been
	619	// deleted and removed from the notebook/client window.
	620	DestroyChildren();
	621
	622	m_mainWidget = (WXWidget) 0;
	623	}
	624
	625	bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
	626	{
	627	SetWindowStyleFlag(style);
	628
	629	// m_windowParent = parent;
	630	// m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
	631
	632	bool success = wxNotebook::Create(parent, wxID_NOTEBOOK_CLIENT_AREA, wxPoint(0, 0), wxSize(100, 100), 0);
	633	if (success)
	634	{
	635	wxFont font(10, wxSWISS, wxNORMAL, wxNORMAL);
	636	wxFont selFont(10, wxSWISS, wxNORMAL, wxBOLD);
	637	GetTabView()->SetTabFont(font);
	638	GetTabView()->SetSelectedTabFont(selFont);
	639	GetTabView()->SetTabSize(120, 18);
	640	GetTabView()->SetTabSelectionHeight(20);
	641	return TRUE;
	642	}
	643	else
	644	return FALSE;
	645	}
	646
	647	void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
	648	{
	649	wxWindow::DoSetSize(x, y, width, height, sizeFlags);
	650	}
	651
	652	void wxMDIClientWindow::DoSetClientSize(int width, int height)
	653	{
	654	wxWindow::DoSetClientSize(width, height);
	655	}
	656
	657	void wxMDIClientWindow::DoGetClientSize(int width, int height) const
	658	{
	659	wxWindow::DoGetClientSize(width, height);
	660	}
	661
	662	void wxMDIClientWindow::DoGetSize(int width, int height) const
	663	{
	664	wxWindow::DoGetSize(width, height);
	665	}
	666
	667	void wxMDIClientWindow::DoGetPosition(int x, int y) const
	668	{
	669	wxWindow::DoGetPosition(x, y);
	670	}
	671
	672	void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
	673	{
	674	// Default(); // Default processing: OBSOLETE FUNCTION
	675	event.Skip();
	676	}
	677
	678	void wxMDIClientWindow::OnPageChanged(wxNotebookEvent& event)
	679	{
	680	// Notify child that it has been activated
	681	if (event.GetOldSelection() != -1)
	682	{
	683	wxMDIChildFrame* oldChild = (wxMDIChildFrame*) GetPage(event.GetOldSelection());
	684	if (oldChild)
	685	{
	686	wxActivateEvent event(wxEVT_ACTIVATE, FALSE, oldChild->GetId());
	687	event.SetEventObject( oldChild );
	688	oldChild->GetEventHandler()->ProcessEvent(event);
	689	}
	690	}
	691	if (event.GetSelection() != -1)
	692	{
	693	wxMDIChildFrame* activeChild = (wxMDIChildFrame*) GetPage(event.GetSelection());
	694	if (activeChild)
	695	{
	696	wxActivateEvent event(wxEVT_ACTIVATE, TRUE, activeChild->GetId());
	697	event.SetEventObject( activeChild );
	698	activeChild->GetEventHandler()->ProcessEvent(event);
	699
	700	if (activeChild->GetMDIParentFrame())
	701	{
	702	activeChild->GetMDIParentFrame()->SetActiveChild(activeChild);
	703	activeChild->GetMDIParentFrame()->SetChildMenuBar(activeChild);
	704	}
	705	}
	706	}
	707	event.Skip();
	708	}