docmdiref.cpp

Go to the documentation of this file.

/*! \file docview/src/docmdiref.cpp
    \brief Frame classes for MDI document/view applications
    \author Julian Smart
    \author Klaas Holwerda 
    \date Created 01/02/97

    Copyright: (c) Julian Smart

    Licence: wxWidgets licence

    RCS-ID: $Id: docmdiref.cpp,v 1.44 2009/09/29 20:06:47 titato Exp $
*/

#include "docviewprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#if wxUSE_MDI_ARCHITECTURE && wxUSE_DOC_VIEW_ARCHITECTURE

#ifndef WX_PRECOMP
    #include "wx/string.h"
    #include "wx/utils.h"
    #include "wx/app.h"
    #include "wx/dc.h"
    #include "wx/dialog.h"
    #include "wx/menu.h"
    #include "wx/list.h"
    #include "wx/filedlg.h"
    #include "wx/intl.h"
    #include "wx/file.h"
#endif

#include "wx/docview/doccom.h"
#include "wx/docview/docmdiref.h"

// ----------------------------------------------------------------------------
// template instantiations
// ----------------------------------------------------------------------------

//#include "wx/general/id.inl"

//----------------------------------------------------------------------------
// template instanitiations
//----------------------------------------------------------------------------

/*
 * Docview MDI parent frame
 */

IMPLEMENT_CLASS(a2dDocumentMDIParentFrame, wxMDIParentFrame)

BEGIN_EVENT_TABLE(a2dDocumentMDIParentFrame, wxMDIParentFrame)
    EVT_MENU(wxID_EXIT, a2dDocumentMDIParentFrame::OnExit)
    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, a2dDocumentMDIParentFrame::OnMRUFile)
    EVT_CLOSE(a2dDocumentMDIParentFrame::OnCloseWindow)
END_EVENT_TABLE()

a2dDocumentMDIParentFrame::a2dDocumentMDIParentFrame( wxFrame *frame, wxWindowID id, const wxString& title,
  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
  wxMDIParentFrame(frame, id, title, pos, size, style, name)
{
}

a2dDocumentMDIParentFrame::a2dDocumentMDIParentFrame()
{
}

bool a2dDocumentMDIParentFrame::Create(     
                    wxWindow* frame,
                    wxWindowID id,
                    const wxString& title,
                    const wxPoint& pos,
                    const wxSize& size,
                    long  style,
                    const wxString& name)
{
    bool res = wxMDIParentFrame::Create(frame, id, title, pos, size, style, name);
    return res;
}


void a2dDocumentMDIParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
{
    Close();
}

void a2dDocumentMDIParentFrame::OnMRUFile(wxCommandEvent& event)
{
    int n = event.GetId() - wxID_FILE1;  // the index in MRU list
    a2dFileHistoryItem* fileHistItem = a2dDocviewGlobals->GetDocviewCommandProcessor()->GetHistoryFileItem(n);
    if ( fileHistItem )
    {
        // verify that the file exists before doing anything else
        if ( wxFile::Exists( fileHistItem->m_filename.GetFullPath() ) )
        {
            // try to open it
            a2dError returncode = a2dDocviewGlobals->GetDocviewCommandProcessor()->CreateDocuments( fileHistItem->m_filename.GetFullPath(), a2dREFDOC_SILENT, fileHistItem->m_docTemplate );
            if ( returncode == a2dError_NoDocTemplateRef )
            {
                a2dDocviewGlobals->ReportError( a2dError_CouldNotCreateDocument, _("No templates to create document, removed from history, a2dDocumentCommandProcessor::OnMRUFile")); 
                a2dDocviewGlobals->GetDocviewCommandProcessor()->RemoveFileFromHistory(n);
            }
        }
        else
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_FileHistory,  _("The file '%s' doesn't exist and couldn't be opened.\nIt has been removed from the most recently used files list."),
                       fileHistItem->m_filename.GetFullPath().c_str());

            // remove the bogus filename from the MRU list and notify the user
            // about it
            a2dDocviewGlobals->GetDocviewCommandProcessor()->RemoveFileFromHistory(n);
        }
    }
}

bool a2dDocumentMDIParentFrame::ProcessEvent(wxEvent& event)
{
    if ( !wxEvtHandler::ProcessEvent(event) )
    {
        if ( a2dDocviewGlobals->GetDocviewCommandProcessor() ) //&& event.IsKindOf(CLASSINFO(wxCommandEvent)) )
            return a2dDocviewGlobals->GetDocviewCommandProcessor()->ProcessEvent(event);
        return false;
    }
    return true;
}

void a2dDocumentMDIParentFrame::OnCloseWindow(wxCloseEvent& event)
{
  if (a2dDocviewGlobals->GetDocviewCommandProcessor()->Clear(!event.CanVeto()))
  {
    this->Destroy();
  }
  else
    event.Veto();
}

void a2dDocumentMDIParentFrame::OnCmdMenuId(wxCommandEvent &event)
{
    event.Skip();
}

