doccom.cpp

Go to the documentation of this file.

/*! \file docview/src/doccom.cpp
    \brief Document/view classes
    \author Klaas Holwerda 
    \date Created 05/07/2003

    Copyright: 2001-2004 (C) Klaas Holwerda 

    Licence: wxWidgets licence

    RCS-ID: $Id: doccom.cpp,v 1.157 2009/09/26 19:01:05 titato Exp $
*/

#include "docviewprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

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

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#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"
#endif


#ifdef __WXGTK__
    #include "wx/mdi.h"
#endif

#if wxUSE_PRINTING_ARCHITECTURE
  #include "wx/prntbase.h"
  #include "wx/printdlg.h"
#endif

#include "wx/msgdlg.h"
#include "wx/choicdlg.h"
#include "wx/confbase.h"
#include "wx/file.h"
#include "wx/cmdproc.h"
#include "wx/log.h"
#include "wx/textdlg.h"

#include <wx/tokenzr.h>
#include <wx/regex.h>

#if wxUSE_PRINTING_ARCHITECTURE
#include <wx/paper.h>
#endif

#include <stdio.h>
#include <string.h>

#include "wx/docview.h"
#include "wx/docview/docviewref.h"
#include "wx/general/gen.h"
#include "wx/docview/doccom.h"
#include "wx/docview/doccomimpl.h"
#include "wx/docview/cparser.h"

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

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

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DDOCVIEWDLLEXP a2dSmrtPtrList< a2dCommandLanguageWrapper >;
#endif

// ============================================================================
// declarations
// ============================================================================

DEFINE_EVENT_TYPE(wxEVT_ADD_DOCUMENT)
DEFINE_EVENT_TYPE(wxEVT_REMOVE_DOCUMENT)
DEFINE_EVENT_TYPE(wxEVT_CHANGED_DOCUMENT)
DEFINE_EVENT_TYPE(wxEVT_RECORD)
DEFINE_EVENT_TYPE(wxEVT_CANNOT_OPEN_DOCUMENT)

//! select one or more files 
/*!
    \param message message to display
    \param default_path path to go for selecting files
    \param default_filename file to open by default
    \param indexDefaultExtension Returns the index into the list of filters supplied, 
            optionally, in the wildcard parameter. Before the dialog is shown, 
            this is the index which will be used when the dialog is first displayed. 
            After the dialog is shown, this is the index selected by the user.
    \param wildcard display files according to this filter
    \param flags flags for multiple files etc. see wxFileDialog
    \param parent parent window
    \param returnPaths all returned files in case fo multiple files selection
    \param x x display coordinate of dialog
    \param y y display coordinate of dialog
*/
a2dError a2dFileSelectorEx( const wxString& message = wxFileSelectorPromptStr,
                      const wxString& default_path = wxEmptyString,
                      const wxString& default_filename = wxEmptyString,
                      int *indexDefaultExtension = NULL,
                      const wxString& wildcard = wxFileSelectorDefaultWildcardStr,
                      int flags = 0,
                      wxWindow *parent = NULL,
                      wxArrayString *returnPaths = NULL, 
                      int x = wxDefaultCoord, int y = wxDefaultCoord )
{
    wxASSERT_MSG( returnPaths, wxT("must have return path wxArrayString") );
    returnPaths->Clear();

    wxFileDialog fileDialog(parent,
        message,
        default_path,
        default_filename,
        wildcard,
        flags, wxPoint(x, y));

    //set position to the preferred template
    if (indexDefaultExtension && *indexDefaultExtension > 0)
        fileDialog.SetFilterIndex(*indexDefaultExtension);

    if ( fileDialog.ShowModal() == wxID_OK )
    {
        if ( indexDefaultExtension )
            *indexDefaultExtension = fileDialog.GetFilterIndex();

        if(flags & wxFD_MULTIPLE)
            fileDialog.GetPaths(*returnPaths);
        else
            returnPaths->Add( fileDialog.GetPath() );
        return a2dError_NoError;
    }
    return a2dError_Canceled;
}


// ----------------------------------------------------------------------------
// wxWindows macros
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(a2dDocumentCommandProcessor, a2dCommandProcessor )
 
//!@{ \ingroup menus
const a2dMenuIdItem CmdMenu_Exit( wxT("CmdMenu_Exit"), wxT("&Exit\tAlt-X"), wxT("Exit application") );
const a2dMenuIdItem CmdMenu_FileClose( wxT("CmdMenu_FileClose"), wxT("&Close"), wxT("Close current file") );
const a2dMenuIdItem CmdMenu_FileOpen( wxT("CmdMenu_FileOpen"), wxT("&Open"), wxT("Open existing file") );
const a2dMenuIdItem CmdMenu_FileNew( wxT("CmdMenu_FileNew"), wxT("&New"), wxT("Create new file") );
const a2dMenuIdItem CmdMenu_FileSave( wxT("CmdMenu_FileSave"), wxT("Save"), wxT("Save file") );
const a2dMenuIdItem CmdMenu_FileSaveAs( wxT("CmdMenu_FileSaveAs"), wxT("Save &As"), wxT("Save file with different Name") );
const a2dMenuIdItem CmdMenu_FileImport( wxT("CmdMenu_FileImport"), wxT("&Import"), wxT("Import file into current document") );
const a2dMenuIdItem CmdMenu_FileExport( wxT("CmdMenu_FileExport"), wxT("&Export"), wxT("Export file to formatX") );
const a2dMenuIdItem CmdMenu_FileRevert( wxT("CmdMenu_FileRevert"), wxT("&Revert"), wxT("reload file") );
const a2dMenuIdItem CmdMenu_Print( wxT("CmdMenu_Print"), wxT("Print"), wxT("&Print") );
const a2dMenuIdItem CmdMenu_Preview( wxT("CmdMenu_Preview"), wxT("Preview"), wxT("Preview") );
const a2dMenuIdItem CmdMenu_PrintView( wxT("CmdMenu_PrintView"), wxT("Print View"), wxT("Print View") );
const a2dMenuIdItem CmdMenu_PreviewView( wxT("CmdMenu_PreviewView"), wxT("Preview View"), wxT("Preview Print View") );
const a2dMenuIdItem CmdMenu_PrintDocument( wxT("CmdMenu_PrintDocument"), wxT("Print Document"), wxT("Print Document") );
const a2dMenuIdItem CmdMenu_PreviewDocument( wxT("CmdMenu_PreviewDocument"), wxT("Preview Document"), wxT("Preview Print Document") );
const a2dMenuIdItem CmdMenu_PrintSetup( wxT("CmdMenu_PrintSetup"), wxT("Print Setup"), wxT("Setup Print") );
const a2dMenuIdItem CmdMenu_EmptyDocument( wxT("CmdMenu_EmptyDocument"), wxT("Empty Document"), wxT("Remove contents of document") );
//!@}

// ----------------------------------------------------------------------------
// a2dDocumentCommandProcessor
// ----------------------------------------------------------------------------

//!@{ \ingroup commandid
const a2dCommandId a2dCommand_Exit::Id( wxT("Exit") );
const a2dCommandId a2dCommand_FileClose::Id( wxT("FileClose") );
const a2dCommandId a2dCommand_FileOpen::Id( wxT("FileOpen") );
const a2dCommandId a2dCommand_FileNew::Id( wxT("FileNew") ); 
const a2dCommandId a2dCommand_FileSave::Id( wxT("FileSave") );
const a2dCommandId a2dCommand_FileSaveAs::Id( wxT("FileSaveAs") );
const a2dCommandId a2dCommand_FileImport::Id( wxT("FileImport") );
const a2dCommandId a2dCommand_FileExport::Id( wxT("FileExport") );
const a2dCommandId a2dCommand_FileRevert::Id( wxT("FileRevert") );
const a2dCommandId a2dCommand_Print::Id( wxT("Print") );
const a2dCommandId a2dCommand_CreateDocument::Id( wxT("CreateDocument") );
const a2dCommandId a2dCommand_CloseDocuments::Id( wxT("CloseDocuments") );
const a2dCommandId a2dCommand_Clear::Id( wxT("Clear") );
const a2dCommandId a2dCommand_Ask::Id( wxT("Ask") );
const a2dCommandId a2dCommand_AskFile::Id( wxT("AskFile") );
const a2dCommandId a2dCommand_ShowVar::Id( wxT("ShowVar") );
const a2dCommandId a2dCommand_SetActivateView::Id( wxT("SetActivateView") );
//!@}

