src/motif/mdi.cpp

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

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

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

#include "wx/mdi.h"

#ifndef WX_PRECOMP
    #include "wx/menu.h"
    #include "wx/icon.h"
    #include "wx/settings.h"
#endif

#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(wxOrientation WXUNUSED(orient))
{
    // 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(wxEmptyString);
        else
        {
            wxMenuBar *menuBar = (wxMenuBar*) NULL;
            if (GetActiveChild())
              menuBar = GetActiveChild()->GetMenuBar();
            else
              menuBar = GetMenuBar();
            if (menuBar)
            {
                wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
                if (!helpString.empty())
                    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);

    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
        {
            int i = clientWindow->FindPage(this);

            if (i != -1)
            {
                clientWindow->RemovePage(i);
                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 wxWidgets)
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)
{
    SetVisibleStatus( show );
    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)
{
    wxTopLevelWindow::SetTitle( title );
    wxMDIClientWindow* clientWindow = GetMDIParentFrame()->GetClientWindow();

    // Remove page if still there
    {
        int i = clientWindow->FindPage(this);

        if (i != -1)
            clientWindow->SetPageText(i, 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::DoSetSizeHints(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);
        SetFont(font);
        return true;
    }
    else
        return false;
}

int wxMDIClientWindow::FindPage(const wxNotebookPage* page)
{
    for (int i = GetPageCount() - 1; i >= 0; --i)
    {
        if (GetPage(i) == page)
            return i;
    }

    return -1;
}

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