void a2dDocumentMDIParentFrame::AddCmdMenu( wxMenu* parentMenu, wxMenuItem* item )
{
    Connect( item->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIParentFrame::OnCmdMenuId ) );
    parentMenu->Append( item );
}

void a2dDocumentMDIParentFrame::AddCmdMenu( wxMenu* parentMenu, const a2dMenuIdItem& cmdId )
{
    Connect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIParentFrame::OnCmdMenuId ) );
    parentMenu->Append( cmdId.GetId(), cmdId.GetLabel(), cmdId.GetHelp(), cmdId.IsCheckable() );
}

void a2dDocumentMDIParentFrame::RemoveCmdMenu( wxMenu* parentMenu, const a2dMenuIdItem& cmdId )
{
    Disconnect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIParentFrame::OnCmdMenuId ) );
    parentMenu->Delete( cmdId.GetId() );
}

void a2dDocumentMDIParentFrame::AddCmdToToolbar( const a2dMenuIdItem& cmdId )
{
    if ( ! GetToolBar() )
        return;
    Connect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIParentFrame::OnCmdMenuId ) );
    wxString error = _T("No Bitmap for a2dToolCmd found for:") + cmdId.GetIdName();
    wxASSERT_MSG( cmdId.GetBitmap(false).Ok(), error );
    GetToolBar()->AddTool( cmdId.GetId(), cmdId.GetLabel(), cmdId.GetBitmap(false), cmdId.GetHelp() ); 
}

/********************************************************************
* a2dDocumentMDIChildFrame
*********************************************************************/

IMPLEMENT_CLASS(a2dDocumentMDIChildFrame, wxMDIChildFrame)

BEGIN_EVENT_TABLE( a2dDocumentMDIChildFrame, wxMDIChildFrame)
    EVT_ACTIVATE( a2dDocumentMDIChildFrame::OnActivate)
    EVT_CLOSE( a2dDocumentMDIChildFrame::OnCloseWindow)
    EVT_PAINT( a2dDocumentMDIChildFrame::OnPaint )
    EVT_ACTIVATE_VIEW_SENT_FROM_CHILD( a2dDocumentMDIChildFrame::OnActivateViewSentFromChild )
    EVT_CLOSE_VIEW( a2dDocumentMDIChildFrame::OnCloseView )
END_EVENT_TABLE()


a2dDocumentMDIChildFrame::a2dDocumentMDIChildFrame()
{
    m_destroyOnCloseView = true;
    m_view = NULL;
}


a2dDocumentMDIChildFrame::a2dDocumentMDIChildFrame( wxMDIParentFrame *frame,  a2dView *view, wxWindowID  id,
  const wxString& title, const wxPoint& pos, const wxSize& size, long style, const wxString& name):
    wxMDIChildFrame(frame, id, title, pos, size, style, name)
{
    m_destroyOnCloseView = true;
    m_view = view;
    if ( m_view )
    {
        m_view->SetDisplayWindow( this );
    }
}

bool a2dDocumentMDIChildFrame::Create(     
                    wxMDIParentFrame* frame,
                    a2dView* view,
                    wxWindowID id,
                    const wxString& title,
                    const wxPoint& pos,
                    const wxSize& size,
                    long  style,
                    const wxString& name)
{
    bool res = wxMDIChildFrame::Create(frame, id, title, pos, size, style, name);
    m_view = view;
    if ( m_view )
    {
        m_view->SetDisplayWindow( this );
    }
    return res;
}  

a2dDocumentMDIChildFrame::~a2dDocumentMDIChildFrame(void)
{
    m_view = (a2dView *) NULL;
}

void a2dDocumentMDIChildFrame::OnCmdMenuId(wxCommandEvent &event)
{
    event.Skip();
}

void a2dDocumentMDIChildFrame::AddCmdMenu( wxMenu* parentMenu, wxMenuItem* item )
{
    Connect( item->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIChildFrame::OnCmdMenuId ) );
    parentMenu->Append( item );
}

void a2dDocumentMDIChildFrame::AddCmdMenu( wxMenu* parentMenu, const a2dMenuIdItem& cmdId )
{
    Connect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIChildFrame::OnCmdMenuId ) );
    parentMenu->Append( cmdId.GetId(), cmdId.GetLabel(), cmdId.GetHelp(), cmdId.IsCheckable() );
}

void a2dDocumentMDIChildFrame::RemoveCmdMenu( wxMenu* parentMenu, const a2dMenuIdItem& cmdId )
{
    Disconnect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIChildFrame::OnCmdMenuId ) );
    parentMenu->Delete( cmdId.GetId() );
}

void a2dDocumentMDIChildFrame::AddCmdToToolbar( const a2dMenuIdItem& cmdId )
{
    if ( ! GetToolBar() )
        return;
    Connect( cmdId.GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( a2dDocumentMDIChildFrame::OnCmdMenuId ) );
    wxString error = _T("No Bitmap for a2dToolCmd found for:") + cmdId.GetIdName();
    wxASSERT_MSG( cmdId.GetBitmap(false).Ok(), error );
    GetToolBar()->AddTool( cmdId.GetId(), cmdId.GetLabel(), cmdId.GetBitmap(false), cmdId.GetHelp() ); 
}