A2D_BEGIN_EVENT_TABLE( a2dDocumentCommandProcessor, a2dCommandProcessor )
    A2D_EVT_MENU( CmdMenu_Exit.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileClose.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileOpen.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileNew.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileSave.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileSaveAs.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileImport.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileExport.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_FileRevert.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_Print.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_Preview.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_PrintView.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_PreviewView.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_PrintDocument.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_PreviewDocument.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_PrintSetup.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_MENU( CmdMenu_EmptyDocument.GetId(), a2dDocumentCommandProcessor::OnMenu )
    A2D_EVT_UPDATE_UI( CmdMenu_FileOpen.GetId(), a2dDocumentCommandProcessor::OnUpdateFileOpen)
    A2D_EVT_UPDATE_UI( CmdMenu_FileClose.GetId(), a2dDocumentCommandProcessor::OnUpdateFileClose)
    A2D_EVT_UPDATE_UI( CmdMenu_FileRevert.GetId(), a2dDocumentCommandProcessor::OnUpdateFileRevert)
    A2D_EVT_UPDATE_UI( CmdMenu_FileNew.GetId(), a2dDocumentCommandProcessor::OnUpdateFileNew)
    A2D_EVT_UPDATE_UI( CmdMenu_FileSave.GetId(), a2dDocumentCommandProcessor::OnUpdateFileSave)
    A2D_EVT_UPDATE_UI( CmdMenu_FileSaveAs.GetId(), a2dDocumentCommandProcessor::OnUpdateFileSaveAs)
    A2D_EVT_UPDATE_UI(wxID_UNDO, a2dDocumentCommandProcessor::OnUpdateUndo)
    A2D_EVT_UPDATE_UI(wxID_REDO, a2dDocumentCommandProcessor::OnUpdateRedo)

#if wxUSE_PRINTING_ARCHITECTURE
    A2D_EVT_UPDATE_UI( CmdMenu_Print.GetId(), a2dDocumentCommandProcessor::OnUpdatePrint)
    A2D_EVT_UPDATE_UI( CmdMenu_Preview.GetId(), a2dDocumentCommandProcessor::OnUpdatePreview)
#endif

    A2D_EVT_ACTIVATE_VIEW( a2dDocumentCommandProcessor::OnActivateView )
    A2D_EVT_REMOVE_VIEW( a2dDocumentCommandProcessor::OnRemoveView )
    A2D_EVT_ADD_VIEW( a2dDocumentCommandProcessor::OnAddView )

    A2D_EVT_CANNOT_OPEN_DOCUMENT( a2dDocumentCommandProcessor::OnCannotOpenDocument )

A2D_END_EVENT_TABLE()

a2dDocumentCommandProcessor::a2dDocumentCommandProcessor(long flags, bool WXUNUSED(initialize), int maxCommands )
        : a2dCommandProcessor( maxCommands )
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        , m_initCurrentSmartPointerOwner(this)
#endif
{
    m_defaultDocumentNameCounter = 1;
    m_flags = flags;
    m_lastView = m_currentView = (a2dView*) NULL;
    m_maxDocsOpen = 10000;
    m_fileHistory = (a2dFileHistory *) NULL;
#if wxUSE_PRINTING_ARCHITECTURE
    m_pageSetupData = new wxPageSetupData;
#endif
    Initialize();
    m_currentDocument = NULL;
    m_lastView = m_currentView = NULL;
    m_busyExit = false;

}

a2dDocumentCommandProcessor::a2dDocumentCommandProcessor( a2dDocumentCommandProcessor* other )
        : a2dCommandProcessor( other->m_maxNoCommands )
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        , m_initCurrentSmartPointerOwner(this)
#endif
{
    m_defaultDocumentNameCounter = 1;
    m_flags = other->m_flags;
    m_lastView = m_currentView = (a2dView*) NULL;
    m_maxDocsOpen = 10000;

#if wxUSE_PRINTING_ARCHITECTURE
    m_pageSetupData = new wxPageSetupData(*other->m_pageSetupData);
#endif
    a2dCommandProcessor::Initialize();

    m_fileHistory = new a2dFileHistory;
    size_t j;
    for ( j = 0; j < other->m_fileHistory->GetCount(); j++ )
    {
        m_fileHistory->AddFileToHistory( other->GetHistoryFile(j) );
    }

    m_currentDocument = NULL;
    m_lastView = m_currentView = NULL;
    
    m_docTemplates = other->m_docTemplates;
    m_viewTemplates = other->m_viewTemplates;
    m_busyExit = false;
}

a2dDocumentCommandProcessor::~a2dDocumentCommandProcessor()
{
    m_busyExit = true;
    Clear();
    if (m_fileHistory)
        delete m_fileHistory;
#if wxUSE_PRINTING_ARCHITECTURE
    if(m_pageSetupData)
        delete m_pageSetupData;
#endif
}

void a2dDocumentCommandProcessor::OnMenu( wxCommandEvent& event )
{
    if ( event.GetId() == CmdMenu_Exit.GetId() )
    {
        Exit();
    }
    else if ( event.GetId() == CmdMenu_FileClose.GetId() )
    {
        FileClose();
    }
    else if ( event.GetId() == CmdMenu_FileOpen.GetId() )
    { 
        a2dDocumentPtr doc = NULL;
        a2dError result = FileOpen( doc, wxFileName( wxT("") ) );
        if ( !doc )
        {
            if ( result == a2dError_Canceled )
            {
            }
        }
    }
    else if ( event.GetId() == CmdMenu_FileNew.GetId() )
    {
        a2dDocumentPtr doc;
        a2dError result = FileNew( doc );
    }
    else if ( event.GetId() == CmdMenu_FileSave.GetId() )
    {
        FileSave();
    }
    else if ( event.GetId() == CmdMenu_FileSaveAs.GetId() )
    {
        FileSaveAs();
    }
    else if ( event.GetId() == CmdMenu_FileImport.GetId() )
    {
        FileImport();
    }
    else if ( event.GetId() == CmdMenu_FileExport.GetId() )
    {
        FileExport();
    }
    else if ( event.GetId() == CmdMenu_FileRevert.GetId() )
    {
        FileRevert();
    }
    else if ( event.GetId() == CmdMenu_Print.GetId() )
    {
        Print( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PrintView ) ));
    }
    else if ( event.GetId() == CmdMenu_PrintView.GetId() )
    {
        Print( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PrintView ) ));
    }
    else if ( event.GetId() == CmdMenu_PreviewView.GetId() )
    {
        Preview( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PreviewView ) ));
    }
    else if ( event.GetId() == CmdMenu_PrintDocument.GetId() )
    {
        Print( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PrintDocument ) ));
    }
    else if ( event.GetId() == CmdMenu_PreviewDocument.GetId() )
    {
        Preview( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PreviewDocument ) ));
    }
    else if ( event.GetId() == CmdMenu_PrintSetup.GetId() )
    {
        Print( new a2dCommand_Print( a2dCommand_Print::Args().what( a2dCommand_Print::PrintSetup ) ));
    }
    else if ( event.GetId() == CmdMenu_EmptyDocument.GetId() )
    {
        if ( !m_currentDocument )
            return;

        if ( !m_currentDocument->GetCommandProcessor() )
            return;

        m_currentDocument->DeleteContents();
        m_currentDocument->GetCommandProcessor()->Initialize();
    }
    a2dDocviewGlobals->SendToLogTarget();
    a2dDocviewGlobals->ResetErrors();
}

void a2dDocumentCommandProcessor::OnExit()
{
}

void a2dDocumentCommandProcessor::Initialize()
{
    a2dCommandProcessor::Initialize();

    if (m_fileHistory)
        delete m_fileHistory;
    m_fileHistory = OnCreateFileHistory();
}

bool a2dDocumentCommandProcessor::SubmitToDocument( a2dCommand *command, bool storeIt )
{
    if ( !m_currentDocument )
        return false;

    if ( !m_currentDocument->GetCommandProcessor() )
        return false;

    return m_currentDocument->GetCommandProcessor()->Submit( command, storeIt );
}

bool a2dDocumentCommandProcessor::CloseDocuments(bool force)
{
    m_currentView = NULL;
    m_currentDocument = NULL; 

    bool all = true;

    a2dDocumentList::iterator iter = m_docs.begin();
    while( iter != m_docs.end() )
    {
        //An extra reference to make absolutely sure that the document is deleted HERE, 
        //and not deep down in views or documents. 
        //If we don't do this some other call may already release the document from here, while closing 
        //and event resulting from that are not yet finished. A typical case is that 
        // a2dDocumentCommandProcessor::FileClose() is called by the user after removing view from a document, 
        // unaware that it will be released to soon that way.
        a2dDECLARE_LOCAL_ITEM(a2dDocumentList::value_type, doc, *iter);

        iter++;
        if ( doc->Close( force ) || force )
        {
            // in case of non veto in document closing, this already did happen, 
            // but if force is true this makes sure it happens. 
            doc->DisConnectAllViews(); 

            // release document from a2dDocumentCommandProcessor 
            // This assumes that documents are not connected in
            // any way, i.e. deleting one document does NOT
            // delete another.
            RemoveDocument( doc );
        }
        else
            all = false;

    }
    return all;
}

bool a2dDocumentCommandProcessor::Clear(bool force)
{
    if (!CloseDocuments(force))
        return false;

    m_docTemplates.clear();
    m_viewTemplates.clear();
    return true;
}

bool a2dDocumentCommandProcessor::Exit(bool force)
{
    if ( m_busyExit )
        return true;

    m_busyExit = true;
    // the next will destroy all child window of view on documents
    if ( Clear( force ) )
    {
        // e.g. toplevel windows, which or not THE toplevel window.
        OnExit();

        //now check if the exit is via the windows close mechanism, or a script line. 
        // In case of window close, the toplevel window is already marked for destroy.
        wxFrame *pf = (wxFrame*) wxTheApp->GetTopWindow();
        if ( wxTopLevelWindows.Find( pf ) && !wxPendingDelete.Member( pf ) )
        {
            pf->Close(true);
        }
        return true;
    }
    return false;
}

a2dFileHistory *a2dDocumentCommandProcessor::OnCreateFileHistory()
{
    return new a2dFileHistory;
}

bool a2dDocumentCommandProcessor::FileClose( bool force )
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;

    if (doc->Close( force )) // if not vetod, closes the view(s) of this document
    {
        RemoveDocument( doc );
        return true;
    }
    return false;
}

