candoc.cpp

Go to the documentation of this file.

/*! \file canvas/src/candoc.cpp
    \author Klaas Holwerda

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: candoc.cpp,v 1.190 2009/09/02 19:46:07 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include <wx/wfstream.h>
#include <math.h>
#include <wx/tokenzr.h>
#include <locale.h>


#if wxUSE_STD_IOSTREAM
  #include "wx/ioswrap.h"
  #if wxUSE_IOSTREAMH
    #include <fstream.h>
  #else
    #include <fstream>
  #endif
#else
  #include "wx/wfstream.h"
#endif


#include "wx/canvas/candoc.h"
#include "wx/canvas/cancom.h"

#include "wx/canvas/xmlpars.h"
#include "wx/canvas/drawer.h"
#include "wx/canvas/canglob.h"
#include "wx/canvas/algos.h"

#if defined(__WXMSW__) && defined(__MEMDEBUG__)
#include <wx/msw/msvcrt.h>
#endif

//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// a2dCanvasDocument
//----------------------------------------------------------------------------

DEFINE_EVENT_TYPE( a2dCanvasDocument::sm_layersetupChanged )

IMPLEMENT_DYNAMIC_CLASS(a2dCanvasDocument, a2dDocument)

A2D_BEGIN_EVENT_TABLE( a2dCanvasDocument, a2dDocument )
    A2D_EVT_IDLE( a2dCanvasDocument::OnIdle )
    A2D_EVT_OPEN_DOCUMENT( a2dCanvasDocument::OnOpenDocument )
A2D_END_EVENT_TABLE()

a2dCanvasDocument::a2dCanvasDocument(): a2dDocument()
{
    m_rootobject = new a2dCanvasObject();

    m_askSaveWhenOwned = false;

    m_layersetup = (a2dLayers*) a2dCanvasGlobals->GetLayerSetup()->Clone( clone_deep );

    m_rootobject->SetCanvasDocument( this );

    m_ignorePendingObjects = false;
    m_updatespending = false;

    m_units_accuracy = 0.001;
    m_units_scale = 1.0;
    m_normalize_scale = 1.0;

    m_units = wxT("non");
    m_units_measure = wxT("non");

    m_initialSizeX = 100;
    m_initialSizeY = 100;

    m_description = wxT("a2dCanvasDocument generated by wxArt2D");
    m_libraryname = wxT("Not specified");

    m_modificationtime = wxDateTime::Now();
    m_accesstime = wxDateTime::Now();
    m_changedInternalAccesstime = wxDateTime::Now();

    m_documentTypeName = wxT("a2dCanvasDocument");

    m_multiRoot = false;
}

a2dCanvasDocument::a2dCanvasDocument( const a2dCanvasDocument &other)
    :a2dDocument( other )
{
    if ( other.m_rootobject )
    {
        m_rootobject = other.m_rootobject->TClone( clone_deep );
        m_rootobject->SetCanvasDocument( this );
    }
    if ( other.m_layersetup )
    {
        m_layersetup =  (a2dLayers*) other.m_layersetup->Clone( clone_deep );
        m_layersetup->SetCanvasDocument( this );
    }
    m_ignorePendingObjects = false;
    m_updatespending = false;
    m_units_accuracy = other.m_units_accuracy;
    m_units = other.m_units;
    m_units_scale = other.m_units_scale;
    m_normalize_scale = other.m_normalize_scale;
    m_units_measure = other.m_units_measure;
    m_description = other.m_description;
    m_libraryname = other.m_libraryname;
    m_modificationtime = other.m_modificationtime;
    m_accesstime = other.m_accesstime;
    m_documentTypeName = other.m_documentTypeName;
    m_multiRoot = other.m_multiRoot;

    m_initialSizeX = other.m_initialSizeX;
    m_initialSizeY = other.m_initialSizeY;

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in Clone ( )
    CurrentSmartPointerOwner = this;
#endif
}

a2dObject* a2dCanvasDocument::Clone( CloneOptions WXUNUSED(options) ) const
{
    a2dCanvasDocument* a = new a2dCanvasDocument( *this );
    return a;
}

a2dCanvasDocument::~a2dCanvasDocument()
{
    // in case multiple references to an object from outside the document do exist, 
    // they may not use m_root from there, so set it to NULL.
    // For objects on the command stack there is no problem, it is already deleted in a2dDocument.
    if ( m_rootobject )
        m_rootobject->SetCanvasDocument( NULL );
    if ( m_layersetup )
        m_layersetup->SetCanvasDocument( this );
}

//void a2dCanvasDocument::operator delete(void* recordptr)
//{
//  ::delete recordptr;
//}

void a2dCanvasDocument::DeleteContents()
{
    m_rootobject->ReleaseChildObjects();
}

a2dCanvasCommandProcessor* a2dCanvasDocument::GetCanvasCommandProcessor() 
{
    return wxStaticCastNull( GetCommandProcessor(), a2dCanvasCommandProcessor);
}

void a2dCanvasDocument::Update( a2dCanvasObject::UpdateMode mode )
{
    m_layersetup->SetAllLayersAvailable( false );
    //this one always available because editing handles are on it.
    m_layersetup->SetAvailable( wxLAYER_DEFAULT, TRUE );

    m_rootobject->Update( mode );
}

void a2dCanvasDocument::SetRootObject( a2dCanvasObject* newRoot )
{
    wxASSERT_MSG( newRoot, wxT("a2dCanvasDocument its root object can not be NULL") );    
    m_rootobject = newRoot; 
    SetCanvasDocumentRecursive();
}

void a2dCanvasDocument::DependencyPending()
{
    if ( !m_ignorePendingObjects )
    {
        //continue calling DependencyPending until no more new pendingobjects are generated.
        while ( m_updatespending )
        {
            m_updatespending = false;
            a2dWalker_CallMemberFuncW walker;
            walker.Start( m_rootobject, &a2dCanvasObject::DependencyPending );                
        }
        m_updatespending = true;
    }
}

void a2dCanvasDocument::SetUpdatesPending(bool onoff)
{
    if ( !m_ignorePendingObjects )
    {
        m_changedInternalAccesstime = wxDateTime::Now();
        if ( !onoff )
        {
            a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::PENDING );
            setflags.Start( m_rootobject, false );

            // although the layer setup is not displayed directly, and therefore its pending
            // flag is not of interest for that, it still needs a reset.
            setflags.Start( m_layersetup, false );
        }
        m_updatespending=onoff;
    }
}

bool a2dCanvasDocument::GetUpdatesPending()
{
    if ( m_ignorePendingObjects )
        return false;
    return m_updatespending;
}

void a2dCanvasDocument::SetIgnorePendingObjects( bool onoff )
{
    m_ignorePendingObjects = onoff;
}

void a2dCanvasDocument::SetLayerSetup( a2dLayers* layersetup )
{
    m_layersetup = layersetup;
    if ( m_layersetup )
        m_layersetup->SetCanvasDocument( this );

    a2dComEvent changedlayers( this, m_layersetup, &sm_layersetupChanged );
    a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedlayers );
};

void a2dCanvasDocument::SetCanvasDocumentRecursive()
{
    if ( m_rootobject )
        m_rootobject->SetCanvasDocument(this);
    if ( m_layersetup )
        m_layersetup->SetCanvasDocument(this); 

    //since root changed/set again for all objects,
    //the chances are big that layers did change too.
    //trigger to update the layers table settings on layers available
    //before rendering.
    a2dComEvent changedlayers( this, m_layersetup, &a2dCanvasView::sm_changedLayers );
    a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedlayers );
}

void a2dCanvasDocument::OnOpenDocument( a2dDocumentEvent& event )
{
    a2dDocument::OnOpenDocument( event );

    UpdateAllViews( NULL, a2dCANVIEW_UPDATE_ALL );
}

a2dDocumentInputStream& a2dCanvasDocument::LoadObject( a2dDocumentInputStream& stream, a2dIOHandlerStrIn* handler )
{
    // Set the locale to english for this I/O operation
    // !!!! It would be better to set the locale of the stream itself,
    // but this does not work for two reasons:
    // 1. wxWindows streams don't support this
    // 2. CVG-IO uses e.g. wxString::ToDouble, which is independent of the stream
    wxString oldLocale = wxSetlocale( LC_NUMERIC, NULL );
    wxSetlocale( LC_NUMERIC, wxString(wxT("English")) );

    bool ownhandler = false;
    if (! handler )
    {  
#if wxART2D_USE_CVGIO
        //assume it is the default CVG format.
        handler = new a2dIOHandlerCVGIn();
        ownhandler = true;
#else
        a2dDocviewGlobals->ReportErrorF( a2dError_NoDocTemplateRef, _("No template defined in a2dDocument::LoadObject") ); 
#endif //wxART2D_USE_CVGIO
    }

#if wxUSE_STD_IOSTREAM
    bool isOK = (stream.fail() || stream.bad()) == 0;
#else
    bool isOK = stream.IsOk ();
#endif

    bool oke = false;
    if (isOK)
    {
        if ( handler )
        {
            if ( handler->CanLoad( stream, this, m_documentTemplate ? m_documentTemplate->GetDocumentClassInfo(): NULL )  )
            {
                if ( !handler->Load(stream, this) )
                {
                    a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotLoad, _("I/O handler error during loading this format."));
                    m_lastError = a2dError_CouldNotLoad;
                }
                else
                    oke = true;
            }
            else
            {
                a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("I/O handler not capable of loading in this format."));
                m_lastError = a2dError_IOHandler;
            }
        }
        else
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("I/O handler must be != NULL, maybe template I/O handler not available in document template.") ); 
            m_lastError = a2dError_IOHandler;
        }

    
        if ( ownhandler )
            delete handler;
    }
    else
        a2dDocviewGlobals->ReportErrorF( a2dError_ImportObject, _("bad stream"));

    // now we are ready to prepare the document for rendering 
    if ( oke )
    {
        //set this root for all object stored in this root.
        SetCanvasDocumentRecursive();

        Update( a2dCanvasObject::updatemask_force );

        a2dDocumentEvent event( wxEVT_POST_LOAD_DOCUMENT );
        event.SetEventObject( this );
        DistributeEvent( event );
    }
    else
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotLoad, _("bad stream"));
        m_lastError = a2dError_CouldNotLoad;
    }
    
    wxSetlocale( LC_NUMERIC, oldLocale );
    return stream;
}

bool a2dCanvasDocument::Load(const wxString& filename, a2dIOHandlerStrIn* handler )
{
    m_lastError = a2dError_NoError;
#if wxUSE_STD_IOSTREAM
    a2dDocumentFileInputStream stream( filename.mb_str(), wxSTD ios_base::in | wxSTD ios_base::binary );
    if (stream.fail() || stream.bad())
#else
    wxFileInputStream stream( filename );
    if ( !stream.IsOk() )
#endif
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_FileCouldNotOpen, _("Sorry, could not open file %s for loading"), filename.c_str() ); 
        return false;
    }

    if ( handler )
    {
        if ( handler->CanLoad(stream, this, m_documentTemplate ? m_documentTemplate->GetDocumentClassInfo(): NULL )  )
        {
            if ( !handler->Load(stream, this) )
            {
                a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler failed loading from stream.") ); 
                m_lastError = a2dError_CouldNotLoad;
            }
            else
            {
                UpdateAllViews( NULL, a2dCANVIEW_UPDATE_ALL );
                return true;
            }
        }
        else
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler not capable of loading this format.") ); 
            m_lastError = a2dError_IOHandler;
        }
    }
    else
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_LoadObject, _("I/O handler not set in document template.") ); 
        m_lastError = a2dError_NoDocTemplateRef;
    }
    return false;
}

#if wxART2D_USE_CVGIO
void a2dCanvasDocument::Load( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& parser )
{
    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( m_rootobject );
    setp.Start( m_layersetup );

    parser.Next();
    parser.Require( START_TAG, wxT("cvg") );
    parser.Next();
    if ( parser.GetTagName() == wxT("title") )
    {
        m_documentTitle = parser.GetContent();
        parser.Next();
        parser.Require( END_TAG, wxT("title") );
        parser.Next();
    }
    if ( parser.GetTagName() == wxT("desc") )
    {
        m_description = parser.GetContent();
        parser.Next();
        parser.Require( END_TAG, wxT("desc") );
        parser.Next();
    }

    if ( parser.GetTagName() == wxT("o") && parser.GetAttributeValue( wxT("classname") ) == wxT("a2dLayers") )
    {
        if (m_layersetup)
            m_layersetup->ReleaseChildObjects();
        else
        {
            m_layersetup = new a2dLayers();
        }
        m_layersetup->Load( NULL, parser );
        m_layersetup->GetLayerIndex();
    }

    UpdateLoadedLayerSetup();

    if ( parser.GetTagName() == wxT("o") )
        m_rootobject->Load( NULL, parser );

    parser.Require( END_TAG, wxT("cvg") );
}
#endif //wxART2D_USE_CVGIO

bool a2dCanvasDocument::SaveLayers( const wxString& filename )
{
    return m_layersetup->SaveLayers( filename );
}

bool a2dCanvasDocument::LoadLayers( const wxString& filename )
{
    m_lastError = a2dError_NoError;
#if wxUSE_STD_IOSTREAM
    a2dDocumentFileInputStream stream( filename.mb_str(), wxSTD ios_base::in | wxSTD ios_base::binary );
    if (stream.fail() || stream.bad())
#else
    wxFileInputStream stream( filename );
    if ( !stream.Ok() )
#endif
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_LoadLayers, _("Sorry, could not open file %s for loading"), filename.c_str() ); 
        m_lastError = a2dError_LoadLayers;
        return false;
    }

    m_layersetup->SetFileName( filename );
    m_layersetup->ReleaseChildObjects();

    bool done = true;

#if wxART2D_USE_CVGIO
    //layers or in CVG format.
    a2dIOHandlerCVGIn* handler = new a2dIOHandlerCVGIn();

    if ( handler && handler->CanLoad(stream, m_layersetup, NULL )  )
    {
        if ( !handler->LoadLayers(stream, m_layersetup ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_LoadLayers, _("template I/O handler not capable of loading this format."));
            m_lastError = a2dError_LoadLayers;
            done = false;
        }
    }
    else
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_LoadLayers, _("template I/O handler not capable of loading this format."));
        m_lastError = a2dError_LoadLayers;
        done = false;
    }   
#else
    wxFAIL_MSG( wxT("wxART2D_USE_CVGIO is needed to load layers from a file CVG file") );
#endif //wxART2D_USE_CVGIO

#if wxART2D_USE_CVGIO
    delete handler;
#endif //wxART2D_USE_CVGIO
    return done;
}

void a2dCanvasDocument::UpdateLoadedLayerSetup()
{
}

a2dDocumentOutputStream& a2dCanvasDocument::SaveObject(a2dDocumentOutputStream& stream, a2dIOHandlerStrOut* handler )
{
    // Set the locale to english for this I/O operation
    // !!!! It would be better to set the locale of the stream itself,
    // but this does not work for two reasons:
    // 1. wxWindows streams don't support this
    // 2. CVG-IO uses e.g. wxString::ToDouble, which is independent of the stream
    wxString oldLocale = wxSetlocale( LC_NUMERIC, NULL );
    wxSetlocale( LC_NUMERIC, wxString( wxT("English") ) );

#if wxUSE_STD_IOSTREAM
    bool isOK = (stream.fail() || stream.bad()) == 0;
#else
    bool isOK = stream.IsOk ();
#endif

    if (! handler )
    {   
#if wxART2D_USE_CVGIO
        //assume it is the default CVG format.
        handler = new a2dIOHandlerCVGOut();
#else
    wxFAIL_MSG( wxT("wxART2D_USE_CVGIO is needed to load object from a file CVG file") );
#endif //wxART2D_USE_CVGIO
    }

    if (isOK)
    {
        if ( handler )
        {
            if ( handler->CanSave( this )  )
            {
                if ( !handler->Save(stream, this) )
                {
                    a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler error during saving in this format") ); 
                    m_lastError = a2dError_IOHandler;
                }
            }
            else 
            {
                a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler not capable of saving in this format."));
                m_lastError = a2dError_IOHandler;
            }
        }
        else 
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler not set in document template"));
            m_lastError = a2dError_IOHandler;
        }
    }
    else
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_SaveObject,  _("bad stream") );
        m_lastError = a2dError_SaveObject;
    }

    if (! m_documentTemplate )
        delete handler;

    wxSetlocale( LC_NUMERIC, oldLocale );

    return stream;
}

bool a2dCanvasDocument::Save(const wxString& filename, a2dIOHandlerStrOut* handler ) const
{
#if wxUSE_STD_IOSTREAM
    a2dDocumentFileOutputStream stream(filename.mb_str(), wxSTD ios_base::out | wxSTD ios_base::binary );
    if (stream.fail() || stream.bad())
#else
    wxFileOutputStream stream( filename );
    if (stream.GetLastError() != wxSTREAM_NO_ERROR)
#endif
    {
        a2dDocviewGlobals->ReportErrorF( a2dError_SaveFile, _("Sorry, could not open file %s for saving"), filename.c_str() );

        // Saving error
        return false;
    }

    if ( handler )
    {
        if ( handler->CanSave( this )  )
        {
            if ( handler->Save(stream, this) )
                return true;

            a2dDocviewGlobals->ReportErrorF( a2dError_SaveFile, _("template I/O handler not succeeded to save in this format to file %s"), filename.c_str() );
        }
        else 
            a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler not capable of saving in this format."));
    }
    else 
        a2dDocviewGlobals->ReportErrorF( a2dError_IOHandler, _("template I/O handler not set in document template"));
    return false;
}


#if wxART2D_USE_CVGIO
void a2dCanvasDocument::Save( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut &out, a2dObjectList* WXUNUSED(towrite) )
{
    Save( (a2dIOHandlerCVGOut&) out, m_rootobject );
}

void a2dCanvasDocument::Save( a2dIOHandlerCVGOut &out, a2dCanvasObject* start )
{
    //check flag is used for writing once an object which is referenced many times
    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( m_rootobject );
    setp.Start( m_layersetup );

    out.WriteStartDocument( wxT("1.0"), wxT("UTF-8") , true );

    out.WriteStartElementAttributes( wxT("cvg") );
    out.WriteAttribute( wxT("classname"), GetClassInfo()->GetClassName() );
    out.WriteEndAttributes();

    out.WriteElement( wxT("title"), GetPrintableName() );
    out.WriteElement( wxT("desc"), m_description );

    a2dObjectList towritelayer;
    m_layersetup->Save( NULL, out, &towritelayer );

    a2dObjectList towrite;
    if ( start )
        towrite.push_back( start );
    else 
        towrite.push_back( m_rootobject.Get() );

    a2dObjectList::iterator iter = towrite.begin();
    while ( towrite.size() )
    {
        a2dObject *obj = *iter;
        obj->Save( NULL, out, &towrite );
        towrite.erase( iter );
        iter = towrite.begin();
    }

    out.WriteEndElement();
    out.WriteEndDocument();
}

void a2dCanvasDocument::DoSave( a2dIOHandlerCVGOut &out, a2dCanvasObjectList* WXUNUSED(towrite) )
{
    out.WriteEndAttributes();
}
#endif //wxART2D_USE_CVGIO

bool a2dCanvasDocument::WriteSVG( a2dCanvasView* drawer, const wxString& filename, a2dCanvasObject* WXUNUSED(top), double WXUNUSED(Width), double WXUNUSED(Height), wxString unit)
{
    wxASSERT_MSG( drawer, wxT("no a2dCanvasView set for a2dCanvasDocument") );

    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( m_rootobject );
    setp.Start( m_layersetup );

    bool done = false;
#if wxART2D_USE_SVGIO
    a2dIOHandlerSVGOut* handler = new a2dIOHandlerSVGOut();
    a2dIterC ic( drawer );

    handler->SetIterC( ic );

    done = Save( filename, handler );

    delete handler;
#else
    wxFAIL_MSG( wxT("wxART2D_USE_SVGIO is needed to write doc into SVG file") );
#endif //wxART2D_USE_SVGIO

    return done;
}

a2dCanvasObject* a2dCanvasDocument::Find( a2dCanvasObject* obj )
{
    a2dWalker_FindCanvasObject finder( obj );

    if ( finder.Start( m_rootobject ) )
        return obj;
    return NULL;
}

a2dCanvasObject* a2dCanvasDocument::Find(  const wxString& objectname,  const wxString& classname, wxInt64 id )
{
    a2dWalker_CollectCanvasObjects finder( a2dCanvasOFlags::ALL );
    finder.SetObjectName( objectname );
    finder.AddClassName( classname );
    finder.SetUniqueSerializationId( id );
    finder.Start( m_rootobject );

    if ( finder.m_found.size() )
        return finder.m_found.front();
    return NULL;
}

void a2dCanvasDocument::SetSpecificFlags( bool setOrClear, a2dCanvasObjectFlagsMask which, const wxString& classname, a2dCanvasObjectFlagsMask whichobjects )
{
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( which, whichobjects );
    setflags.Start( m_rootobject, setOrClear );
}

void a2dCanvasDocument::OnIdle( wxIdleEvent &event )
{
    if ( AddPendingUpdatesOldNew() )
    {    
        //here we could wait for the a2dCanvasView::OnIdle to do the next,
        //But we are idle so why not now.
        //Still this is here for all views directly while else it may be 
        //distributed in time.
        UpdateAllViews( NULL, a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT );
    }
    else 
        event.Skip();
}

void a2dCanvasDocument::UpdateAllViews( a2dView *sender, unsigned int hint, wxObject *WXUNUSED(objecthint) )
{
    //in case of a2dCANVIEW_UPDATE_ALL, first clear all pending objects, they are not of use any more
    //since all drawers will be updated/redrawn totally, no matter what.
    if ( ( hint & a2dCANVIEW_UPDATE_ALL ) && GetUpdatesPending() )
    {
        a2dDocumentEvent event( wxEVT_UPDATE_VIEWS, (a2dView*) NULL );
        event.SetEventObject(this);
        event.SetUpdateHint( a2dCANVIEW_UPDATE_VIEWDEPENDENT );
        DistributeEvent( event );

        //  only invalid need recalculation so they will be rendered. 
        Update( a2dCanvasObject::updatemask_normal );
        //tell root there or no more pending objects.
        SetUpdatesPending(false);
    }

    // now continue with sending the update event in base class
    a2dDocument::UpdateAllViews(sender, hint, NULL );
}

bool a2dCanvasDocument::AddPendingUpdatesOldNew()
{
    if ( !GetUpdatesPending() )
        return false;

    // if layers are pending by a2dLayers::SetPending(bool pending)
    // we need to redraw all views, and no need for fine tuning.
    if ( m_layersetup  && m_layersetup->GetPending() ) 
    {
        a2dComEvent changedlayers( this, m_layersetup, &sm_layersetupChanged );
        a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedlayers );

        Update( a2dCanvasObject::updatemask_normal ); //update all objects which are pending for an update
        //tell root there or no more pending objects.
        SetUpdatesPending(false);

        UpdateAllViews( NULL, a2dCANVIEW_UPDATE_ALL );


        return true;
    }

    // if a layer info object is pending, all needs to be redrawn
    if ( m_layersetup ) 
    {
        unsigned int j;
        for ( j=0; j< wxMAXLAYER; j++ )
        {
            if ( m_layersetup->GetLayerIndex()[j]->GetPending() )
            {
                Update( a2dCanvasObject::updatemask_normal ); //update all objects which are pending for an update
                //tell root there or no more pending objects.
                SetUpdatesPending(false);

                UpdateAllViews( NULL, a2dCANVIEW_UPDATE_ALL );
                return true;
            }
        }
    }

    DependencyPending();
    
    // inform views (and other user interface objects interested), 
    // that it needs to update itself from the document.
    // Old boundingbox is still intact, and can be used to find update areas of old document state
    a2dDocumentEvent eventPreUpdate( wxEVT_UPDATE_VIEWS, (a2dView*) NULL );
    eventPreUpdate.SetEventObject(this);
    // in the next a2dCANVIEW_UPDATE_VIEWDEPENDENT is not needed, since a view does not change
    // when an canvasobject changes, but the othere way around only.
    eventPreUpdate.SetUpdateHint( a2dCANVIEW_UPDATE_PENDING );
    DistributeEvent( eventPreUpdate );

    Update( a2dCanvasObject::updatemask_normal ); //update all objects which are pending for an update

    // inform views (and other user interface objects interested), 
    // that it needs to update itself from the document.
    // New boundingbox is calculated, and can be used to find update areas of new document state
    // use the new boundingbox of pending objects for update areas
    a2dDocumentEvent eventPostUpdate( wxEVT_UPDATE_VIEWS, (a2dView*) NULL );
    eventPostUpdate.SetEventObject(this);
    eventPostUpdate.SetUpdateHint( a2dCANVIEW_UPDATE_PENDING );
    DistributeEvent( eventPostUpdate );

    //tell root there or no more pending objects.
    SetUpdatesPending(false);

    // all have been processed so all temporary boundingbox properties
    // which are used for mini updates can now be removed.
    // Keep in mind that the Boundingbox of a canvas object and its parents do include those 
    // boundingbox properties also, else those parts would not be rendered ( due to clipping ).
    // Therefore the objects containing those properties need to be recalculated, set them pending.

    a2dWalker_RemovePropertyCandoc removep( a2dCanvasObject::PROPID_BoundingBox );
    removep.SetMakePending( true );
    removep.Start( GetRootObject() );

    return true;
}

void a2dCanvasDocument::Freeze()
{
/*
    a2dDocumentEvent event( wxEVT_FREEZE_VIEWS, sender);
    event.SetEventObject(this);
    event.SetUpdateHint( a2dCANVIEW_UPDATE_PENDING );
    DistributeEvent( event );
*/
}

void a2dCanvasDocument::Thaw(bool WXUNUSED(update) )
{
/*
    a2dDocumentEvent event( wxEVT_THAW_VIEWS, sender);
    event.SetEventObject(this);
    event.SetUpdateHint( a2dCANVIEW_UPDATE_PENDING );
    
    DistributeEvent( event );
*/
}

void a2dCanvasDocument::CreateCommandProcessor()
{
    m_commandProcessor = new a2dCanvasCommandProcessor( this );
}

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