void a2dDocumentMDIChildFrame::SetView( a2dView* view ) 
{ 
    if ( m_view )
    {
        m_view->SetDisplayWindow( NULL );
    }

    m_view = view; 

    if ( m_view )
    {
        //Attach the canvas as the window for the view to display its stuff
        m_view->SetDisplayWindow( this );
    }
}

// Extend event processing to search the view's event table
bool a2dDocumentMDIChildFrame::ProcessEvent(wxEvent& event)
{
    static wxEvent *ActiveEvent = NULL;

    // Break recursion loops
    if (ActiveEvent == &event)
        return false;

    ActiveEvent = &event;

    bool ret = false;
    if ( event.GetEventType() == wxEVT_CLOSE_WINDOW )
    {
        //window close events should lead to view close events.
        //
        //When a child frame is being closed, only the child view will be closed and the frame flaged 
        //for Destroy ( see OnCloseView )

        wxCloseEvent& closeevent = (wxCloseEvent&) event;

        //give the Frame the right to veto in for instance a OnCloseWindow which is called by wxEVT_CLOSE
        if ( wxEvtHandler::ProcessEvent(event) && !closeevent.GetVeto() )
        {
            closeevent.SetCanVeto( false );
            if ( m_view )
                m_view->GetEventHandler()->ProcessEvent(closeevent);
            m_view = NULL;
        }
        else        
            closeevent.Veto();
        ret = true;
    }
    else if ( event.GetEventType() == wxEVT_ACTIVATE )  
    {
        // the wxEVT_ACTIVATE event should lead to a wxEVT_ACTIVATE_VIEW event here.
        // This last event is always sent to a2dDocviewGlobals->GetDocviewCommandProcessor()() from
        // within a2dView::Activate()
        
        if (  m_view && !m_view->IsClosed() )
             m_view->GetEventHandler()->ProcessEvent(event);

        ret = wxEvtHandler::ProcessEvent(event);
    }
    else
    {
        // EVENTS needed for view directly, should be handled above.
        // events down here go only to the parent window or commandprocessor

        //In case the event is a commandevent, it will automatically be redirected to the parent window by
        // wxEvtHandler::ProcessEvent
        //There is no need to handle that case in here. 
        if ( !wxEvtHandler::ProcessEvent(event) )
        {
            // Try the document manager, then do default processing
            if ( a2dDocviewGlobals->GetDocviewCommandProcessor() )
            {
                ret = a2dDocviewGlobals->GetDocviewCommandProcessor()->ProcessEvent(event);
            }
            else
                ret = false;
        }
        else
            ret = true;
    }
    ActiveEvent = NULL;
    return ret;
}

void a2dDocumentMDIChildFrame::OnActivate(wxActivateEvent& event)
{
  wxMDIChildFrame::OnActivate(event);

  if (event.GetActive() && m_view)
    m_view->Activate(event.GetActive());
}

void a2dDocumentMDIChildFrame::OnActivateViewSentFromChild( a2dViewEvent& viewevent )
{
    if ( viewevent.GetActive() )
    {
        m_view = (a2dView*) viewevent.GetEventObject();
    }
}

// Clean up frames/windows used for displaying the view.
// They or not really deleted here only flagged for deletion using Destroy(),
// this means that they will really be deleted in idle time by wxWindows.
void a2dDocumentMDIChildFrame::OnCloseView( a2dCloseViewEvent& event )
{
    wxASSERT_MSG( m_view || event.GetEventObject(), wxT("not view of frame closed") );

    //there is no need to handle the parent frame differently

    //frames can be destroyed savely ( happening in idle time )
    //This default, asumes a multi frame application, where each view has one frame
    if ( m_destroyOnCloseView )
        Destroy(); //very likely done somewhere else, but makes sure it happens.

    if ( m_view )
        m_view->SetDisplayWindow( NULL );
    m_view = NULL;

    Refresh(); 
}

void a2dDocumentMDIChildFrame::OnCloseWindow(wxCloseEvent& event)
{
    if ( !m_view )
        Destroy();

    // Close view but don't delete the frame while doing so!
    // ...since it will be deleted by wxWindows

    if ( event.CanVeto() )
    {
        if ( !m_view || m_view->Close( !event.CanVeto() ) )   
            Destroy();
        else
            event.Veto( true );

    }
    else
        Destroy();
}

bool a2dDocumentMDIChildFrame::Destroy() 
{ 
    m_view = (a2dView *)NULL; 
    return wxMDIChildFrame::Destroy(); 
}

void a2dDocumentMDIChildFrame::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
    wxPaintDC dc( this );
    PrepareDC(dc);

    if ( m_view && m_view->GetDisplayWindow() == this )
        OnDraw(dc);    
}

// Define the repainting behaviour
void a2dDocumentMDIChildFrame::OnDraw(wxDC& dc)
{
    if ( m_view && m_view->GetDisplayWindow() == this )
        m_view->OnDraw(& dc);
}

#endif
    // wxUSE_DOC_VIEW_ARCHITECTURE

docmdiref.cpp Source File -- Tue Aug 31 17:56:27 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation