objlist.cpp

Go to the documentation of this file.

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

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: objlist.cpp,v 1.88 2009/05/20 18:42:10 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/objlist.h"
#include "wx/canvas/drawer.h"
#include "wx/canvas/canglob.h"
#include "wx/canvas/algos.h"
#include "wx/general/smrtptr.inl"

#include "wx/general/a2dlist.h"
#include "wx/general/a2dlist.inl"

#include <math.h>
#include <algorithm>

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

// MSVC warning 4660 is quite stupid. It says that the template is already instantiated
// by using it, but it is not fully instantiated as required for a library
#ifdef _MSC_VER
#pragma warning(disable: 4660)
#endif

template class a2dSmrtPtrList<a2dCanvasObject>;

#ifdef _MSC_VER
#pragma warning(default: 4660)
#endif

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

a2dCanvasObjectList *wxNullCanvasObjectList;

bool XYSorter(const a2dCanvasObjectPtr& x, const a2dCanvasObjectPtr& y)
{
    a2dCanvasObject* firstc = wxStaticCast( x.Get(), a2dCanvasObject );
    a2dCanvasObject* secondc = wxStaticCast( y.Get(), a2dCanvasObject );

    if ( firstc->GetPosX() < secondc->GetPosX() )   
        return true;
    if ( firstc->GetPosX() == secondc->GetPosX() )   
        if ( firstc->GetPosY() < secondc->GetPosY() )   
            return true;
    return false;
}

bool XRevYSorter(const a2dCanvasObjectPtr& x, const a2dCanvasObjectPtr& y)
{
    a2dCanvasObject* firstc = wxStaticCast( x.Get(), a2dCanvasObject );
    a2dCanvasObject* secondc = wxStaticCast( y.Get(), a2dCanvasObject );

    if ( firstc->GetPosX() < secondc->GetPosX() )   
        return true;
    if ( firstc->GetPosX() == secondc->GetPosX() )   
        if ( firstc->GetPosY() > secondc->GetPosY() )   
            return true;
    return false;
}

bool YXSorter(const a2dCanvasObjectPtr& x, const a2dCanvasObjectPtr& y)
{
    a2dCanvasObject* firstc = wxStaticCast( x.Get(), a2dCanvasObject );
    a2dCanvasObject* secondc = wxStaticCast( y.Get(), a2dCanvasObject );

    if ( firstc->GetPosY() < secondc->GetPosY() )   
        return true;
    if ( firstc->GetPosY() == secondc->GetPosY() )   
        if ( firstc->GetPosX() < secondc->GetPosX() )   
            return true;
    return false;
}

bool YRevXSorter(const a2dCanvasObjectPtr& x, const a2dCanvasObjectPtr& y)
{
    a2dCanvasObject* firstc = wxStaticCast( x.Get(), a2dCanvasObject );
    a2dCanvasObject* secondc = wxStaticCast( y.Get(), a2dCanvasObject );

    if ( firstc->GetPosY() < secondc->GetPosY() )   
        return true;
    if ( firstc->GetPosY() == secondc->GetPosY() )   
        if ( firstc->GetPosX() > secondc->GetPosX() )   
            return true;
    return false;
}

//----------------------------------------------------------------------------
// a2dCanvasObjectList
//----------------------------------------------------------------------------

a2dCanvasObjectList::a2dCanvasObjectList()
{
}

a2dCanvasObjectList::~a2dCanvasObjectList()
{
}

void a2dCanvasObjectList::SortXY()
{
    s_a2dCanvasObjectSorter = &XYSorter;
    sort();
}

void a2dCanvasObjectList::SortXRevY()
{
    s_a2dCanvasObjectSorter = &XRevYSorter;
    sort();
}

void a2dCanvasObjectList::SortYX()
{
    s_a2dCanvasObjectSorter = &YXSorter;
    sort();
}

void a2dCanvasObjectList::SortYRevX()
{
    s_a2dCanvasObjectSorter = &YRevXSorter;
    sort();
}

void a2dCanvasObjectList::MakeUnique()
{
    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj && obj->GetOwnedBy() > 2)
        {
            *iter = obj->TClone( a2dObject::clone_deep );
        }
        iter++;
    }
}

a2dCanvasObjectList& a2dCanvasObjectList::operator=( const a2dCanvasObjectList& other )
{
    wxASSERT( this != wxNullCanvasObjectList );

    if ( &other == wxNullCanvasObjectList )
        return *this;

    clear();     
    for( a2dCanvasObjectList::const_iterator iter = other.begin(); iter != other.end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        push_back( obj );
    }
    return *this;
}

a2dCanvasObjectList* a2dCanvasObjectList::Clone( a2dObject::CloneOptions options ) const
{
    if ( this == wxNullCanvasObjectList )
        return wxNullCanvasObjectList;
     
    a2dCanvasObjectList* a = new a2dCanvasObjectList();

    for( a2dCanvasObjectList::const_iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        if ( obj && options & a2dObject::clone_childs )
        {
            a2dCanvasObject *objnew=obj->TClone( options );
            a->push_back(objnew);
        }
        else
            a->push_back( obj );
    }

    return a;
}

a2dCanvasObjectList* a2dCanvasObjectList::Clone( a2dCanvasObjectFlagsMask mask, a2dObject::CloneOptions options, a2dlist< long >* objectsIndex, const a2dBoundingBox& bbox ) const
{
    if ( this == wxNullCanvasObjectList )
        return wxNullCanvasObjectList;
     
    a2dCanvasObjectList* a = new a2dCanvasObjectList();
    a2dAffineMatrix tworld; 

    int index = 0;
    for( a2dCanvasObjectList::const_iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( !obj->GetRelease() && obj->CheckMask(mask) )
        {
            bool pass = true;
            if ( bbox.GetValid() )
            {
                a2dBoundingBox tmp;
                tmp.Expand( obj->GetMappedBbox( tworld) );
                if (bbox.Intersect(tmp) != _IN )
                    pass = false;
            }
            if ( pass )
            {
                if ( options & a2dObject::clone_deep )
                {
                    a2dCanvasObject *objnew=obj->TClone( options );
                    a->push_back(objnew);
                }
                else
                    a->push_back( obj );
                if ( objectsIndex )
                    objectsIndex->push_back( index );
            }

        }
        if ( !obj->GetRelease() )
            index++;
    }

    return a;
}

a2dCanvasObjectList* a2dCanvasObjectList::CloneChecked( a2dObject::CloneOptions options, a2dlist< long >* objectsIndex ) const
{
    if ( this == wxNullCanvasObjectList )
        return wxNullCanvasObjectList;
     
    a2dCanvasObjectList* a = new a2dCanvasObjectList();

    int index = 0;
    for( a2dCanvasObjectList::const_iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( !obj->GetRelease() && obj->GetCheck() )
        {
            if ( options & a2dObject::clone_deep )
            {
                a2dCanvasObject *objnew=obj->TClone( options );
                a->push_back(objnew);
            }
            else
                a->push_back( obj );
            if ( objectsIndex )
                objectsIndex->push_back( index );
        }
        if ( !obj->GetRelease() )
            index++;
    }

    return a;
}

bool a2dCanvasObjectList::ChangeLayer( wxUint16 layer, a2dCanvasObjectFlagsMask mask )
{
/*
    a2dCanvasObjectIter myiter = Begin();
    while( myiter != End() )
    {
        a2dCanvasObjectList::value_type obj = *myiter;
        myiter++;
    }
*/
    bool did=false;
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        if ( obj && obj->CheckMask(mask))
        {
            did=true;
            obj->SetLayer(layer);
        }
    }

    return did;
}

int a2dCanvasObjectList::Release(a2dCanvasObjectFlagsMask mask, const wxString& classname, const a2dPropertyId *id, const wxString& name, bool now )
{
    int did = 0;
    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj &&
             (classname.IsEmpty() || obj->GetClassInfo()->GetClassName()==classname ) &&
             ( !id || obj->HasProperty(id) ) &&
             ( name.IsEmpty() || obj->GetName() == name ) &&
             ( obj->CheckMask(mask))
           )
        {
            did++;
            if ( now )
            {
                iter = erase( iter );
            }
            else
            {
                obj->SetRelease( true );
                obj->SetPending( true );
                iter++;
            }
        }
        else
            iter++;
    }

    return did;
}

int a2dCanvasObjectList::Release( a2dCanvasObject* object, bool backwards, bool all, bool now, const a2dPropertyId *id )
{
    int did = 0;
    if ( backwards )
    {
        a2dCanvasObjectList::reverse_iterator iter = rbegin();
        while( iter != rend() )
        {    
            a2dCanvasObject *obj = *iter;
            if ( obj && object == obj && ( !id || obj->HasProperty(id) ) )
            {
                if ( now )
                {
                    iterator it( iter.base() ) ;
                    -- it ;
                    erase( it ) ;
                    iter++;
                    //erase((++iter).base());
                }
                else
                {
                    obj->SetRelease( true );
                    obj->SetPending( true );
                    iter++;
                }
                did++;

                if ( !all )
                    break;            
            }
            else 
                iter++;
        }
    }    
    else
    {
        a2dCanvasObjectList::iterator iter = begin();
        while( iter != end() )
        {    
            a2dCanvasObject *obj = *iter;

            if ( obj && object == obj && ( !id || obj->HasProperty(id) ) )
            {
                if ( now )
                {
                    iter = erase( iter );
                }
                else
                {
                    obj->SetRelease( true );
                    obj->SetPending( true );
                    iter++;
                }
                did++;

                if ( !all )
                    break;
            
            }
            else
                iter++;
        }
    }    

    return did;
}

int a2dCanvasObjectList::Copy( double x, double y, a2dCanvasObjectFlagsMask mask, long target, bool check )
{
    int nr = 0;

    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj && check )
            obj->SetCheck(false);
        if ( obj && obj->CheckMask(mask))
        {
            nr++;
            a2dCanvasObject *objn=obj->TClone( a2dObject::clone_deep | a2dObject::clone_reconnectable );
            push_front(objn);
            objn->Translate(x,y);
            objn->SetPending(true);
            objn->SetSpecificFlags( false, mask );
            if ( check )
                objn->SetCheck(true);
            if ( target != -1 )
                objn->SetLayer( target );
        }
        ++iter;
    }

    for( iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj && obj->CheckMask(mask))
        {
            obj->RestoreConnectionsAfterCloning();
        }
    }

    return nr;
}

int a2dCanvasObjectList::Move( double x, double y, a2dCanvasObjectFlagsMask mask, long target, bool check )
{
    int nr = 0;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        if ( obj && check )
            obj->SetCheck(false);
        if ( obj && obj->CheckMask(mask))
        {
            nr++;
            obj->Translate(x,y);
            if ( check )
                obj->SetCheck(true);
            if ( target != -1 )
                obj->SetLayer( target );
        }
    }

    return nr;
}

int a2dCanvasObjectList::BringToTop( a2dCanvasObjectFlagsMask mask, bool check )
{
    a2dCanvasObjectList toTop;

    int nr = 0;
    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj && check )
            obj->SetCheck(false);
        if ( obj && obj->CheckMask(mask))
        {
            if ( check )
                obj->SetCheck(true);
            toTop.push_back( obj );
            nr++;
            iter = erase( iter );
            obj->SetPending(true);
        }
        else
            iter++;
    }
    iter = toTop.begin();
    while( iter != toTop.end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        push_back( obj );
        iter++;
    }
    return nr;
}