a2dError a2dDocumentCommandProcessor::FileNew( a2dDocumentPtr& doc, a2dTemplateFlagMask docTemplateFlags )
{
    doc = NULL;
    a2dError result;
    result = CreateDocuments(wxT(""), a2dREFDOC_NEW | a2dREFDOC_INIT, NULL, wxFD_OPEN, docTemplateFlags );
    if ( result == a2dError_NoError )
        doc = m_docs.back();
    else if ( result == a2dError_Canceled )
        doc = NULL;
    else
    {
        a2dDocviewGlobals->ReportError( result, _("could not create document, a2dDocumentCommandProcessor::FileNew")); 
        doc = NULL;
    }

    return result;
}

a2dError a2dDocumentCommandProcessor::FileOpen( a2dDocumentPtr& doc, const wxFileName& file, a2dTemplateFlagMask docTemplateFlags )
{
    a2dError result ;
    wxString filename  = file.GetFullPath();

    doc = NULL;
    if ( filename.IsEmpty() )
    {
        result = CreateDocuments(wxT(""), a2dREFDOC_NON, NULL, wxFD_OPEN, docTemplateFlags );
        if ( result == a2dError_NoError )
            doc = m_docs.back();
        else if ( result == a2dError_Canceled )
            doc = NULL;
        else if ( result == a2dError_NoDocTemplateRef )
        {
            a2dDocviewGlobals->ReportError( a2dError_CouldNotCreateDocument, _("No templates, could not create document, a2dDocumentCommandProcessor::FileOpen")); 
            doc = NULL;
        }
        else
        {
            a2dDocviewGlobals->ReportError( result, _("could not create document, a2dDocumentCommandProcessor::FileOpen")); 
            doc = NULL;
        }
    }
    else
    {
        a2dPathList path;
        path.Add( wxT(".") );
        if ( !path.ExpandPath( filename ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), file.GetFullPath().c_str(),filename.c_str() ); 
            result = a2dError_CouldNotEvaluatePath;
            return result;
        }
        result = CreateDocuments( filename, a2dREFDOC_SILENT, NULL, wxFD_OPEN, docTemplateFlags );
        if ( result == a2dError_NoError )
            doc = m_docs.back();
        else if ( result == a2dError_Canceled )
            doc = NULL;
        else if ( result == a2dError_NoDocTemplateRef )
        {
            a2dDocviewGlobals->ReportError( a2dError_CouldNotCreateDocument, _("No templates, could not create document, a2dDocumentCommandProcessor::FileOpen")); 
            doc = NULL;
        }
        else
        {
            a2dDocviewGlobals->ReportError( result, _("could not create document, a2dDocumentCommandProcessor::FileOpen")); 
            doc = NULL;
        }
    }

    // returns (a2dDocument*) NULL if creation fails
    return result;
}

a2dError a2dDocumentCommandProcessor::FilesOpen( const wxString& openPath, int dialogFlags, a2dTemplateFlagMask mask )
{
    a2dError result;
    wxString expandedPath = openPath;
    a2dPathList path;
    path.Add( wxT(".") );
    if ( !path.ExpandPath( expandedPath ) )
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), openPath.c_str(),expandedPath.c_str() ); 
        result = a2dError_CouldNotEvaluatePath;
        return result;
    }
    result = CreateDocuments( openPath, a2dREFDOC_NON, NULL, dialogFlags, mask );
    if ( result == a2dError_NoError )
    {
    }
    else if ( result == a2dError_Canceled )
    {
    }
    else
    {
        a2dDocviewGlobals->ReportError( result, _("could not create document, a2dDocumentCommandProcessor::FilesOpen")); 
    }

    return result;
}

bool a2dDocumentCommandProcessor::FileRevert()
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;
    doc->Revert();
    return true;
}

bool a2dDocumentCommandProcessor::FileSave()
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;
    doc->Save();
    return true;
}

bool a2dDocumentCommandProcessor::FileSaveAs( const wxFileName& file, a2dDocumentFlagMask flags )
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;

    a2dPathList path;
    path.Add( wxT(".") );
    wxString foundfile = file.GetFullPath();
    if ( !path.ExpandPath( foundfile ) )
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), file.GetFullPath().c_str(),foundfile.c_str() ); 
        return false;
    }

    return doc->SaveAs( foundfile, flags );
}

bool a2dDocumentCommandProcessor::FileExport( const wxFileName& file, const wxString& description, a2dDocumentFlagMask flags )
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;
      
    a2dDocumentTemplate* found = NULL;
    size_t n = 0;
    const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
    {
        a2dDocumentTemplateList::value_type temp = *iter;
        if ( temp->CheckMask( a2dTemplateFlag::EXPORTING ) )
        {
            if ( (description.IsEmpty() && !file.GetExt().IsEmpty() && file.GetExt() == temp->GetDefaultExtension() ) ||
                  temp->GetDescription() == description )
                found  = temp;
            n++;
        }
    }

    a2dPathList path;
    path.Add( wxT(".") );
    wxString foundfile = file.GetFullPath();
    if ( !path.ExpandPath( foundfile ) )
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), file.GetFullPath().c_str(),foundfile.c_str() ); 
        return false;
    }

    // let the user choose a template and file if not found
    return doc->Export( found, foundfile, flags );
}

bool a2dDocumentCommandProcessor::FileImport( const wxFileName& file, const wxString& description, a2dDocumentFlagMask flags )
{
    a2dDocument *doc = GetCurrentDocument();
    if (!doc)
        return false;

    a2dDocumentTemplate* found = NULL;
    size_t n = 0;
    const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
    {
        a2dDocumentTemplateList::value_type temp = *iter;
        if ( temp->CheckMask( a2dTemplateFlag::IMPORTING ) )
        {
            if ( (description.IsEmpty() && !file.GetExt().IsEmpty() && file.GetExt() == temp->GetDefaultExtension() ) ||
                  temp->GetDescription() == description )
                found  = temp;
            n++;
        }
    }

    a2dPathList path;
    path.Add( wxT(".") );
    wxString foundfile = file.GetFullPath();
    if ( !path.ExpandPath( foundfile ) )
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), file.GetFullPath().c_str(),foundfile.c_str() ); 
        return false;
    }

    // let the user choose a template and file if not found
    return doc->Import( found, foundfile, flags );
}


bool a2dDocumentCommandProcessor::Print( a2dCommand* command )
{
#if wxUSE_PRINTING_ARCHITECTURE
    a2dView *view = GetCurrentView();
    if (!view)
        return false;

    wxPageSetupData* aPageSetupData = NULL;
    if (view && view->GetViewTemplate())
        aPageSetupData = view->GetViewTemplate()->GetPageSetupData();
    if(!aPageSetupData)
    {
        a2dDocument *aDoc = GetCurrentDocument();
        if (aDoc && aDoc->GetDocumentTemplate())
            aPageSetupData = aDoc->GetDocumentTemplate()->GetPageSetupData();
    }
    if(!aPageSetupData)
        aPageSetupData = GetPageSetupData();

    wxPrintDialogData printDialogData( aPageSetupData->GetPrintData());

    wxPrintout *printout = view->OnCreatePrintout( command );
    if (printout)
    {
        wxPrinter printer(&printDialogData);
        if(printer.Print( view->GetDisplayWindow(), printout, true))
            aPageSetupData->SetPrintData(printer.GetPrintDialogData().GetPrintData());

        delete printout;
    }
#endif // wxUSE_PRINTING_ARCHITECTURE
    return true;
}

bool a2dDocumentCommandProcessor::Preview( a2dCommand* command )
{
#if wxUSE_PRINTING_ARCHITECTURE
    a2dView *view = GetCurrentView();
    if (!view)
        return false;
    wxPageSetupData* aPageSetupData = NULL;
    if (view && view->GetViewTemplate())
        aPageSetupData = view->GetViewTemplate()->GetPageSetupData();
    if(!aPageSetupData)
    {
        a2dDocument *aDoc = GetCurrentDocument();
        if (aDoc && aDoc->GetDocumentTemplate())
            aPageSetupData = aDoc->GetDocumentTemplate()->GetPageSetupData();
    }
    if(!aPageSetupData)
        aPageSetupData = GetPageSetupData();

    wxPrintDialogData printDialogData(aPageSetupData->GetPrintData());

    wxPrintout *printout = view->OnCreatePrintout( command );
    if (printout)
    {
        // Pass two printout objects: for preview, and possible printing.
        wxPrintPreviewBase *preview = (wxPrintPreviewBase *) NULL;
        preview = new wxPrintPreview(printout, view->OnCreatePrintout( command ), &printDialogData);
        if ( !preview->Ok() )
        {
            delete preview;
            wxMessageBox( _("Sorry, print preview needs a printer to be installed.") );
            return false;
        }

        wxPreviewFrame *frame = new wxPreviewFrame(preview, (wxFrame *)wxTheApp->GetTopWindow(), _("Print Preview"),
                wxPoint(100, 100), wxSize(600, 650));
        frame->Centre(wxBOTH);
        frame->Initialize();
        frame->Show(true);
    }
#endif // wxUSE_PRINTING_ARCHITECTURE
    return true;
}

bool a2dDocumentCommandProcessor::PrintSetup( a2dCommand* command )
{
#if wxUSE_PRINTING_ARCHITECTURE
    wxPageSetupData* aPageSetupData = NULL;
    a2dView *view = GetCurrentView();
    if (view && view->GetViewTemplate())
        aPageSetupData = view->GetViewTemplate()->GetPageSetupData();
    if(!aPageSetupData)
    {
        a2dDocument *aDoc = GetCurrentDocument();
        if (aDoc && aDoc->GetDocumentTemplate())
            aPageSetupData = aDoc->GetDocumentTemplate()->GetPageSetupData();
    }
    if(!aPageSetupData)
        aPageSetupData = GetPageSetupData();

    wxPageSetupDialog pageSetupDialog((wxFrame *)wxTheApp->GetTopWindow(), aPageSetupData);
    pageSetupDialog.ShowModal();
    *aPageSetupData = pageSetupDialog.GetPageSetupData();
#endif // wxUSE_PRINTING_ARCHITECTURE
    return true;
}


a2dView *a2dDocumentCommandProcessor::GetCurrentView() const
{
    return m_currentView;
}

a2dView *a2dDocumentCommandProcessor::GetLastView() const
{
    return m_lastView;
}

void a2dDocumentCommandProcessor::OnCannotOpenDocument( a2dCommandEvent& event )
{
    a2dDocument* newDoc = event.GetDocument();
    newDoc->DisConnectAllViews();
    newDoc->DeleteContents();
    a2dDocviewGlobals->ReportError( a2dError_FileCouldNotOpen, _("File could not be opened , a2dDocumentCommandProcessor::OnCannotOpenDocument") ); 
}

a2dError a2dDocumentCommandProcessor::CreateDocuments(const wxString& path, a2dDocumentFlagMask documentflags, 
                                                          a2dDocumentTemplate* wantedDocTemplate,
                                                          int dialogflags,
                                                          a2dTemplateFlagMask docTemplateFlags
                                                          )
{
    // remember last used template
    static a2dDocumentTemplate* lastSelectedDocTemplate = NULL;
    size_t n = 0;
    if ( !wantedDocTemplate )
    {
        // check is there is only one template visible, meaning we do not have to choose one. 
        const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if ( temp->CheckMask( docTemplateFlags ) )
            {
                if (n == 0)
                    wantedDocTemplate = temp;
                n ++;
            }
        }

        if (n == 0)
        {   
            return a2dError_NoDocTemplateRef;
        }
    }
    else 
        n = 1; 

    //in an application with only one view and document,
    //the application wants to close ( and save ) the document when creating a new document.
    //so call Close to generate a a2dCloseDocumentEvent.
    //In such a case m_maxDocsOpen should be one.

    // If we've reached the max number of docs, close the
    // first one.
    if ( m_docs.size() >= m_maxDocsOpen)
    {
        a2dDECLARE_LOCAL_ITEM(a2dDocumentList::value_type, doc, m_docs.front());
        //The handler that intercepts EVT_CLOSE_DOCUMENT must decide to Save and/or Empty the document
        if ( doc->Close( false ) )
        {
            doc->DisConnectAllViews();
            RemoveDocument( doc );
        }
        else
        {   //clean up
            return a2dError_ToManyOpen;
        }
    }

    // New document: user chooses a template, unless there's only one or one was given as input.
    if ( documentflags & a2dREFDOC_NEW )
    {
        a2dDocumentTemplate *fileTemplate = (a2dDocumentTemplate *) NULL;
        if (n == 1)
            fileTemplate = wantedDocTemplate;
        else
            fileTemplate = SelectDocumentType( false, docTemplateFlags ); //choose document template from list of templates

        if (fileTemplate)
        {
            a2dDocumentList openedDocList;
            a2dSmrtPtr< a2dDocument > newDoc = fileTemplate->CreateDocument(path, documentflags);

            // arrived here, the new document is ready for use.  But the document is not loaded or initiated yet.
            // For that the wxEVT_NEW_DOCUMENT will take care.
            if (newDoc)
            {
                a2dDocumentEvent event( wxEVT_NEW_DOCUMENT );
                event.SetEventObject(newDoc);
                newDoc->ProcessEvent( event );

                a2dDocument* ret = fileTemplate->SentPreAddCreatedDocumentEvent( newDoc, documentflags );

                //and only now if the new document is not closed because document data may have bin merged/copied
                //to another already opened document. In that case ret contains that document.
                if ( ret == newDoc && !newDoc->IsClosed() ) // really use this new document?
                {
                    // add the document because every thing is properly set
                    AddDocument( newDoc );
                    fileTemplate->SentPostCreateDocumentEvent( newDoc, documentflags );
                    // add the new document to opened documents list which update all views
                    openedDocList.push_back(newDoc);

                    // arrived here, the new document is ready and its views ( and related windows )
                    // are in place.
                    
                    // now that frames and views are created, set the filename once more, this will generate proper events 
                    // for setting e.g. title of frames
                    newDoc->SetFilename( newDoc->GetFilename(), true );
                    newDoc->SetTitle( newDoc->GetTitle(), true );
                }
            }
            else
            {
                return a2dError_CouldNotCreateDocument;
            }

            a2dDocumentList::iterator iter = openedDocList.begin();
            for( ; iter != openedDocList.end(); iter++ )
            {
                a2dDocument *aDoc = *iter;
                // in the previous often view are created, are existing views
                // are connected, update them now.            
                aDoc->UpdateAllViews();
            }
            return a2dError_NoError;

        }
        else
        {
            return a2dError_NoDocTemplateRef;
        }
    }    

    //Create new documents using the path to the file or by selecting a file or more.
    a2dDocumentTemplate *fileTemplate = (a2dDocumentTemplate *) NULL;

    wxArrayString selectedPaths;

    if (documentflags & a2dREFDOC_SILENT) 
    {   
        if ( n == 1 )
        {
            fileTemplate = wantedDocTemplate;
            selectedPaths.Add( path );
        }
        else
        {
            // find a template which is able to load this file ( use file ext or iohandler of template )
            fileTemplate = FindTemplateForPath(m_docTemplates, path );//File extension or format test to find template
            if( fileTemplate )  
                selectedPaths.Add( path ); // just one file is selected this way.
            else
            {
                return a2dError_NoDocTemplateRef;
            }
        }
    }
    else 
    {   
        if ( n == 1 )
        {
            a2dDocumentTemplateList docTemplates;
            docTemplates.push_back( wantedDocTemplate );
            fileTemplate = wantedDocTemplate;
            // selection of one or more files.
            if( a2dError_NoError == SelectDocumentPath(docTemplates, path, documentflags, &selectedPaths, &fileTemplate, dialogflags, docTemplateFlags, lastSelectedDocTemplate ) )
                lastSelectedDocTemplate = fileTemplate;
            else
                return a2dError_Canceled;
        }
        else
        {
            // selection of one or more files.
            if( a2dError_NoError == SelectDocumentPath(m_docTemplates, path, documentflags, &selectedPaths, &fileTemplate, dialogflags, docTemplateFlags, lastSelectedDocTemplate ) )
                lastSelectedDocTemplate = fileTemplate;
            else
                return a2dError_Canceled;
        }
    }

    // the selected files are in selectedPaths
    if (fileTemplate)
    {   
        fileTemplate->SetDirectory( m_lastDirectory );        
        
        // start creating documents + views for all opened files.
        a2dDocumentList openedDocList; // temporary list of document added here, will be used to update its views.
        a2dSmrtPtr< a2dDocument > newDoc;
        for( size_t i=0; i<selectedPaths.GetCount(); i++ )
        {
            newDoc = fileTemplate->CreateDocument(selectedPaths[i], documentflags);

            // arrived here, the new document is ready for use.  But the document is not loaded or initiated yet.
            // For that the wxEVT_OPEN_DOCUMENT will take care.
            if (newDoc)
            {
                a2dDocumentEvent event( wxEVT_OPEN_DOCUMENT );
                event.SetFileName( selectedPaths.Item(i) );
                event.SetEventObject(newDoc);
                if ( !newDoc->ProcessEvent( event ) || !event.IsAllowed() )
                {
                    a2dCommandEvent event( wxEVT_CANNOT_OPEN_DOCUMENT, newDoc );
                    event.SetEventObject(this);
                    a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( event );
                    return a2dError_FileCouldNotOpen;
                }

                a2dDocument* ret = fileTemplate->SentPreAddCreatedDocumentEvent( newDoc, documentflags );

                //and only now if the new document is not closed because document data may have bin merged/copied
                //to another already opened document. In that case ret contains that document.
                if ( ret == newDoc && !newDoc->IsClosed() ) // really use this new document?
                {
                    // add the document because every thing is properly set
                    AddDocument( newDoc );
                    AddFileToHistory( selectedPaths.Item(i), fileTemplate );

                    fileTemplate->SentPostCreateDocumentEvent( newDoc, documentflags );
                    // add the new document to opened documents list which update all views
                    openedDocList.push_back(newDoc);

                    // arrived here, the new document is ready and its views ( and related windows )
                    // are in place. 

                    // now that frames and views are created, set the filename once more, this will generate proper events 
                    // for setting e.g. title of frames
                    newDoc->SetFilename( newDoc->GetFilename(), true );
                    newDoc->SetTitle( newDoc->GetTitle(), true );
                }
            }
            else
            {
                return a2dError_CouldNotCreateDocument;
            }
        }
        a2dDocumentList::iterator iter = openedDocList.begin();
        for( ; iter != openedDocList.end(); iter++ )
        {
            a2dDocument *aDoc = *iter;
            // in the previous often views are created, or existing views are connected, update them now.            
            aDoc->UpdateAllViews();
        }
        
        return a2dError_NoError;
    }

    return a2dError_NoDocTemplateRef;
}

a2dView* a2dDocumentCommandProcessor::AddDocumentCreateView( 
    a2dDocument* newDoc, const wxString& viewTypeName, 
    a2dDocumentFlagMask documentflags, 
    a2dTemplateFlagMask documentTemplateFlags,
    a2dTemplateFlagMask viewTemplateFlags )
{
    AddCreatedDocument( newDoc,  false, false, documentflags, documentTemplateFlags );
    return CreateView( newDoc, viewTypeName, documentflags, viewTemplateFlags );
}

void a2dDocumentCommandProcessor::AddCreatedDocument( a2dDocument* newDoc, 
    bool sentPreAddCreatedDocumentEvent, bool sentPostCreateDocumentEvent,
    a2dDocumentFlagMask documentflags,
    a2dTemplateFlagMask docTemplateFlags )
{
    //search a template for it.
    a2dDocumentTemplate* foundtemplate = 0;

    // in case the template is set already, use it.
    if ( !newDoc->GetDocumentTemplate() )
    {
        const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if ( temp->CheckMask( docTemplateFlags ) )
            {
                if (temp->GetDocumentTypeName() == newDoc->GetDocumentTypeName())
                {
                    foundtemplate = temp;
                    break;
                }
            }
        }
    }

    wxASSERT_MSG( foundtemplate, 
        _("a2dDocumentCommandProcessor::AddCreatedDocument Could not find template for document type name") );

    wxASSERT_MSG( foundtemplate->GetDocumentTypeName() == newDoc->GetDocumentTypeName(),
        _("a2dDocumentCommandProcessor::AddCreatedDocument template DocumentTypeName different from document") );

    if ( !foundtemplate )
        return;

    //in an application with only one view and document,
    //the application wants to close ( and save ) the document when creating a new document.
    //so call Close to generate a a2dCloseDocumentEvent.
    //In such a case m_maxDocsOpen should be one.

    // If we've reached the max number of docs, close the
    // first one.
    if ( m_docs.size() >= m_maxDocsOpen)
    {
        a2dDocument *doc = GetDocuments().front();
        //The handler that intercepts EVT_CLOSE_DOCUMENT must decide to Save and/or Empty the document
        if ( doc->Close( false ) )
        {
            doc->DisConnectAllViews();
            RemoveDocument( doc );
        }
        else
        {   //clean up
            return;
        }
    }

    //instead of the document template generating a new document,
    //here we already have that document, and we set things as if template did create the new document.
    newDoc->SetFilename( wxFileName(wxT("")) );
    newDoc->CreateCommandProcessor();
    newDoc->SetDocumentTypeName( foundtemplate->GetDocumentTypeName() );
    newDoc->SetDocumentTemplate( foundtemplate );
    a2dDocumentEvent event( wxEVT_NEW_DOCUMENT );
    event.SetEventObject(newDoc);
    newDoc->ProcessEvent( event );

    if ( sentPreAddCreatedDocumentEvent )
    {
        foundtemplate->SentPreAddCreatedDocumentEvent( newDoc, documentflags );
    }

    //now add the document because every thing is properly set
    AddDocument( newDoc );

    if ( sentPostCreateDocumentEvent )
    {
        foundtemplate->SentPostCreateDocumentEvent( newDoc, documentflags );

        // in the previous often view are created, are existing views
        // are connected, update them now.            
        newDoc->UpdateAllViews();
    }
}

a2dView *a2dDocumentCommandProcessor::CreateView( a2dDocument *doc, const wxString& viewTypeName, 
                                        a2dDocumentFlagMask flags, a2dTemplateFlagMask viewTemplateFlags )
{
    //let the user/program choose a view from the list
    a2dViewTemplate *temp = SelectViewType( doc, m_viewTemplates, viewTypeName, false, viewTemplateFlags );
    if (temp)
    {
        return temp->CreateView(doc, flags );
    }

    wxASSERT_MSG( viewTypeName.IsEmpty(), _("a2dDocumentCommandProcessor::CreateView could not find template of given type") );

    return (a2dView *) NULL;
}

// Not yet implemented
void a2dDocumentCommandProcessor::ReleaseTemplate(a2dDocumentTemplate* temp, long flags )
{
    a2dSmrtPtrList<a2dDocumentTemplate>::itSmart iter;
    iter = m_docTemplates.Find(temp);
    if ( m_docTemplates.end() !=  iter )
    {
        m_docTemplates.erase( iter );
    }
}

// Not yet implemented
bool a2dDocumentCommandProcessor::FlushDoc(a2dDocument *WXUNUSED(doc))
{
    return false;
}

a2dDocument* a2dDocumentCommandProcessor::GetCurrentDocument() const
{
    if ( m_currentDocument )
        return m_currentDocument;
    else
        return (a2dDocument *) NULL;
}

a2dCommandProcessor* a2dDocumentCommandProcessor::GetCurrentDocumentCommandProcessor() const
{
    if ( !m_currentDocument )
        return false;

    if ( !m_currentDocument->GetCommandProcessor() )
        return false;

    return m_currentDocument->GetCommandProcessor();
}

// Make a default document name
bool a2dDocumentCommandProcessor::MakeDefaultName(wxString& name)
{
    name.Printf(_T("unnamed%d"), m_defaultDocumentNameCounter);
    m_defaultDocumentNameCounter++;

    return true;
}

// Make a frame title (override this to do something different)
// If docName is empty, a document is not currently active.
wxString a2dDocumentCommandProcessor::MakeFrameTitle(a2dDocument* doc, const wxString& modifiedIndicator)
{
    wxString appName = wxTheApp->GetAppName();
    wxString title;
    if (!doc)
        title = appName;
    else
    {
        wxString docName = doc->GetPrintableName();

        if (doc->IsModified()) 
            docName = docName + modifiedIndicator;

        title = docName + wxString(wxT(" - ")) + appName;
    }
    return title;
}


// Not yet implemented
a2dDocumentTemplate *a2dDocumentCommandProcessor::MatchTemplate( const wxString& path )
{
    return FindTemplateForPath(m_docTemplates, path ); //File extension or format test to find template
}

// File history management
void a2dDocumentCommandProcessor::AddFileToHistory(  const wxFileName& file, a2dDocumentTemplate* docTemplate, a2dViewTemplate* viewTemplate )
{
    if (m_fileHistory)
        m_fileHistory->AddFileToHistory( file, docTemplate, viewTemplate );
}

void a2dDocumentCommandProcessor::RemoveFileFromHistory(size_t i)
{
    if (m_fileHistory)
        m_fileHistory->RemoveFileFromHistory(i);
}

wxString a2dDocumentCommandProcessor::GetHistoryFile(size_t i) const
{
    wxString histFile;

    if ( m_fileHistory )
    {
        a2dFileHistoryItem* item = m_fileHistory->GetHistoryFileItem( i );
        if  ( item )
             histFile = item->m_filename.GetFullPath();
    }
    return histFile;
}

a2dFileHistoryItem* a2dDocumentCommandProcessor::GetHistoryFileItem(size_t i) const
{
    if (m_fileHistory)
        return m_fileHistory->GetHistoryFileItem(i);
    return NULL;
}

void a2dDocumentCommandProcessor::FileHistoryUseMenu(wxMenu *menu)
{
    if (m_fileHistory)
        m_fileHistory->UseMenu(menu);
}

void a2dDocumentCommandProcessor::FileHistoryRemoveMenu(wxMenu *menu)
{
    if (m_fileHistory)
        m_fileHistory->RemoveMenu(menu);
}

#if wxUSE_CONFIG
void a2dDocumentCommandProcessor::FileHistoryLoad(wxConfigBase& config)
{
    if (m_fileHistory)
        m_fileHistory->Load(config);
}

void a2dDocumentCommandProcessor::FileHistorySave(wxConfigBase& config)
{
    if (m_fileHistory)
        m_fileHistory->Save(config);
}
#endif

void a2dDocumentCommandProcessor::FileHistoryAddFilesToMenu(wxMenu* menu)
{
    if (m_fileHistory)
        m_fileHistory->AddFilesToMenu(menu);
}

void a2dDocumentCommandProcessor::FileHistoryAddFilesToMenu()
{
    if (m_fileHistory)
        m_fileHistory->AddFilesToMenu();
}

size_t a2dDocumentCommandProcessor::GetHistoryFilesCount() const
{
    if (m_fileHistory)
        return m_fileHistory->GetCount();
    else
        return 0;
}


// Find out the document template via matching in the document file format
// against that of the template
a2dDocumentTemplate *a2dDocumentCommandProcessor::FindTemplateForPath( const a2dDocumentTemplateList& docTemplates, const wxString& path, a2dTemplateFlagMask mask )
{
    a2dDocumentTemplate *theTemplate = (a2dDocumentTemplate *) NULL;

    // Find the template which this extension corresponds to
    const_forEachIn( a2dDocumentTemplateList, &docTemplates )
    {
        a2dDocumentTemplateList::value_type temp = *iter;
        if ( temp->FileMatchesTemplate(path) && temp->CheckMask( mask ) )
        {
            theTemplate = temp;
            break;
        }
    }
    return theTemplate;
}

// Try to get a more suitable parent frame than the top window,
// for selection dialogs. Otherwise you may get an unexpected
// window being activated when a dialog is shown.
wxWindow* wxFindSuitableParent()
{
    wxWindow* parent = wxTheApp->GetTopWindow();

    wxWindow* focusWindow = wxWindow::FindFocus();
    if (focusWindow)
    {
        while (focusWindow &&
                !focusWindow->IsKindOf(CLASSINFO(wxDialog)) &&
                !focusWindow->IsKindOf(CLASSINFO(wxFrame)))

            focusWindow = focusWindow->GetParent();

        if (focusWindow)
            parent = focusWindow;
    }
    return parent;
}

// Prompts user to open one or more files, using file specs in templates.
a2dError a2dDocumentCommandProcessor::SelectDocumentPath( const a2dDocumentTemplateList& docTemplates,
                                                const wxString& path,
                                                a2dDocumentFlagMask WXUNUSED(flags),
                                                wxArrayString* selectedPaths,
                                                a2dDocumentTemplate** chosenTemplate,
                                                int dialogflags,
                                                a2dTemplateFlagMask docTemplateFlags,
                                                const a2dDocumentTemplate* preferedTemplate )
{
    wxString descrBuf;
    int FilterIndex = -1;

    // We can only have multiple filters in Windows and GTK
#if defined(__WXMSW__) || defined(__WXGTK__)

    // search visible filters, and get position of preferred template
    int filterCount = 0;
    const_forEachIn( a2dDocumentTemplateList, &docTemplates )
    {
        a2dDocumentTemplateList::value_type temp = *iter;
        if ( temp->CheckMask( docTemplateFlags ) )
        {
            if(temp == preferedTemplate)
                FilterIndex = filterCount;

            filterCount++;
            // add a '|' to separate this filter from the previous one
            if ( !descrBuf.IsEmpty() )
                descrBuf << wxT('|');

            descrBuf << temp->GetDescription()
                << wxT(" (") << temp->GetFileFilter() << wxT(") |")
                << temp->GetFileFilter();
        }
    }
#else
    descrBuf << wxT("*.*");
#endif

    // if not given a specific directory to open in, use last
    if ( !path.IsEmpty() )
        m_lastDirectory = path;
    else
    {
        // use last directory chosen for this specific type of document.
        if ( preferedTemplate )
            m_lastDirectory = preferedTemplate->GetDirectory();
        //else use m_lastDirectory as it was set the last time here.
    }

    wxWindow* parent = wxFindSuitableParent();

    *chosenTemplate = (a2dDocumentTemplate *)NULL;

    if ( a2dError_Canceled == a2dFileSelectorEx(_("Select a file"), m_lastDirectory, wxT(""),&FilterIndex,
                            descrBuf, dialogflags, parent, selectedPaths) )
        return a2dError_Canceled; // since canceled file dialog
    
    if ( selectedPaths->GetCount() )
    {
        if ( dialogflags & wxFD_OPEN )
        {   // check files for existence 
            for( size_t i=0; i < selectedPaths->GetCount(); i++)
                if( !wxFileExists(selectedPaths->Item(i)) )
                {
                    wxString msgTitle;
                    if (!wxTheApp->GetAppName().IsEmpty())
                        msgTitle = wxTheApp->GetAppName();
                    else
                        msgTitle = wxString(_("File error"));

                    wxString buf;
                    buf.Printf( _("Sorry, could not open the file: %s\n"), selectedPaths->Item(i).c_str() );
                    wxMessageBox( buf , msgTitle, wxOK | wxICON_EXCLAMATION );
                    return a2dError_FileCouldNotOpen;
                }
        }
        m_lastDirectory = wxPathOnly( selectedPaths->Item(0) );

        // first find the template that was choosen in file dialog, if this fails (i.e.
        // wxFileSelectorEx() didn't fill it), then use the path
        if ( FilterIndex != -1 )
        {
            int n = 0;
            const_forEachIn( a2dDocumentTemplateList, &docTemplates )
            {
                a2dDocumentTemplateList::value_type temp = *iter;
                // use same filter as used for descrBuf above.
                if ( temp->CheckMask( docTemplateFlags ) )
                {
                    if ( n == FilterIndex )
                    {
                       *chosenTemplate = temp;
                       break;
                    }
                    // count 'n' here because FilterIndex = filterCount which count if temp->CheckMask( docTemplateFlags )
                    n++;
                }
            }
        }
        // if not found, use the path to find a template
        if ( dialogflags & wxFD_OPEN && !*chosenTemplate )
            *chosenTemplate = FindTemplateForPath( docTemplates, path );

        return a2dError_NoError;
    }
    return a2dError_NoSelection;
}

a2dDocumentTemplate* a2dDocumentCommandProcessor::SelectDocumentType( bool sort, a2dTemplateFlagMask docTemplateFlags )
{
    wxArrayString strings(sort);
    a2dDocumentTemplate **templates = new a2dDocumentTemplate *[m_docTemplates.size()];
    int n = 0;
        
    const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
    {
        a2dDocumentTemplateList::value_type temp = *iter;
        if ( temp->CheckMask( docTemplateFlags ) )
        {
            int j;
            bool want = true;
            for (j = 0; j < n; j++)
            {
                //filter out NOT unique document combinations
                if ( temp->GetDocumentTypeName() == templates[j]->GetDocumentTypeName() )
                    want = false;
            }

            if ( want )
            {
                strings.Add(temp->GetDescription());

                templates[n] = temp;
                n ++;
            }
        }
    }  // for
        
    if (sort)
    {
        // Yes, this will be slow, but template lists
        // are typically short.
        int i;
        n = strings.Count();
        for (i = 0; i < n; i++)
        {
            const_forEachIn( a2dDocumentTemplateList, &m_docTemplates )
            {
                a2dDocumentTemplateList::value_type temp = *iter;
                if (strings[i] == temp->GetDescription())
                    templates[i] = temp;
            }
        }
    }

    a2dDocumentTemplate *theTemplate;

    switch ( n )
    {
        case 0:
            // no visible templates, hence nothing to choose from
            theTemplate = NULL;
            break;

        case 1:
            // don't propose the user to choose if he heas no choice
            theTemplate = templates[0];
            break;

        default:
            // propose the user to choose one of several
            theTemplate = (a2dDocumentTemplate *)wxGetSingleChoiceData
                          (
                            _("Select a document template"),
                            _("Templates"),
                            strings,
                            (void **)templates,
                            wxFindSuitableParent()
                          );
    }

    delete[] templates;

    return theTemplate;
}

a2dViewTemplate* a2dDocumentCommandProcessor::SelectViewType( a2dDocument* doc, 
                                                    const a2dViewTemplateList& list, 
                                                    const wxString& viewTypeName, 
                                                    bool sort, 
                                                    a2dTemplateFlagMask mask )
{
    if ( !viewTypeName.IsEmpty() ) 
    {   //a specific view type is asked for, search it and return it.
        const_forEachIn( a2dViewTemplateList, &list )
        {
            a2dViewTemplateList::value_type temp = *iter;
            if ( temp->GetViewTypeName() == viewTypeName )
            {
                return temp;
            }
        }
        return (a2dViewTemplate *)NULL;
    }

    wxArrayString strings;
    a2dViewTemplate **templates = new a2dViewTemplate *[list.size()];

    int n = 0;
     
    //fill new array of templates with wanted views
    const_forEachIn( a2dViewTemplateList, &list )
    {
        a2dViewTemplateList::value_type temp = *iter;
        if ( !temp->GetViewTypeName().empty() && temp->CheckMask( mask ) &&
              temp->GetDocumentTypeName() == doc->GetDocumentTypeName() )
        {
            strings.Add(temp->GetViewTypeName());
            templates[n] = temp;
            n ++;
        }
    }
        
    if (sort)
    {
        strings.Sort();

        // Yes, this will be slow, but template lists
        // are typically short.
        int i;
        n = strings.Count();
        for (i = 0; i < n; i++)
        {
            const_forEachIn( a2dViewTemplateList, &list )
            {
                a2dViewTemplateList::value_type temp = *iter;
                if (strings[i] == temp->GetViewTypeName())
                {
                    templates[i] = temp;
                }
            }
        }
    }

    a2dViewTemplate *theTemplate;

    switch ( n )
    {
        case 0:
            // no visible templates, hence nothing to choose from
            theTemplate = (a2dViewTemplate *)NULL;
            break;

        case 1:
            // don't propose the user to choose if he has no choice
            theTemplate = templates[0];
            break;

        default:
            // propose the user to choose one of several
            theTemplate = (a2dViewTemplate *)wxGetSingleChoiceData
                          (
                          wxString::Format(_("Select a document view for the file %s"), doc->GetFilename().GetFullName().c_str()),
                            _("Views"),
                            strings,
                            (void **)templates,
                            wxFindSuitableParent()
                          );

    }

    delete[] templates;
    return theTemplate;
}

void a2dDocumentCommandProcessor::AssociateDocTemplate( a2dDocumentTemplate *temp )
{
    if ( m_docTemplates.end() == m_docTemplates.Find(temp))
    {
        m_docTemplates.push_back(temp);
    }
}

void a2dDocumentCommandProcessor::DisassociateDocTemplate( a2dDocumentTemplate *temp )
{
    m_docTemplates.ReleaseObject(temp);
}

void a2dDocumentCommandProcessor::AssociateViewTemplate( a2dViewTemplate *temp )
{
    if ( m_viewTemplates.end() == m_viewTemplates.Find(temp))
    {
        m_viewTemplates.push_back(temp);
    }
}

void a2dDocumentCommandProcessor::DisassociateViewTemplate( a2dViewTemplate *temp )
{
    m_viewTemplates.ReleaseObject(temp);
}

// Add and remove a document from the manager's list
void a2dDocumentCommandProcessor::AddDocument(a2dDocument *doc)
{
    if ( m_docs.end() == m_docs.Find(doc))
    {
        m_docs.push_back( a2dDocumentPtr( doc ) );
        SetCurrentDocument( doc );
        a2dCommandEvent event( wxEVT_ADD_DOCUMENT, doc );
        event.SetEventObject(this);
        a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( event );
    }
    else
        SetCurrentDocument( doc );
}

void a2dDocumentCommandProcessor::RemoveDocument(a2dDocument *doc)
{
    if ( m_currentDocument == doc )
        SetCurrentDocument( (a2dDocument*) NULL );

    if ( m_docs.ReleaseObject(doc) )
    {
        a2dCommandEvent event( wxEVT_REMOVE_DOCUMENT, doc );
        event.SetEventObject(this);
        a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( event );
    }
}

// Views or windows should inform the document manager
// when a view is going in or out of focus
void a2dDocumentCommandProcessor::SetActiveView( a2dView* view )
{
    // SetActiveView() disables the current active view here, but in that event we are not
    // interested.
    static bool recur = false;
    if ( recur )
        return;
    recur = true;

    //deactivate the current view if different from the new one.
    if ( m_currentView && !m_currentView->IsClosed() && m_currentView != view && m_currentView->GetActive()  )
    {
        m_currentView->Activate( false );
    }

    m_currentView = view;

    if ( m_currentView )
    {
        SetCurrentDocument( m_currentView->GetDocument() );
        m_lastView = m_currentView;
    }

    recur = false;
}

void a2dDocumentCommandProcessor::CheckCurrentLastView( a2dView* view )
{
    if(!view)
    {
        m_currentView = NULL;
        m_lastView = NULL;
    }
    else
    {
        if(m_currentView == view)
            m_currentView = NULL;
        if(m_lastView == view)
            m_lastView = NULL;
    }
}

void a2dDocumentCommandProcessor::SetCurrentDocument( a2dDocument* document ) 
{ 
    bool changed = m_currentDocument != document;
    //wxLogDebug("Proc %p Doc old %p new  %p\n", this, m_currentDocument, document );

    m_currentDocument = document; 
    // KLAAS next changed, since this function should do what it says.
    // sent changed current document event only if it is NULL or added to a2dDocumentCommandProcessor
    // if ( !document || m_docs.end() != m_docs.Find(document))
    if ( !document || changed )
    {
        if ( changed )
        {
            a2dCommandEvent event( wxEVT_CHANGED_DOCUMENT, m_currentDocument );
            event.SetEventObject(this);
            a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( event );
        }
    }
}

void a2dDocumentCommandProcessor::OnUndo(wxCommandEvent& WXUNUSED(event))
{
    Undo();
}

void a2dDocumentCommandProcessor::OnRedo(wxCommandEvent& WXUNUSED(event))
{
    Redo();
}

// Handlers for UI update commands

void a2dDocumentCommandProcessor::OnUpdateFileOpen(wxUpdateUIEvent& event)
{
    event.Enable( true );
}

void a2dDocumentCommandProcessor::OnUpdateFileClose(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc != (a2dDocument*) NULL) );
}

void a2dDocumentCommandProcessor::OnUpdateFileRevert(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc != (a2dDocument*) NULL) );
}

void a2dDocumentCommandProcessor::OnUpdateFileNew(wxUpdateUIEvent& event)
{
    event.Enable( true );
}

void a2dDocumentCommandProcessor::OnUpdateFileSave(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( doc && doc->IsModified() );
}

void a2dDocumentCommandProcessor::OnUpdateFileSaveAs(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc != (a2dDocument*) NULL) );
}

void a2dDocumentCommandProcessor::OnUpdateUndo(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc && doc->GetCommandProcessor() && doc->GetCommandProcessor()->CanUndo()) );
}

void a2dDocumentCommandProcessor::OnUpdateRedo(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc && doc->GetCommandProcessor() && doc->GetCommandProcessor()->CanRedo()) );
}

void a2dDocumentCommandProcessor::OnUpdatePrint(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc != (a2dDocument*) NULL) );
}

void a2dDocumentCommandProcessor::OnUpdatePreview(wxUpdateUIEvent& event)
{
    a2dDocument *doc = GetCurrentDocument();
    event.Enable( (doc != (a2dDocument*) NULL) );
}

// Views or windows should inform the document manager
// when a view is going in or out of focus
void a2dDocumentCommandProcessor::OnActivateView( a2dViewEvent& viewevent )
{
    a2dView* view = (a2dView*) viewevent.GetEventObject();
    SetActiveView( viewevent.GetActive() ? view : NULL );
}

//It works when a2dView::SetDocument() executing
void a2dDocumentCommandProcessor::OnAddView( a2dDocumentEvent& docevent )
{
    a2dView* view = (a2dView*) docevent.GetEventObject();
    if(docevent.GetEnable())
        SetActiveView( view );
}

void a2dDocumentCommandProcessor::OnRemoveView( a2dDocumentEvent& viewevent )
{
    a2dView* view = (a2dView*) viewevent.GetEventObject();


    if ( view == m_lastView )
        m_lastView = NULL;
    if ( view == m_currentView )
        m_currentView = NULL;
}

bool a2dDocumentCommandProcessor::ProcessEvent(wxEvent& event)
{
/* klion: all it is not need for wxDocview, it was my mistake
          because from a2dCommandProcessor::SetMenuStrings we can't check for a2dCommandProcessorEvent
          so menus wrong update
    static wxEvent* lastProcessedEvent = NULL; // for any events
    static int  lastProcessedEventId = -1;     // for wxIdleEvent and wxUpdateUIEvent
    static bool lastProcessedRetCode = false;  // return code last event
    static long lastProcessedEventTimeStamp = -1; // for a2d...Events
    static wxObject* lastProcessedEventObject = NULL; // for any wxWidgets events (menu toolbars)
    static wxEventType lastProcessedEventType = wxEVT_NULL;
    
    if(&event != lastProcessedEvent || lastProcessedEventId != event.GetId() 
    || lastProcessedEventObject != event.GetEventObject() || lastProcessedEventType != event.GetEventType()
    || lastProcessedEventTimeStamp != event.GetTimestamp())
    {
//        if(event.GetEventType() != wxEVT_UPDATE_UI) {
//            wxLogDebug(wxT("Stack dump:\n%s"), a2dGetStackTrace(1, true, 20, 10).c_str());
        lastProcessedRetCode = a2dCommandProcessor::ProcessEvent(event);
        lastProcessedEventId = event.GetId();
        lastProcessedEvent = &event;
        lastProcessedEventObject = event.GetEventObject();
        lastProcessedEventType = event.GetEventType();
        lastProcessedEventTimeStamp = event.GetTimestamp();
    }
    else
    {
//        wxLogDebug(wxT("Stack dump:\n%s"), a2dGetStackTrace(1, true, 20, 10).c_str());
    }
    return lastProcessedRetCode;
*/
    return a2dCommandProcessor::ProcessEvent(event);
}

// ----------------------------------------------------------------------------
// a2dDocviewGlobal
// ----------------------------------------------------------------------------

//! a global pointer to get to global instance of important classes.
a2dDocviewGlobal* a2dDocviewGlobals = NULL;

a2dDocviewGlobal::a2dDocviewGlobal()
{
    m_docviewCommandProcessor = new a2dDocumentCommandProcessor();
    m_docviewEventDistributer->Register( m_docviewCommandProcessor );

    m_showlog = true;
}

void a2dDocviewGlobal::SetDocviewCommandProcessor( a2dDocumentCommandProcessor* docviewCommandProcessor ) 
{ 
    if ( m_docviewCommandProcessor )
        m_docviewEventDistributer->Unregister( m_docviewCommandProcessor );
    
    docviewCommandProcessor->CheckCurrentLastView( NULL );
    m_docviewCommandProcessor = docviewCommandProcessor; 
    m_docviewEventDistributer->Register( m_docviewCommandProcessor );
}

a2dDocviewGlobal::~a2dDocviewGlobal()
{
}

void a2dDocviewGlobal::RecordF( wxObject* sender, const wxChar* Format, ... )
{
    va_list ap;

    wxString recordstring;
    va_start( ap, Format );

    //Format.Replace( wxT("%f"), wxT("%6.3f") );   

    recordstring.PrintfV( Format, ap );
    va_end( ap );

    a2dCommandEvent event( recordstring );
    event.SetEventObject( sender );

    GetEventDistributer()->ProcessEvent( event );
}

void a2dDocviewGlobal::RecordF( const wxChar* Format, ... )
{
    va_list ap;

    wxString recordstring;
    va_start( ap, Format );

    //Format.Replace( wxT("%f"), wxT("%6.3f") );   

    recordstring.PrintfV( Format, ap );
    va_end( ap );

    a2dCommandEvent event( recordstring );
    event.SetEventObject( this );

    GetEventDistributer()->ProcessEvent( event );
}

// ----------------------------------------------------------------------------
// a2dFileHistory
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(a2dFileHistory, wxObject)

// ----------------------------------------------------------------------------
// local constants
// ----------------------------------------------------------------------------

static const wxChar *s_MRUEntryFormat = wxT("&%lu %s");


static inline wxChar* MYcopystring(const wxString& s)
{
    wxChar* copy = new wxChar[s.length() + 1];
    return wxStrcpy(copy, s.c_str());
}

static inline wxChar* MYcopystring(const wxChar* s)
{
    wxChar* copy = new wxChar[wxStrlen(s) + 1];
    return wxStrcpy(copy, s);
}

a2dFileHistory::a2dFileHistory(size_t maxFiles, wxWindowID idBase)
{
    m_fileMaxFiles = maxFiles;
    m_idBase = idBase;
}

a2dFileHistory::~a2dFileHistory()
{
}

// File history management
void a2dFileHistory::AddFileToHistory(  const wxFileName& file, a2dDocumentTemplate* docTemplate, a2dViewTemplate* viewTemplate )
{
    a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
    size_t i = 0;
    for( ; iter != m_fileHistoryList.end(); iter++ )
    {
        a2dFileHistoryItemPtr fileitem = *iter;
        if ( fileitem->m_filename == file )
        {
            // we do have it, move it to the top of the history
            RemoveFileFromHistory (i);
            //recursive call, but item is laready removed, so size-1 now.
            AddFileToHistory( file, docTemplate, viewTemplate );
            return;
        }
        i++;
    }

    // if we already have a full history, delete the one at the end
    if ( m_fileMaxFiles == m_fileHistoryList.size() )
    {
        RemoveFileFromHistory ( m_fileHistoryList.size() - 1);
        AddFileToHistory( file, docTemplate, viewTemplate );
        return;
    }

    // Add to the project file history:
    // Move existing files (if any) down so we can insert file at beginning.
    if ( m_fileHistoryList.size() < m_fileMaxFiles)
    {
        wxList::compatibility_iterator node = m_fileMenus.GetFirst();
        while (node)
        {
            wxMenu* menu = (wxMenu*) node->GetData();
            if ( m_fileHistoryList.empty() && menu->GetMenuItemCount() )
            {
                menu->AppendSeparator();
            }
            // fill up with menu set to empty labels, will be set later
            menu->Append( m_idBase + m_fileHistoryList.size(), _("[EMPTY]"));
            node = node->GetNext();
        }
    }
    m_fileHistoryList.push_front( new a2dFileHistoryItem( file, docTemplate, viewTemplate ) );

    // this is the directory of the last opened file
    iter = m_fileHistoryList.begin();
    wxString pathCurrent = (*iter)->m_filename.GetPath();

    //refill menu from list
    i = 0;
    for( ; iter != m_fileHistoryList.end(); iter++ )
    {
        a2dFileHistoryItemPtr fileitem = *iter;

        // if in same directory just show the filename; otherwise the full
        // path
        wxString pathInMenu, path;
        path = fileitem->m_filename.GetPath();
        if ( path == pathCurrent )
            pathInMenu = fileitem->m_filename.GetFullName();
        else
        {
            // absolute path; could also set relative path
            pathInMenu = fileitem->m_filename.GetFullPath();
        }

        // we need to quote '&' characters which are used for mnemonics
        pathInMenu.Replace(_T("&"), _T("&&"));
        wxString buf;
        buf.Printf(s_MRUEntryFormat, i + 1, pathInMenu.c_str() );
        wxList::compatibility_iterator node = m_fileMenus.GetFirst();
        while (node)
        {
            wxMenu* menu = (wxMenu*) node->GetData();
            menu->SetLabel(m_idBase + i, buf);
            node = node->GetNext();
        }
        i++;
    }
}

void a2dFileHistory::RemoveFileFromHistory(size_t i)
{
    wxCHECK_RET( i < m_fileHistoryList.size(),
                 wxT("invalid index in a2dFileHistory::RemoveFileFromHistory") );

    // delete the element from the list 
    a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
    size_t j = 0;
    for( ; iter != m_fileHistoryList.end(); iter++ )
    {
        a2dFileHistoryItemPtr fileitem = *iter;
        if ( j == i )
        {
            m_fileHistoryList.erase( iter );
            break;
        }
        j++;
    }

    wxList::compatibility_iterator node = m_fileMenus.GetFirst();
    while ( node )
    {
        wxMenu* menu = (wxMenu*) node->GetData();

        // re-fill menu labels
        wxString buf;
        a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
        size_t j = 0;
        for( ; iter != m_fileHistoryList.end(); iter++ )
        {
            a2dFileHistoryItemPtr fileitem = *iter;
            buf.Printf(s_MRUEntryFormat, j + 1, fileitem->m_filename.GetFullPath().c_str() );
            menu->SetLabel(m_idBase + j, buf);
            j++;
        }

        node = node->GetNext();

        // delete the last menu item which is unused now
        wxWindowID lastItemId = m_idBase + wx_truncate_cast(wxWindowID, m_fileHistoryList.size());
        if (menu->FindItem(lastItemId))
        {
            menu->Delete(lastItemId);
        }

        // delete the last separator too if no more files are left
        if ( m_fileHistoryList.empty() )
        {
            wxMenuItemList::compatibility_iterator nodeLast = menu->GetMenuItems().GetLast();
            if ( nodeLast )
            {
                wxMenuItem *menuItem = nodeLast->GetData();
                if ( menuItem->IsSeparator() )
                {
                    menu->Delete(menuItem);
                }
                //else: should we search backwards for the last separator?
            }
            //else: menu is empty somehow
        }
    }
}

wxString a2dFileHistory::GetHistoryFile(size_t i) const
{
    wxString s;
    if ( i < m_fileHistoryList.size() )
    {
        a2dFileHistoryItemList::const_iterator iter = m_fileHistoryList.item( i );    
        a2dFileHistoryItemPtr fileitem = *iter;
        s = fileitem->m_filename.GetFullPath();
    }
    else
        wxFAIL_MSG( wxT("bad index in a2dFileHistory::GetHistoryFile") );
    return s;
}

a2dFileHistoryItem* a2dFileHistory::GetHistoryFileItem(size_t i) const
{
    wxString s;
    if ( i < m_fileHistoryList.size() )
    {
        a2dFileHistoryItemList::const_iterator iter = m_fileHistoryList.item( i );    
        return *iter;
    }
    else
        wxFAIL_MSG( wxT("bad index in a2dFileHistory::GetHistoryFile") );
    return NULL;
}

void a2dFileHistory::UseMenu(wxMenu *menu)
{
    if (!m_fileMenus.Member(menu))
        m_fileMenus.Append(menu);
}

void a2dFileHistory::RemoveMenu(wxMenu *menu)
{
    m_fileMenus.DeleteObject(menu);
}

#if wxUSE_CONFIG
void a2dFileHistory::Load(wxConfigBase& config)
{
    wxString buf;
    buf.Printf(wxT("file%d"), 1 );
    wxString historyFile;
    while (( m_fileHistoryList.size() < m_fileMaxFiles) && config.Read(buf, &historyFile) && (!historyFile.empty()))
    {
        m_fileHistoryList.push_back(  new a2dFileHistoryItem( wxFileName( historyFile ), NULL, NULL ) );
        buf.Printf(wxT("file%d"), (int)m_fileHistoryList.size()+1);
        historyFile = wxEmptyString;
    }
    AddFilesToMenu();
}

void a2dFileHistory::Save(wxConfigBase& config)
{
    a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
    size_t j = 0;
    for( ; iter != m_fileHistoryList.end(); iter++ )
    {
        a2dFileHistoryItemPtr fileitem = *iter;
        wxString buf;
        buf.Printf(wxT("file%d"), (int)j+1);
        if ( j < m_fileHistoryList.size() )
            config.Write( buf, fileitem->m_filename.GetFullPath() );
        else
            config.Write(buf, wxEmptyString);
        j++;    
    }
}
#endif // wxUSE_CONFIG

void a2dFileHistory::AddFilesToMenu()
{
    if ( !m_fileHistoryList.empty() )
    {
        wxList::compatibility_iterator node = m_fileMenus.GetFirst();
        while (node)
        {
            wxMenu* menu = (wxMenu*) node->GetData();
            if (menu->GetMenuItemCount())
            {
                menu->AppendSeparator();
            }

            a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
            size_t i = 0;
            for( ; iter != m_fileHistoryList.end(); iter++ )
            {
                a2dFileHistoryItemPtr fileitem = *iter;
                wxString buf;
                buf.Printf(s_MRUEntryFormat, i+1, fileitem->m_filename.GetFullPath().c_str() );
                menu->Append(m_idBase+i, buf);
                i++;
            }
            node = node->GetNext();
        }
    }
}

void a2dFileHistory::AddFilesToMenu(wxMenu* menu)
{
    if ( !m_fileHistoryList.empty() )
    {
        if (menu->GetMenuItemCount())
        {
            menu->AppendSeparator();
        }

        a2dFileHistoryItemList::iterator iter = m_fileHistoryList.begin();
        size_t i = 0;
        for( ; iter != m_fileHistoryList.end(); iter++ )
        {
            a2dFileHistoryItemPtr fileitem = *iter;
            wxString buf;
            buf.Printf(s_MRUEntryFormat, i+1, fileitem->m_filename.GetFullPath().c_str() );
            menu->Append(m_idBase+i, buf);
            i++;
        }
    }
}


// ----------------------------------------------------------------------------
// a2dDocviewModule
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(a2dDocviewModule, wxModule)

bool a2dDocviewModule::OnInit()
{
#if wxUSE_PRINTING_ARCHITECTURE
    if(wxThePrintPaperDatabase == NULL)
    {
        wxThePrintPaperDatabase = new wxPrintPaperDatabase;
        wxThePrintPaperDatabase->CreateDatabase();
        m_wxThePrintPaperDatabase = wxThePrintPaperDatabase;
    }
#endif
    a2dDocviewGlobals = new a2dDocviewGlobal();
    wxNullRefObjectList = new a2dObjectList();

    return true;
}

void a2dDocviewModule::OnExit()
{
    delete wxNullRefObjectList;
    delete a2dDocviewGlobals;
    a2dDocviewGlobals = NULL;
#if wxUSE_PRINTING_ARCHITECTURE
    if(m_wxThePrintPaperDatabase && m_wxThePrintPaperDatabase != wxThePrintPaperDatabase)
        delete m_wxThePrintPaperDatabase;
    m_wxThePrintPaperDatabase = NULL;
#endif
}

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