int a2dCanvasObjectList::BringToBack( a2dCanvasObjectFlagsMask mask, bool check )
{
    int nr = 0;
    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type obj = *iter;
        if ( obj && check )
            obj->SetCheck(false);
        if ( obj && obj->CheckMask(mask))
        {
            if ( check )
                obj->SetCheck(true);
            nr++;
            iter = erase( iter );
            insert( begin(), obj );
            obj->SetPending(true);
        }
        else
            iter++;
    }

    return nr;
}

bool a2dCanvasObjectList::SetSpecificFlags( bool setOrClear, a2dCanvasObjectFlagsMask which, 
                                           const wxString& classname,
                                           a2dCanvasObjectFlagsMask whichobjects, 
                                           const a2dBoundingBox& bbox,
                                           const a2dAffineMatrix& tworld )
{
    bool did=false;
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        if ( obj &&
             ( classname.IsEmpty() || obj->GetClassInfo()->GetClassName() == classname ) &&
             obj->CheckMask(whichobjects) )
        {
            if ( bbox.GetValid() )
            {
                a2dBoundingBox tmp;
                tmp.Expand( obj->GetMappedBbox( tworld) );
                if (bbox.Intersect(tmp) == _IN )
                {
                    did=true;
                    obj->SetSpecificFlags( setOrClear, which );
                }
            }
            else
            {
                did=true;
                obj->SetSpecificFlags( setOrClear, which );
            }
        }
    }
    return did;
}

a2dCanvasObject* a2dCanvasObjectList::Find( a2dCanvasObject* obj ) const
{
    a2dCanvasObject* cobj;

    for( const_iterator iter = begin(); iter != end(); ++iter )
    {
        cobj= *iter;
        if ( cobj && obj == cobj )
            return cobj;
    }

    return (a2dCanvasObject*) NULL;
}

a2dCanvasObject* a2dCanvasObjectList::Find( const wxString& objectname, const wxString& classname, a2dCanvasObjectFlagsMask mask, const a2dPropertyId *propid, const wxString& valueAsString, wxUint32 id ) const
{
    a2dCanvasObject* cobj;

    for( const_iterator iter = begin(); iter != end(); ++iter )
    {
        cobj= *iter;

        if ( cobj &&
             ( objectname.IsEmpty() || objectname.Matches( cobj->GetName() ) ) &&
             ( classname.IsEmpty() || cobj->GetClassInfo()->GetClassName() == classname ) &&
             ( id == 0 || cobj->GetUniqueSerializationId() == (int)id ) &&
             ( !propid || cobj->HasProperty( propid, valueAsString ) ) &&
             ( cobj->CheckMask(mask) )
           )
            return cobj;
    }

    return (a2dCanvasObject*) NULL;
}

bool a2dCanvasObjectList::SwitchObjectNamed( const wxString& objectname, a2dCanvasObject* newobject )
{
    a2dCanvasObject* cobj;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;

        if ( cobj && cobj->GetName() == objectname )
        {
            newobject->SetCanvasDocument( cobj->GetCanvasDocument() );
            *iter =  newobject;
            return true;
        }
    }

    return false;
}

bool a2dCanvasObjectList::SetDrawerStyle( const a2dFill& fill, const a2dStroke& stroke, a2dCanvasObjectFlagsMask mask )
{
    bool did=false;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        if ( obj && obj->CheckMask(mask) )
        {
            did=true;
            obj->SetFill( fill );
            obj->SetStroke( stroke );
        }
    }

    return did;
}

void a2dCanvasObjectList::Transform( const a2dAffineMatrix& tworld , const wxString& type, a2dCanvasObjectFlagsMask mask, const a2dPropertyId *id )
{
    a2dCanvasObject* cobj;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;

        if ( cobj &&
             (type.IsEmpty() || cobj->GetClassInfo()->GetClassName()==type ) &&
             ( !id || cobj->HasProperty( id ) ) &&
             (cobj->CheckMask(mask))
           )
        {
            cobj->Transform( tworld );
        }
    }
}

void a2dCanvasObjectList::SetTransform( const a2dAffineMatrix& tworld , const wxString& type, a2dCanvasObjectFlagsMask mask, const a2dPropertyId *id )
{
    a2dCanvasObject* cobj;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;

        if ( cobj &&
             (type.IsEmpty() || cobj->GetClassInfo()->GetClassName()==type ) &&
             ( !id || cobj->HasProperty( id ) ) &&
             (cobj->CheckMask(mask))
           )
        {
            cobj->SetTransformMatrix( tworld );
        }
    }
}

int a2dCanvasObjectList::CollectObjects( a2dCanvasObjectList* total, const wxString& type, a2dCanvasObjectFlagsMask mask, 
                                         const a2dPropertyId *id, 
                                         const a2dBoundingBox& bbox
                                       )
{
    a2dCanvasObject* cobj;
    int count = 0;

    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;

        if ( cobj &&
             !bbox.GetValid() || bbox.Intersect( cobj->GetBbox() ) == _IN )
        {
            if ( (type.IsEmpty() || cobj->GetClassInfo()->GetClassName()==type ) &&
                 ( !id || cobj->HasProperty( id ) ) &&
                 (cobj->CheckMask(mask))
               )
            {
                if ( total && total != wxNullCanvasObjectList )
                    total->push_back(cobj);
                count++;
            }
        }
    }

    return count;
}

int a2dCanvasObjectList::TakeOverTo( a2dCanvasObjectList* total, const wxString& type, a2dCanvasObjectFlagsMask mask, const a2dPropertyId *id )
{
    int count = 0;

    a2dCanvasObjectList::iterator iter = begin();
    while( iter != end() )
    {
        a2dCanvasObjectList::value_type cobj = *iter;

        if ( cobj &&
             (type.IsEmpty() || cobj->GetClassInfo()->GetClassName()==type ) &&
             ( !id || cobj->HasProperty( id ) ) &&
             (cobj->CheckMask(mask))
           )
        {
            if ( total && total != wxNullCanvasObjectList )
            {
                iter = erase( iter );
                total->push_back( cobj );
            }
            else
                iter++;
            count++;
        }
        else
            iter++;
    }

    return count;
}

int a2dCanvasObjectList::TakeOverFrom( a2dCanvasObjectList* total, const wxString& type, a2dCanvasObjectFlagsMask mask, const a2dPropertyId *id )
{
    return total->TakeOverTo( this, type, mask, id );
}

void a2dCanvasObjectList::RestoreConnectionsAfterCloning( a2dCanvasCommandProcessor *cp )
{
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dCanvasObjectList::value_type cobj = *iter;

        if ( cobj )
            cobj->RestoreConnectionsAfterCloning( cp );
    }
}

bool UpdateImmediatePrioritySorter (const a2dCanvasObjectPtr& a, const a2dCanvasObjectPtr& b)
{
    int pa = a2dCanvasObject::PROPID_UpdateImmediatePriority->GetPropertyValue( a.Get() );
    int pb = a2dCanvasObject::PROPID_UpdateImmediatePriority->GetPropertyValue( b.Get() );
    return pa < pb;
}

void a2dCanvasObjectList::UpdateImmediate( bool final, a2dBaseTool *tool, a2dCanvasObject *extra, a2dCanvasObject* parent, a2dCanvasObject::a2dDoUpdateImmediateData *data )
{
    if( empty() )
        return;

    a2dCanvasObject::a2dDoUpdateImmediateData ldata( final, tool, parent );
    if( !data )
        data = &ldata;

    int cnt=0;

    for(;;)
    {
        //wxLogDebug("Update cycle phase %d", data->m_phase);
        int oldphase = data->m_phase;

        if( extra )
        {
            extra->DoUpdateImmediate( data );
        }
    
        for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
        {
            a2dCanvasObject *obj = *iter;
            if ( obj )
                obj->DoUpdateImmediate( data );
        }

        // Check if more phases are requested
        if( !data->m_phaserequest )
            break;

        // Note that this phase was (once) done
        data->m_phasedone |= (1<<data->m_phase);

        // Search for the next phase to execute
        for( data->m_phase=0; ! (data->m_phaserequest & (1<<data->m_phase) ); data->m_phase++ );

        // Clear that phase-request bit
        data->m_phaserequest &= ~ ( 1 << data->m_phase );

        // Is this phase run for the first time ?
        data->m_phase_first = (data->m_phasedone & ( 1 << data->m_phase ) ) == 0;

        // Shall we sort the list by priority ?
        if( data->m_sortbeforenextphase && data->m_phase != oldphase )
        {
            s_a2dCanvasObjectSorter = &UpdateImmediatePrioritySorter;
            sort();
        }

        // max 1000 cycles
        cnt++;
        if( cnt>1000 )
        {
            wxASSERT(0);
            break;
        }
    }

    //wxLogDebug("Update end");
}

void a2dCanvasObjectList::AssertUnique()
{
#ifdef _DEBUG
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        for( a2dCanvasObjectList::iterator iter2 = iter;  (++iter2) != end();  )
        {
            wxASSERT( *iter != *iter2 );
        }
    }
#endif
}

void a2dCanvasObjectList::Insert( size_t before, a2dCanvasObject* obj, bool ignoreReleased )
{
    a2dCanvasObjectList::iterator iter = begin();

    if ( !ignoreReleased && before > size() )
        push_back( obj );
    else
    {
        size_t i;
        for( i = 0; i < before; i++ )
        {
            a2dCanvasObject *obj = *iter;
            if ( ignoreReleased && obj->GetRelease()  )
                i--;
            iter++;
        }
        insert( iter, obj );
    }
    obj->SetPending(true);
}

//----------------------------------------------------------------------------
// a2dCorridor
//----------------------------------------------------------------------------
a2dCorridor::a2dCorridor()
{
}

a2dCorridor::~a2dCorridor()
{
}

a2dCorridor::a2dCorridor( const a2dIterC &ic )
{
    a2dIterCU* iter = ic.m_bottom;
    if ( iter )
    {
        m_relativetransform = ic.m_bottom->GetTransform();
        m_inverseRelativetransform = ic.m_bottom->GetInverseTransform();    
    }
    while ( iter )
    {
        if ( iter->GetObject() )
            push_front( iter->GetObject() );
        iter = iter->GetParent();
    }
    m_capture = ic.GetCanvasView()->GetCaptured();
}

a2dCorridor::a2dCorridor( const a2dCanvasView& view )
{
    a2dWalker_CollectCanvasObjects findcorridor( a2dCanvasOFlags::IsOnCorridorPath ); 
    if ( view.GetShowObject() )
    {
        findcorridor.Start( view.GetShowObject() );
        if( findcorridor.m_found.size() )
        {
            this->TakeOverFrom( &findcorridor.m_found );
        }
        else
            push_back( view.GetShowObject() );
    }

    a2dCanvasObject* cobj;
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;
        if ( cobj )
        {
            m_relativetransform *= cobj->GetTransformMatrix();
        }
    }

    m_inverseRelativetransform = m_relativetransform;
    m_inverseRelativetransform.Invert();
    m_capture = view.GetCaptured();
}

void a2dCorridor::Push( a2dCanvasObject* object )
{
    push_back( object );

    a2dCanvasObject* cobj;
    for( a2dCanvasObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        cobj = *iter;
        if ( cobj )
        {
            m_relativetransform *= cobj->GetTransformMatrix();
        }
    }

    m_inverseRelativetransform = m_relativetransform;
    m_inverseRelativetransform.Invert();
}

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