algos.cpp

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

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: algos.cpp,v 1.4 2009/09/03 20:09:53 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include <math.h>
#include <limits.h>
#include <float.h>

#include <wx/wfstream.h>

#include "wx/canvas/canglob.h"
#include "wx/canvas/algos.h"
#include "wx/canvas/layerinf.h"
#include "wx/canvas/canobj.h"
#include "wx/canvas/canprim.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/cancom.h"
#include "wx/artbase/afmatrix.h"
#include "wx/artbase/drawer2d.h"

//----------------------------------------------------------------------------
// a2dDumpWalker
//----------------------------------------------------------------------------


a2dDumpWalker::a2dDumpWalker()
{
    Initialize();
}

a2dDumpWalker::~a2dDumpWalker()
{
}

void a2dDumpWalker::Initialize()
{
}

bool a2dDumpWalker::Start( a2dObject* object )
{
    object->Walker( NULL, *this );
    return true;
}

bool a2dDumpWalker::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
    //    a2dCanvasObject* parentobj = (a2dCanvasObject*) parent;
        a2dCanvasObject* canobj = (a2dCanvasObject*) object;
        if ( canobj->GetChildObjectList() != wxNullCanvasObjectList )
        {
            forEachIn( a2dCanvasObjectList, canobj->GetChildObjectList() )
            {
                //a2dCanvasObject *obj = (*iter);

            }
        }
    }

    if ( event == a2dWalker_a2dPropObjectStart )
    {
        if ( wxDynamicCast( object, a2dObject ) )
            wxLogDebug(_T("%s"), wxDynamicCast( object, a2dObject )->GetName().c_str() );
    }

    if ( event == a2dWalker_a2dNamedPropertyStart )
    {
        if ( wxDynamicCast( object, a2dNamedProperty ) )
            wxLogDebug(_T("%s"), wxDynamicCast( object, a2dNamedProperty )->GetName().c_str() );

    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_CallMemberFunc
//----------------------------------------------------------------------------


a2dWalker_CallMemberFunc::a2dWalker_CallMemberFunc()
{
    SetDepthFirst( true );
    Initialize();
}

a2dWalker_CallMemberFunc::~a2dWalker_CallMemberFunc()
{
}

bool a2dWalker_CallMemberFunc::Start( a2dObject* object, a2dCanvasObjectFunc func )
{
    m_func = func;
    object->Walker( NULL, *this );
    return true;
}

bool a2dWalker_CallMemberFunc::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* canobj = (a2dCanvasObject*) object;
        (canobj->*((a2dCanvasObjectFunc) (m_func)))();
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_CallMemberFuncW
//----------------------------------------------------------------------------

a2dWalker_CallMemberFuncW::a2dWalker_CallMemberFuncW()
{
    Initialize();
}

a2dWalker_CallMemberFuncW::~a2dWalker_CallMemberFuncW()
{
}

bool a2dWalker_CallMemberFuncW::Start( a2dObject* object, a2dCanvasObjectFuncW func )
{
    m_func = func;
    object->Walker( NULL, *this );
    return true;
}

bool a2dWalker_CallMemberFuncW::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    m_currentParent = parent;

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* canobj = (a2dCanvasObject*) object;
        (canobj->*((a2dCanvasObjectFuncW) (m_func) ))(this);
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_SetAvailable
//----------------------------------------------------------------------------

a2dWalker_SetAvailable::a2dWalker_SetAvailable( a2dLayers* layerSetup )
{
    Initialize();
    m_layerSetup = layerSetup;
    m_view = NULL;
}

a2dWalker_SetAvailable::a2dWalker_SetAvailable( a2dCanvasView* view )
{
    Initialize();
    m_layerSetup = NULL;
    m_view = view;
}

a2dWalker_SetAvailable::~a2dWalker_SetAvailable()
{
}

bool a2dWalker_SetAvailable::Start( a2dObject* object )
{
    object->Walker( NULL, *this );
    return true;
}

bool a2dWalker_SetAvailable::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    bool foundfirst = false;

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* canobj = (a2dCanvasObject*) object;
        if ( m_view )
            m_view->GetLayerRenderArray()[ canobj->GetLayer() ].SetAvailable( true );
        if ( m_layerSetup )
            m_layerSetup->GetLayerIndex()[ canobj->GetLayer() ]->SetAvailable( true );
        //  wxLogDebug( "available layer %d", obj->GetLayer() );
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_RemoveProperty
//----------------------------------------------------------------------------

a2dWalker_RemoveProperty::a2dWalker_RemoveProperty( bool all )
{
    m_all = all;
}

a2dWalker_RemoveProperty::a2dWalker_RemoveProperty( const a2dPropertyId* id , bool all )
{
    m_propertyList.push_back( (a2dPropertyId*) &id );
    m_all = all;
}

a2dWalker_RemoveProperty::a2dWalker_RemoveProperty( const a2dPropertyIdList& idList, bool all )
{
    m_propertyList = idList;
    m_all = all;
}

a2dWalker_RemoveProperty::~a2dWalker_RemoveProperty()
{
}

void a2dWalker_RemoveProperty::AddPropertyId( const a2dPropertyId* id )
{
    m_propertyList.push_back( (a2dPropertyId*) &id );
}


bool a2dWalker_RemoveProperty::Start( a2dObject* object )
{
    object->Walker( NULL, *this );
    return m_result;
}

bool a2dWalker_RemoveProperty::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dPropObjectStart )
    {
        SetStopWalking( true );
        if ( wxDynamicCast( object, a2dPropObject ) )
        {
            a2dPropObject* propobj = wxDynamicCast( object, a2dPropObject );
            forEachIn( a2dPropertyIdList, &m_propertyList )
            {
                a2dPropertyId *id = *iter;
                m_result |= propobj->RemoveProperty( id, m_all );
            }
        }
    }
    if ( event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}


//----------------------------------------------------------------------------
// a2dWalker_RemovePropertyCandoc
//----------------------------------------------------------------------------

a2dWalker_RemovePropertyCandoc::a2dWalker_RemovePropertyCandoc( a2dCanvasObjectFlagsMask mask, bool all )
{
    m_all = all;
    m_mask = mask;
    m_makePending = false;
}

a2dWalker_RemovePropertyCandoc::a2dWalker_RemovePropertyCandoc( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask, bool all )
{
    m_propertyList.push_back( (a2dPropertyId*) &id );
    m_all = all;
    m_mask = mask;
    m_makePending = false;
}

a2dWalker_RemovePropertyCandoc::a2dWalker_RemovePropertyCandoc( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask, bool all )
{
    m_propertyList = idList;
    m_all = all;
    m_mask = mask;
    m_makePending = false;
}

a2dWalker_RemovePropertyCandoc::~a2dWalker_RemovePropertyCandoc()
{
}

void a2dWalker_RemovePropertyCandoc::AddPropertyId( const a2dPropertyId* id )
{
    m_propertyList.push_back( (a2dPropertyId*) &id );
}


bool a2dWalker_RemovePropertyCandoc::Start( a2dCanvasObject* object )
{
    object->Walker( NULL, *this );
    return m_result;
}

bool a2dWalker_RemovePropertyCandoc::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dPropObjectStart )
        SetStopWalking( true );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* propobj =  wxDynamicCast( object, a2dCanvasObject );
        if ( propobj && propobj->CheckMask(m_mask) )
        {
            forEachIn( a2dPropertyIdList, &m_propertyList )
            {
                a2dPropertyId *id = *iter;
                //propobj->RemoveProperty( *id, m_all );
                bool res = propobj->RemoveProperty( id, m_all );
                m_result |= res;
                if ( res && m_makePending )
                    propobj->SetPending(true);
            }
        }
    }
    if ( event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_FilterCanvasObjects
//----------------------------------------------------------------------------

a2dWalker_FilterCanvasObjects::a2dWalker_FilterCanvasObjects( a2dCanvasObjectFlagsMask mask )
{
    Initialize();

    m_mask = mask;
}

a2dWalker_FilterCanvasObjects::a2dWalker_FilterCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
{
    Initialize();

    m_propertyList.push_back( (a2dPropertyId*) &id );
    m_mask = mask;
}

a2dWalker_FilterCanvasObjects::a2dWalker_FilterCanvasObjects( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
{
    Initialize();

    m_propertyList = idList;
    m_mask = mask;
    m_result = false;
}

a2dWalker_FilterCanvasObjects::~a2dWalker_FilterCanvasObjects()
{
}

void a2dWalker_FilterCanvasObjects::Initialize()
{
    a2dWalkerIOHandler::Initialize();
    m_mask = a2dCanvasOFlags::ALL;
    m_skipStartObject = false;
    m_depth = INT_MAX;
    m_bbox = wxNonValidBbox;
    m_allowClassList = true;
    m_classnameMap.clear();
    m_objectname = wxT("");
    m_id = -1;
    m_layervisible = false;
    m_layerselectable = false;
    m_propertyList.clear();
}

void a2dWalker_FilterCanvasObjects::AddPropertyId( const a2dPropertyId* id )
{
    m_propertyList.push_back( (a2dPropertyId*) &id );
}


bool a2dWalker_FilterCanvasObjects::Start( a2dCanvasObject* object )
{
    object->Walker( NULL, *this );
    return m_result;
}

void a2dWalker_FilterCanvasObjects::AddClassName( wxString className )
{
    if (m_classnameMap.find(className) == m_classnameMap.end())
        m_classnameMap.insert(className);
}

void a2dWalker_FilterCanvasObjects::RemoveClassName( wxString className )
{
    if (m_classnameMap.find(className) != m_classnameMap.end())
        m_classnameMap.erase( m_classnameMap.find(className) );
}

bool a2dWalker_FilterCanvasObjects::ObjectOke( a2dCanvasObject* obj )
{
    if ( obj &&
         ( m_objectname.IsEmpty() || m_objectname.Matches( obj->GetName() ) ) &&
         ( m_id == -1 || obj->GetUniqueSerializationId() == m_id ) &&
         obj->CheckMask(m_mask)
       )
    {
        if ( m_layervisible && m_layerselectable && obj->GetCanvasDocument() && obj->GetCanvasDocument()->GetLayerSetup() )
        {
            if ( m_layervisible && !obj->GetCanvasDocument()->GetLayerSetup()->GetVisible( obj->GetLayer() ) )
               return false;
            if ( m_layerselectable && !obj->GetCanvasDocument()->GetLayerSetup()->GetSelectable( obj->GetLayer() ) )
               return false;
        }

        if ( m_bbox.GetValid() && m_bbox.Intersect( obj->GetBbox() ) != _IN )
            return false;

        if ( m_propertyList.size() )
        {
            forEachIn( a2dPropertyIdList, &m_propertyList )
            {
                a2dPropertyId *id = *iter;
                if ( !obj->HasProperty( id ) )
                    return false;
            }
        }
        return true;
    }
    return false;
}

bool a2dWalker_FilterCanvasObjects::ClassOfObjectOke( a2dCanvasObject* obj )
{
    if ( ! m_classnameMap.empty() )
    {
        if ( !m_allowClassList )
        {
            // if class is in list, that is a non wanted object
            if ( m_classnameMap.find( obj->GetClassInfo()->GetClassName() ) != m_classnameMap.end() )
                return false;
            else
                return true;
        }
        else
        {
            // if class is NOT in list, that is a non wanted object
            if ( m_classnameMap.find( obj->GetClassInfo()->GetClassName() ) == m_classnameMap.end() )
                return false;
            else
                return true;
        }
    }
    return true;
}

a2dCanvasObjectList* a2dWalker_FilterCanvasObjects::ConvertToPolygons( a2dCanvasObject* canvasobject, bool transform )
{
    a2dCanvasObjectList* polylist = NULL;

    a2dCanvasObjectList* vpath = ConvertToVpath( canvasobject, true );

    // now we have vector path, which we will convert to polygons and polylines.
    // Next only the polygons will be used for boolean operations.
    if ( vpath != wxNullCanvasObjectList )
    {
        a2dCanvasObjectList::iterator iter = vpath->begin();
        while ( iter != vpath->end() )
        {
            a2dVectorPath* obj = (a2dVectorPath*) (*iter).Get();
            polylist = obj->GetAsPolygons();

            iter = vpath->erase( iter );
            iter = vpath->begin();
        }
        delete vpath;
    }
    return polylist;
}

a2dCanvasObjectList* a2dWalker_FilterCanvasObjects::ConvertToVpath( a2dCanvasObject* canvasobject, bool transform )
{
    a2dCanvasObjectList* vpath = wxNullCanvasObjectList;

    if ( wxDynamicCast( canvasobject, a2dRect ) ||
         wxDynamicCast( canvasobject, a2dRectC ) ||
         wxDynamicCast( canvasobject, a2dArrow ) ||
         wxDynamicCast( canvasobject, a2dCircle ) ||
         wxDynamicCast( canvasobject, a2dEllipse ) ||
         wxDynamicCast( canvasobject, a2dEllipticArc ) ||
         wxDynamicCast( canvasobject, a2dArc ) ||
         wxDynamicCast( canvasobject, a2dPolygonL ) ||
         wxDynamicCast( canvasobject, a2dVectorPath ) ||
         wxDynamicCast( canvasobject, a2dText ) ||
         wxDynamicCast( canvasobject, a2dEndsLine ) ||
         wxDynamicCast( canvasobject, a2dSLine ) ||
         wxDynamicCast( canvasobject, a2dPolylineL )
       )
    {
        vpath = canvasobject->GetAsCanvasVpaths( transform );
    }
    return vpath;
}


//----------------------------------------------------------------------------
// a2dWalker_CollectCanvasObjects
//----------------------------------------------------------------------------

a2dWalker_CollectCanvasObjects::a2dWalker_CollectCanvasObjects( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( mask )
{
    Initialize();

    m_mask = mask;
}

a2dWalker_CollectCanvasObjects::a2dWalker_CollectCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( id, mask )
{
    Initialize();

    m_mask = mask;
}

a2dWalker_CollectCanvasObjects::a2dWalker_CollectCanvasObjects( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( idList, mask )
{
    Initialize();

    m_propertyList = idList;
    m_mask = mask;
}

a2dWalker_CollectCanvasObjects::~a2dWalker_CollectCanvasObjects()
{
}

void a2dWalker_CollectCanvasObjects::Initialize()
{
    a2dWalker_FilterCanvasObjects::Initialize();
    m_found.clear();
}

bool a2dWalker_CollectCanvasObjects::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{

    if ( m_currentDepth > m_depth || event == a2dWalker_a2dPropObjectStart )
        SetStopWalking( true );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && ObjectOke( obj ) && ClassOfObjectOke( obj ) )
        {
            m_found.push_back( obj );
            m_result = true;
        }
    }

    if (  m_currentDepth < m_depth  && event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_FindCanvasObject
//----------------------------------------------------------------------------

a2dWalker_FindCanvasObject::a2dWalker_FindCanvasObject( a2dCanvasObject* search )
    :a2dWalkerIOHandler()
{
    Initialize();
    m_search = search;
}


a2dWalker_FindCanvasObject::~a2dWalker_FindCanvasObject()
{
}

void a2dWalker_FindCanvasObject::Initialize()
{
    a2dWalkerIOHandler::Initialize();
    m_search = 0;
}

bool a2dWalker_FindCanvasObject::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj == m_search )
        {
            SetStopWalking( true );
            m_result = true;
        }
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

bool a2dWalker_FindCanvasObject::Start( a2dCanvasObject* object )
{
    m_result = false;
    object->Walker( NULL, *this );
    return m_result;
}


//----------------------------------------------------------------------------
// a2dWalker_SetSpecificFlagsCanvasObjects
//----------------------------------------------------------------------------

a2dWalker_SetSpecificFlagsCanvasObjects::a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( mask )
{
    m_which = which;
    Initialize();
}

a2dWalker_SetSpecificFlagsCanvasObjects::a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( id, mask )
{
    m_which = which;
    Initialize();
}

a2dWalker_SetSpecificFlagsCanvasObjects::a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( idList, mask )
{
    m_which = which;
    Initialize();
}

a2dWalker_SetSpecificFlagsCanvasObjects::~a2dWalker_SetSpecificFlagsCanvasObjects()
{
}

bool a2dWalker_SetSpecificFlagsCanvasObjects::Start( a2dCanvasObject* object, bool setTo )
{
    m_setOrClear = setTo;
    object->Walker( NULL, *this );
    return m_result;
}

void a2dWalker_SetSpecificFlagsCanvasObjects::Initialize()
{
    a2dWalkerIOHandler::Initialize();
}

bool a2dWalker_SetSpecificFlagsCanvasObjects::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{

    if ( m_currentDepth > m_depth || event == a2dWalker_a2dPropObjectStart )
        SetStopWalking( true );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( !m_skipStartObject || ( m_skipStartObject && m_currentDepth > 1 ) )
            if ( obj && ObjectOke( obj ) && ClassOfObjectOke( obj ) )
            {
                obj->SetSpecificFlags( m_setOrClear, m_which );
                m_result = true;
            }
    }

    if (  m_currentDepth < m_depth  && event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}


a2dWalker_SetPropertyToObject::a2dWalker_SetPropertyToObject( a2dNamedProperty* prop )
{
    m_property = prop;
    Initialize();
}

a2dWalker_SetPropertyToObject::~a2dWalker_SetPropertyToObject()
{
}

void a2dWalker_SetPropertyToObject::Initialize()
{
    a2dWalkerIOHandler::Initialize();
}

bool a2dWalker_SetPropertyToObject::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        m_property->SetToObjectClone( obj, a2dPropertyId::set_none );
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}


//----------------------------------------------------------------------------
// a2dWalker_SetViewDependent
//----------------------------------------------------------------------------

a2dWalker_SetViewDependent::a2dWalker_SetViewDependent( a2dCanvasView* aView, bool viewdependent, bool viewspecific, bool onlyinternalarea )
{
    m_aView = aView;
    m_viewdependent = viewdependent;
    m_viewspecific = viewspecific;
    m_onlyinternalarea = onlyinternalarea;
}

a2dWalker_SetViewDependent::~a2dWalker_SetViewDependent()
{
}

void a2dWalker_SetViewDependent::Initialize()
{
    a2dWalkerIOHandler::Initialize();
}

bool a2dWalker_SetViewDependent::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        obj->SetViewDependent( m_aView, m_viewdependent, m_viewspecific, m_onlyinternalarea );
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

bool a2dWalker_SetViewDependent::Start( a2dCanvasObject* object )
{
    object->Walker( NULL, *this );
    return true;
}


//----------------------------------------------------------------------------
// a2dWalker_SetCanvasDocument
//----------------------------------------------------------------------------

a2dWalker_SetCanvasDocument::a2dWalker_SetCanvasDocument( a2dCanvasDocument* root )
{
    m_root = root;
}

a2dWalker_SetCanvasDocument::~a2dWalker_SetCanvasDocument()
{
}

bool a2dWalker_SetCanvasDocument::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        obj->SetCanvasDocument( m_root, false );
    }

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

bool a2dWalker_SetCanvasDocument::Start( a2dCanvasObject* object )
{
    object->Walker( NULL, *this );
    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_MakeTree
//----------------------------------------------------------------------------

a2dWalker_MakeTree::a2dWalker_MakeTree( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( mask )
{
    Initialize();
    m_mask = mask;
}

a2dWalker_MakeTree::a2dWalker_MakeTree( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( id, mask )
{
    Initialize();
    m_mask = mask;
}

a2dWalker_MakeTree::a2dWalker_MakeTree( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( idList, mask )
{
    Initialize();
}

a2dWalker_MakeTree::~a2dWalker_MakeTree()
{
}

bool a2dWalker_MakeTree::Start( a2dCanvasObject* object )
{
    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( object );

    object->Walker( NULL, *this );
    return true;
}

void a2dWalker_MakeTree::Initialize()
{
    a2dWalker_FilterCanvasObjects::Initialize();
    m_useCheck = true;
    m_depthFirst = true;
    m_firstLevelChild = false;
}

bool a2dWalker_MakeTree::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dObjectStart )
    {
        //wxLogDebug(_T("a2dobj start %s"), wxDynamicCast( object, a2dObject )->GetName() );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && m_currentDepth == 2 && ObjectOke( obj ) && ClassOfObjectOke( obj ) && !obj->GetCheck() )
        {
            m_firstLevelChild = true;
            obj->SetCheck( true );
        }
    }

    if ( event == a2dWalker_a2dCanvasObjectEnd )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        //wxLogDebug( wxT( "classname = %s" ), obj->GetClassInfo()->GetClassName().c_str() );
        //wxLogDebug( wxT( "name = %s" ), obj->GetName().c_str() );

        if ( obj && m_firstLevelChild )
        {
            if ( wxDynamicCast( object, a2dCanvasObjectArrayReference ) )
            {
                a2dCanvasObjectArrayReference* arrayref = wxDynamicCast( object, a2dCanvasObjectArrayReference );
                if ( arrayref->GetCanvasObject() )
                {
                    a2dAffineMatrix offsetXY;
                    int i,j;
                    for ( i = 0  ; i < arrayref->GetRows(); i++)
                    {
                        for ( j = 0  ; j < arrayref->GetColumns(); j++)
                        {
                            a2dCanvasObjectPtr cobj = (a2dCanvasObject*) arrayref->GetCanvasObject()->Clone( clone_deep );
                            cobj->SetRelease( false );

                            obj->CreateChildObjectList()->push_back( cobj );
                            cobj->Transform( offsetXY );

                            offsetXY.Translate( arrayref->GetHorzSpace(), 0 );
                        }
                        //translate back (one row of columns) and add one row
                        offsetXY.Translate( -arrayref->GetHorzSpace()*arrayref->GetColumns(), arrayref->GetVertSpace() );
                    }
                    arrayref->SetCanvasObject( NULL );
                }
            }
            else if ( wxDynamicCast( object, a2dCanvasObjectReference ) )
            {
                a2dCanvasObjectReference* ref = wxDynamicCast( object, a2dCanvasObjectReference );

                if ( ref->GetCanvasObject() )
                {
                    obj->CreateChildObjectList()->push_back( ref->GetCanvasObject() );
                    ref->SetCanvasObject( NULL );
                }
            }

            // references are now (must be) gone in derived objects.
            // There for the obj has only children at this stage.
            obj->MakeReferencesUnique();
            obj->SetCheck( true );

        }
    }

    if ( event == a2dWalker_a2dObjectEnd )
    {
        //wxLogDebug(_T("a2dobj end %s"), wxDynamicCast( object, a2dObject )->GetName().c_str() );
        if ( m_currentDepth <= 2 )
        {
            m_firstLevelChild = false;
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_RemoveHierarchy
//----------------------------------------------------------------------------

a2dWalker_RemoveHierarchy::a2dWalker_RemoveHierarchy( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( mask )
{
    Initialize();
    m_mask = mask;
}

a2dWalker_RemoveHierarchy::a2dWalker_RemoveHierarchy( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( id, mask )
{
    Initialize();
    m_mask = mask;
}

a2dWalker_RemoveHierarchy::a2dWalker_RemoveHierarchy( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( idList, mask )
{
    Initialize();
}

a2dWalker_RemoveHierarchy::~a2dWalker_RemoveHierarchy()
{
}

bool a2dWalker_RemoveHierarchy::Start( a2dCanvasObject* object )
{
    a2dWalker_MakeTree unify( m_mask );
    unify.Start( object );

    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( object );
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::BIN );
    setflags.Start( object, false );

    object->Walker( NULL, *this );
    return true;
}

void a2dWalker_RemoveHierarchy::Initialize()
{
    a2dWalker_FilterCanvasObjects::Initialize();
    m_selected = true;
    m_useCheck = true;
    m_depthFirst = true;
    m_firstLevelChild = false;
}

bool a2dWalker_RemoveHierarchy::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dObjectStart )
    {
        m_parentList.push_front( wxDynamicCast( object, a2dObject ) );

        //wxLogDebug(_T("a2dobj start %s"), wxDynamicCast( object, a2dObject )->GetName().c_str() );

        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && m_parentList.size() == 2 && ObjectOke( obj ) && ClassOfObjectOke( obj ) && !obj->GetCheck() )
        {
            m_firstLevelChild = true;
            obj->SetCheck( true );
        }
    }

    if ( event == a2dWalker_a2dCanvasObjectEnd )
    {
        a2dCanvasObject* parentobj =  wxDynamicCast( parent, a2dCanvasObject );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );

        //wxLogDebug( wxT( "classname = %s" ), obj->GetClassInfo()->GetClassName().c_str() );
        //wxLogDebug( wxT( "name = %s" ), obj->GetName().c_str() );

        if ( obj && !obj->GetBin() && parentobj && m_firstLevelChild )
        {
            if ( wxDynamicCast( object, a2dCanvasObjectReference ) )
            {
                a2dCanvasObjectReference* ref = wxDynamicCast( object, a2dCanvasObjectReference );
                wxASSERT_MSG( ref->GetCanvasObject() == NULL, wxT("No references allowed at this stage") );
            }

            if ( obj->GetChildObjectList() != wxNullCanvasObjectList )
            {
                // release later on, since there is an iterator more on it in a2dCanvasObject::DoWalker()
                obj->SetRelease( true );

                a2dCanvasObjectList::iterator iter = obj->GetChildObjectList()->begin();
                while( iter != obj->GetChildObjectList()->end() )
                {
                    a2dCanvasObjectList::value_type objchild = *iter;
                    //iter++;
                    iter = obj->GetChildObjectList()->erase( iter );

                    if ( !objchild->GetRelease() )
                    {
                        //parentobj->CreateChildObjectList()->insert( iterinserthere, obj );
                        parentobj->CreateChildObjectList()->push_back( objchild );
                        objchild->Transform( obj->GetTransformMatrix() );
                        objchild->SetSelected( m_selected );
                    }
                }
            }
        }
    }

    if ( event == a2dWalker_a2dObjectEnd )
    {
        //wxLogDebug(_T("a2dobj end %s"), wxDynamicCast( object, a2dObject )->GetName().c_str() );

        m_parentList.pop_front();
        if ( m_parentList.size() < 2 )
        {
            m_firstLevelChild = false;
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_LayerGroup
//----------------------------------------------------------------------------

a2dWalker_LayerGroup::a2dWalker_LayerGroup( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( mask )
{
    Initialize();
}

a2dWalker_LayerGroup::a2dWalker_LayerGroup( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( id, mask )
{
    Initialize();
}

a2dWalker_LayerGroup::a2dWalker_LayerGroup( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_FilterCanvasObjects( idList, mask )
{
    Initialize();
}

a2dWalker_LayerGroup::~a2dWalker_LayerGroup()
{
}

void a2dWalker_LayerGroup::Initialize()
{
    a2dWalker_FilterCanvasObjects::Initialize();
    m_target = wxLAYER_DEFAULT;
    m_selectedOnlyA = false;
    m_selectedOnlyB = false;
}

void a2dWalker_LayerGroup::SetTarget( wxUint16 targetlayer )
{
    wxASSERT_MSG( wxMAXLAYER > targetlayer , wxT(" targetlayer > wxMAXLAYER, index to high") );
    m_target = targetlayer;
};

bool a2dWalker_LayerGroup::Start( a2dCanvasObject* object )
{
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::BIN );
    setflags.Start( object, false );

    object->Walker( NULL, *this );
    return m_result;
}

//----------------------------------------------------------------------------
// a2dWalker_LayerCanvasObjects
//----------------------------------------------------------------------------

const long a2dWalker_LayerCanvasObjects::moveLayers = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::copyLayers = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::deleteLayers = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertToArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertToPolygonPolylinesWithArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertToPolygonPolylinesWithoutArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertPolygonToArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertPolylineToArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertToVPaths = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertLinesArcs = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::ConvertToPolylines = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::RemoveRedundant = wxGenNewId();
const long a2dWalker_LayerCanvasObjects::areaLayers = wxGenNewId();

a2dWalker_LayerCanvasObjects::a2dWalker_LayerCanvasObjects( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( mask )
{
    Initialize();
}

a2dWalker_LayerCanvasObjects::a2dWalker_LayerCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( id, mask )
{
    Initialize();
}


a2dWalker_LayerCanvasObjects::a2dWalker_LayerCanvasObjects( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( idList, mask )
{
    Initialize();
}

a2dWalker_LayerCanvasObjects::~a2dWalker_LayerCanvasObjects()
{
}

void a2dWalker_LayerCanvasObjects::Initialize()
{
    a2dWalker_LayerGroup::Initialize();
    m_operation = moveLayers;
    m_radiusMin = 0;
    m_radiusMax = DBL_MAX;
    m_detectCircle = false;
    m_calculatedArea = 0.0;
    m_AberPolyToArc = a2dCanvasGlobals->ACCUR();
}

bool a2dWalker_LayerCanvasObjects::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* parentobj =  wxDynamicCast( parent, a2dCanvasObject );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && parentobj && !obj->GetIgnoreLayer() && !obj->GetBin() && ObjectOke( obj ) && ClassOfObjectOke( obj ) )

        {
            bool hasLayer = m_groupA.InGroup( obj->GetLayer() );
            if ( hasLayer && ( !m_selectedOnlyA || (m_selectedOnlyA && obj->GetSelected())) )
            {
                if ( m_operation == moveLayers )
                {
                    obj->SetLayer( m_target );
                }
                else if ( m_operation == copyLayers )
                {
                    a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                    parentobj->Prepend( cobj );
                    cobj->SetLayer( m_target );
                    cobj->SetBin( true );
                }
                else if ( m_operation == deleteLayers )
                {
                    parentobj->ReleaseChild( obj );
                }
                else if ( m_operation == ConvertToArcs )
                {
                    if (0 != wxDynamicCast( obj, a2dPolylineL ) && obj->GetContourWidth() )
                    {
                        a2dPolylineL* objc = wxDynamicCast( obj, a2dPolylineL );
                        a2dPolygonL* contour = objc->GetAsPolygon();
                        contour->SetLayer( m_target );
                        contour->SetBin( true );
                        //contour->GetSegments()->ConvertPolylineToArc( m_AberPolyToArc, m_radiusMin, m_radiusMax );
                        parentobj->Append( contour );
                    }
                }
                else if ( m_operation == ConvertPolygonToArcs || m_operation == ConvertToArcs )
                {
                    if (0 != wxDynamicCast( obj, a2dPolygonL ))
                    {
                        a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                        cobj->SetLayer( m_target );
                        cobj->SetBin( true );
                        a2dPolygonL* objc = wxDynamicCast( cobj, a2dPolygonL );
                        objc->GetSegments()->ConvertPolygonToArc( m_AberPolyToArc, m_radiusMin, m_radiusMax );
                        a2dPoint2D middle;
                        double radius;
                        if ( m_detectCircle && objc->GetSegments()->CheckForOneCircle( middle, radius ) )
                        {
                            a2dCircle* cir = new a2dCircle( middle.m_x, middle.m_y, radius );
                            cir->Transform( obj->GetTransformMatrix() );
                            cir->SetLayer( m_target );
                            cir->SetBin( true );
                            parentobj->Prepend( cir );
                            delete cobj;
                        }
                        else
                            parentobj->Prepend( cobj );
                    }
                }
                else if ( m_operation == ConvertPolylineToArcs )
                {
                    if (0 != wxDynamicCast( obj, a2dPolylineL ) && obj->GetContourWidth() )
                    {
                        a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                        a2dPolylineL* objc = wxDynamicCast( cobj, a2dPolylineL );
                        cobj->SetLayer( m_target );
                        cobj->SetBin( true );
                        parentobj->Prepend( cobj );
                        objc->GetSegments()->ConvertPolylineToArc( m_AberPolyToArc, m_radiusMin, m_radiusMax );
                    }
                    else if (0 != wxDynamicCast( obj, a2dPolylineL ) )
                    {
                        a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                        cobj->SetLayer( m_target );
                        cobj->SetBin( true );
                        parentobj->Prepend( cobj );
                        a2dPolylineL* objc = wxDynamicCast( cobj, a2dPolylineL );
                        objc->GetSegments()->ConvertPolylineToArc( m_AberPolyToArc, m_radiusMin, m_radiusMax );
                    }
                }
                else if ( m_operation == ConvertToPolygonPolylinesWithArcs )
                {
                    a2dCanvasObjectList* polylist = ConvertToPolygons( obj, true );
                    for( a2dCanvasObjectList::iterator iterp = polylist->begin(); iterp != polylist->end(); ++iterp )
                    {
                        a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
                        a2dPolylineL* polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
                        if ( poly && poly->GetNumberOfSegments() > 2 )
                        {
                            poly->SetLayer( m_target );
                            poly->SetBin( true );
                            parentobj->Prepend( poly );
                        }
                        else if ( polyline && polyline->GetNumberOfSegments() > 2 )
                        {
                            polyline->SetLayer( m_target );
                            polyline->SetBin( true );
                            parentobj->Prepend( polyline );
                        }
                    }
                    delete polylist;
                }
                else if ( m_operation == ConvertToPolygonPolylinesWithoutArcs )
                {
                    a2dCanvasObjectList* polylist = ConvertToPolygons( obj, true );
                    for( a2dCanvasObjectList::iterator iterp = polylist->begin(); iterp != polylist->end(); ++iterp )
                    {
                        a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
                        a2dPolylineL* polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
                        if ( poly && poly->GetNumberOfSegments() > 2 )
                        {
                            poly->SetLayer( m_target );
                            poly->SetBin( true );
                            poly->GetSegments()->ConvertToLines();
                            parentobj->Prepend( poly );
                        }
                        else if ( polyline && polyline->GetNumberOfSegments() > 2 )
                        {
                            polyline->SetLayer( m_target );
                            polyline->SetBin( true );
                            polyline->GetSegments()->ConvertToLines();
                            parentobj->Prepend( polyline );
                        }
                    }
                    delete polylist;
                }
                else if ( m_operation == ConvertToVPaths )
                {
                    a2dCanvasObjectList* vpath = ConvertToVpath( obj, true );
                    for( a2dCanvasObjectList::iterator iterp = vpath->begin(); iterp != vpath->end(); ++iterp )
                    {
                        a2dVectorPath* path = wxDynamicCast( (*iterp).Get(), a2dVectorPath );
                        path->SetLayer( m_target );
                        path->SetBin( true );
                        parentobj->Prepend( path );
                    }
                    delete vpath;
                }
                else if ( m_operation == ConvertToPolylines )
                {
                    a2dCanvasObjectList* polylist = ConvertToPolygons( obj, true );
                    int i, count = polylist->size();
                    a2dCanvasObjectList::iterator iterp = polylist->begin();
                    for( i = 0 ; i < count ; i++ )
                    {
                        a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
                        a2dPolylineL* polyline = wxDynamicCast( (*iterp).Get(), a2dPolylineL );
                        if ( poly && poly->GetNumberOfSegments() > 2 )
                        {
                            a2dPolylineL* conv = new a2dPolylineL( poly->GetSegments() );

                            conv->SetLayer( m_target );
                            conv->SetBin( true );
                            parentobj->Prepend( conv );
                            iterp = polylist->erase( iterp );
                        }
                        else if ( polyline && polyline->GetNumberOfSegments() > 2 )
                        {
                            polyline->SetLayer( m_target );
                            polyline->SetBin( true );
                            parentobj->Prepend( polyline );
                            iterp++;
                        }
                    }
                    delete polylist;
                }
                else if ( m_operation == ConvertLinesArcs )
                {
                    a2dCanvasObjectList* polylist = ConvertToPolygons( obj, true );
                    int i, count = polylist->size();
                    a2dCanvasObjectList::iterator iterp = polylist->begin();
                    for( i = 0 ; i < count ; i++ )
                    {
                        a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
                        poly->SetLayer( m_target );
                        poly->SetBin(true );
                        a2dCanvasObjectList* linesAndArcs = poly->GetAsLinesArcs();
                        for( a2dCanvasObjectList::iterator iterl = linesAndArcs->begin(); iterl != linesAndArcs->end(); ++iterl )
                            parentobj->Prepend( *iterl );
                        iterp = polylist->erase( iterp );
                        delete linesAndArcs;
                    }
                    delete polylist;
                }
                else if ( m_operation == RemoveRedundant )
                {
                    if (0 != wxDynamicCast( obj, a2dPolylineL ) )
                    {
                        a2dPolylineL* cobj = wxDynamicCast( obj, a2dPolylineL );
                        cobj->GetSegments()->RemoveRedundant(false);
                        cobj->SetLayer( m_target );
                        cobj->SetBin(true );
                    }
                    else if (0 != wxDynamicCast( obj, a2dPolygonL ))
                    {
                        a2dPolygonL* cobj = wxDynamicCast( obj, a2dPolygonL );
                        cobj->GetSegments()->RemoveRedundant(true);
                        cobj->SetLayer( m_target );
                        cobj->SetBin(true );
                    }
                }
                else if ( m_operation == areaLayers )
                {
                    AddArea( obj );
                }
                m_result = true;
            }
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

void a2dWalker_LayerCanvasObjects::AddArea( a2dCanvasObject* getAsPolyObject )
{
    a2dCanvasObjectList* vpath = wxNullCanvasObjectList;

    if (0 != wxDynamicCast( getAsPolyObject, a2dRect ))
    {
        a2dRect* obj = wxDynamicCast( getAsPolyObject, a2dRect );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dRectC ))
    {
        a2dRectC* obj = wxDynamicCast( getAsPolyObject, a2dRectC );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dArrow ))
    {
        a2dArrow* obj = wxDynamicCast( getAsPolyObject, a2dArrow );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dCircle ))
    {
        a2dCircle* obj = wxDynamicCast( getAsPolyObject, a2dCircle );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dEllipse ))
    {
        a2dEllipse* obj = wxDynamicCast( getAsPolyObject, a2dEllipse );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dEllipticArc ))
    {
        a2dEllipticArc* obj = wxDynamicCast( getAsPolyObject, a2dEllipticArc );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dArc ))
    {
        a2dArc* obj = wxDynamicCast( getAsPolyObject, a2dArc );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dEndsLine ) && getAsPolyObject->GetContourWidth() )
    {
        a2dEndsLine* obj = wxDynamicCast( getAsPolyObject, a2dEndsLine );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dSLine ) && getAsPolyObject->GetContourWidth() )
    {
        a2dSLine* obj = wxDynamicCast( getAsPolyObject, a2dSLine );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dPolylineL ) && getAsPolyObject->GetContourWidth() )
    {
        a2dPolylineL* obj = wxDynamicCast( getAsPolyObject, a2dPolylineL );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dPolygonL ))
    {
        a2dPolygonL* obj = wxDynamicCast( getAsPolyObject, a2dPolygonL );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dVectorPath ))
    {
        a2dVectorPath* obj = wxDynamicCast( getAsPolyObject, a2dVectorPath );
        vpath = obj->GetAsCanvasVpaths();
    }
    else if (0 != wxDynamicCast( getAsPolyObject, a2dText ))
    {
        a2dText* obj = wxDynamicCast( getAsPolyObject, a2dText );
        vpath = obj->GetAsCanvasVpaths();
    }

    // now we have vector path, which we will convert to polygons and polylines.
    // Next only the polygons will be used for boolean operations.
    if ( vpath != wxNullCanvasObjectList )
    {

        a2dCanvasObjectList::iterator iter = vpath->begin();
        while ( iter != vpath->end() )
        {
            a2dCanvasObjectList* polylist = NULL;
            a2dVectorPath* obj = (a2dVectorPath*) (*iter).Get();
            polylist = obj->GetAsPolygons();

            for( a2dCanvasObjectList::iterator iterp = polylist->begin(); iterp != polylist->end(); ++iterp )
            {
                a2dPolygonL* poly = wxDynamicCast( (*iterp).Get(), a2dPolygonL );
                if ( poly && poly->GetNumberOfSegments() > 2 )
                {
                    m_calculatedArea += poly->GetSegments()->CalcArea();
                }
            }
            delete polylist;

            iter = vpath->erase( iter );
            iter = vpath->begin();
        }
        delete vpath;
    }
}

//----------------------------------------------------------------------------
// a2dWalker_DetectSmall
//----------------------------------------------------------------------------

a2dWalker_DetectSmall::a2dWalker_DetectSmall( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( mask )
{
    Initialize();
}

a2dWalker_DetectSmall::a2dWalker_DetectSmall( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( id, mask )
{
    Initialize();
}

a2dWalker_DetectSmall::a2dWalker_DetectSmall( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( idList, mask )
{
    Initialize();
}

a2dWalker_DetectSmall::~a2dWalker_DetectSmall()
{
}

void a2dWalker_DetectSmall::Initialize()
{
    a2dWalker_LayerGroup::Initialize();
    m_asString = false;
/*
#if wxUSE_STD_IOSTREAM
    m_strstream << _T("Contents of document \n");
#else
    wxTextOutputStream text_stream( m_strstream );
    text_stream << _T("Contents of document \n");
#endif
*/
}

bool a2dWalker_DetectSmall::Start( a2dCanvasObject* object )
{
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::BIN );
    setflags.Start( object, false );

    m_CVGwriter.WriteCvgStartDocument( m_strstream );

    m_CVGwriter.WriteStartElementAttributes( wxT("o") );
    m_CVGwriter.WriteAttribute( wxT("classname"), wxT("a2dCanvasObject") );
    m_CVGwriter.WriteEndAttributes();

    object->Walker( NULL, *this );

    m_CVGwriter.WriteEndElement();

    m_CVGwriter.WriteCvgEndDocument();

    return m_result;
}

bool a2dWalker_DetectSmall::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* parentobj =  wxDynamicCast( parent, a2dCanvasObject );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && parentobj && !obj->GetIgnoreLayer() && !obj->GetBin() && ObjectOke( obj ) && ClassOfObjectOke( obj ) )
        {
            bool hasLayer = m_groupA.InGroup( obj->GetLayer() );
            if ( hasLayer && ( !m_selectedOnlyA || (m_selectedOnlyA && obj->GetSelected())) )
            {
                if ( obj->GetBboxWidth() < m_small && obj->GetBboxHeight() < m_small )
                {
                    if ( m_asString )
                    {
                        #if wxART2D_USE_CVGIO
                            m_CVGwriter.WriteObject( obj );
                        #endif //wxART2D_USE_CVGIO
                    }
                    else
                    {
                        a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                        cobj->SetLayer( m_target );
                        cobj->SetBin( true );
                        parentobj->Prepend( cobj );
                    }
                    m_result = true;
                }
            }
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_DetectSmallSegments
//----------------------------------------------------------------------------

a2dWalker_DetectSmallSegments::a2dWalker_DetectSmallSegments( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( mask )
{
    Initialize();
}

a2dWalker_DetectSmallSegments::a2dWalker_DetectSmallSegments( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( id, mask )
{
    Initialize();
}

a2dWalker_DetectSmallSegments::a2dWalker_DetectSmallSegments( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( idList, mask )
{
    Initialize();
}

a2dWalker_DetectSmallSegments::~a2dWalker_DetectSmallSegments()
{
}

void a2dWalker_DetectSmallSegments::Initialize()
{
    a2dWalker_LayerGroup::Initialize();
    m_asString = false;
/*
#if wxUSE_STD_IOSTREAM
    m_strstream << _T("Contents of document \n");
#else
    wxTextOutputStream text_stream( m_strstream );
    text_stream << _T("Contents of document \n");
#endif
*/
}

bool a2dWalker_DetectSmallSegments::Start( a2dCanvasObject* object )
{
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::BIN );
    setflags.Start( object, false );

    m_CVGwriter.WriteCvgStartDocument( m_strstream );

    m_CVGwriter.WriteStartElementAttributes( wxT("o") );
    m_CVGwriter.WriteAttribute( wxT("classname"), wxT("a2dCanvasObject") );
    m_CVGwriter.WriteEndAttributes();

    object->Walker( NULL, *this );

    m_CVGwriter.WriteEndElement();

    m_CVGwriter.WriteCvgEndDocument();

    return m_result;
}

bool a2dWalker_DetectSmallSegments::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* parentobj =  wxDynamicCast( parent, a2dCanvasObject );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && parentobj && !obj->GetIgnoreLayer() && !obj->GetBin() && ObjectOke( obj ) && ClassOfObjectOke( obj ) )
        {
            bool hasLayer = m_groupA.InGroup( obj->GetLayer() );
            if ( hasLayer && ( !m_selectedOnlyA || (m_selectedOnlyA && obj->GetSelected())) )
            {
                a2dVertexListPtr redun;
                if (0 != wxDynamicCast( obj, a2dPolylineL ) )
                {
                    a2dPolylineL* cobj = wxDynamicCast( obj, a2dPolylineL );
                    redun = cobj->GetSegments()->GetRedundant( false, m_small );
                    if ( redun )
                    {
                        m_result = true;
                        a2dSmrtPtr<a2dPolylineL> p = new a2dPolylineL( redun, false );
                        p->SetLayer( m_target );
                        p->SetBin( true );
                        if ( m_asString )
                        {
                            #if wxART2D_USE_CVGIO
                                m_CVGwriter.WriteObject( p );
                            #endif //wxART2D_USE_CVGIO
                        }
                        else
                            parentobj->Append( p );
                    }
                }
                else if (0 != wxDynamicCast( obj, a2dPolygonL ))
                {
                    a2dPolygonL* cobj = wxDynamicCast( obj, a2dPolygonL );
                    redun = cobj->GetSegments()->GetRedundant( true, m_small );
                    if ( redun )
                    {
                        m_result = true;
                        a2dSmrtPtr<a2dPolygonL> p = new a2dPolygonL( redun, false );
                        p->SetLayer( m_target );
                        p->SetBin( true );
                        if ( m_asString )
                        {
                            #if wxART2D_USE_CVGIO
                                m_CVGwriter.WriteObject( p );
                            #endif //wxART2D_USE_CVGIO
                        }
                        else
                            parentobj->Append( p );
                    }
                }
            }
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalker_FindAndSetCorridorPath
//----------------------------------------------------------------------------

a2dWalker_FindAndSetCorridorPath::a2dWalker_FindAndSetCorridorPath( a2dCanvasObject* search )
    :a2dWalker_FindCanvasObject( search )
{
}


a2dWalker_FindAndSetCorridorPath::~a2dWalker_FindAndSetCorridorPath()
{
}

bool a2dWalker_FindAndSetCorridorPath::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dPropObjectStart )
        SetStopWalking( true );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( !m_result )
            obj->SetIsOnCorridorPath( true );
        if ( obj == m_search )
        {
            m_result = true;
            SetStopWalking( true );
            return true;
        }
    }

    if ( event == a2dWalker_a2dCanvasObjectEnd )
    {
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( !m_result )
        {
            obj->SetIsOnCorridorPath( false );
            return true;
        }
    }
    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    if (  !m_result  && event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );


    return true;
}

/* algorithm candidates, which or not in use currentl

    //! Mark multiple references.
    /! Search for objects that are multiple referenced from within the document.
        All such object get there m_bin2 flag set.
    /
virtual bool MarkMultiReferences();


bool a2dCanvasObject::MarkMultiReferences()
{
    bool found = true;

    if ( GetBin() )
    {
        m_flags.m_bin2 = true;
        found = true;
    }
    m_flags.m_bin = true; //passed here

    if ( canobj->GetChildObjectList() == wxNullCanvasObjectList )
        return found;

    forEachIn( a2dCanvasObjectList, canobj->GetChildObjectList() )
    {
        a2dCanvasObject *obj = *iter;
        found = obj->MarkMultiReferences() && found;
    }
    return found;
}








    //!can be used by the user to implement a function that affects all a2dCanvas  derived objects
    /!
      The base implementation calls this function on its childs, so in a derived object always
      call the base class to keep recursing deeper.

       \param function id of the user function to be called
       \param data for the called function (type depends on id)
       \param depth recursion depth (0=this object, 1=this object+childs, ...)
       \param flags objects with this flag set ignore the depth limit
    /
    virtual bool UserBaseFunctionEx( int function, void *data, int depth, a2dCanvasObjectFlagsMask flags );



bool a2dCanvasObject::UserBaseFunctionEx( int function, void *data, int depth,  a2dCanvasObjectFlagsMask flags )
{
    if( depth<=0 && !CheckMask( flags ) )
        return true;

    bool rslt = true;
    if( GetChildObjectsCount() )
    {
        forEachIn( a2dCanvasObjectList, canobj->GetChildObjectList() )
        {
            a2dCanvasObject *obj = *iter;
            rslt &= obj->UserBaseFunctionEx( function, data, depth-1, flags );
        }
    }
    return rslt;
}




    //! to refresh controls after a rendering to a device did take place
    /!
        This brings the wxWindows controls back to the front.
    /
    void RefreshControls();


    void a2dCanvasObject::RefreshControls()
    {
        if ( canobj->GetChildObjectList() == wxNullCanvasObjectList )
            return;

        forEachIn( a2dCanvasObjectList, canobj->GetChildObjectList() )
        {
            a2dCanvasObject *obj = *iter;
            obj->RefreshControls();
        }
    }
*/


//----------------------------------------------------------------------------
// a2dWalker_AllowedObjects
//----------------------------------------------------------------------------

a2dWalker_AllowedObjects::a2dWalker_AllowedObjects( a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( mask )
{
    Initialize();
}

a2dWalker_AllowedObjects::a2dWalker_AllowedObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( id, mask )
{
    Initialize();
}

a2dWalker_AllowedObjects::a2dWalker_AllowedObjects( const a2dPropertyIdList& idList, a2dCanvasObjectFlagsMask mask )
    :a2dWalker_LayerGroup( idList, mask )
{
    Initialize();
}

a2dWalker_AllowedObjects::~a2dWalker_AllowedObjects()
{
}

void a2dWalker_AllowedObjects::Initialize()
{
    a2dWalker_LayerGroup::Initialize();
    m_asString = false;

/*
#if wxUSE_STD_IOSTREAM
    m_strstream << _T("Contents of document \n");
#else
    wxTextOutputStream text_stream( m_strstream );
    text_stream << _T("Contents of document \n");
#endif
*/
}

bool a2dWalker_AllowedObjects::Start( a2dCanvasObject* object )
{
    a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::BIN );
    setflags.Start( object, false );

    m_CVGwriter.WriteCvgStartDocument( m_strstream );

    m_CVGwriter.WriteStartElementAttributes( wxT("o") );
    m_CVGwriter.WriteAttribute( wxT("classname"), wxT("a2dCanvasObject") );
    m_CVGwriter.WriteEndAttributes();

    object->Walker( NULL, *this );

    m_CVGwriter.WriteEndElement();

    m_CVGwriter.WriteCvgEndDocument();

    return m_result;
}

bool a2dWalker_AllowedObjects::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( m_currentDepth > m_depth  )
        SetStopWalking( true );
    else
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* parentobj =  wxDynamicCast( parent, a2dCanvasObject );
        a2dCanvasObject* obj =  wxDynamicCast( object, a2dCanvasObject );
        if ( obj && parentobj && !obj->GetIgnoreLayer() && !obj->GetBin() && ObjectOke( obj ) )
        {
            bool hasLayer = m_groupA.InGroup( obj->GetLayer() );
            if ( hasLayer && ( !m_selectedOnlyA || (m_selectedOnlyA && obj->GetSelected())) )
            {
                // see also m_allowClassList
                if ( ClassOfObjectOke( obj ) )
                {
                    m_result = true;
                    if ( m_store )
                    {
                        if ( m_asString )
                        {
                            #if wxART2D_USE_CVGIO
                                m_CVGwriter.WriteObject( obj );
                            #endif //wxART2D_USE_CVGIO
                        }
                        else
                        {
                            a2dCanvasObject* cobj = obj->TClone( a2dObject::clone_deep );
                            cobj->SetLayer( m_target );
                            cobj->SetBin( true );
                            parentobj->Prepend( cobj );
                        }
                    }
                }
            }
        }
    }

    if (  m_currentDepth <= m_depth   )
        SetStopWalking( false );

    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false; //do not go here

    return true;
}

//----------------------------------------------------------------------------
// a2dWalkerIOHandlerWithContext
//----------------------------------------------------------------------------

a2dWalkerIOHandlerWithContext::a2dWalkerIOHandlerWithContext( a2dIterC& ic )
    : a2dWalkerIOHandler()
{
    m_context = &ic;
    Initialize();
}

a2dWalkerIOHandlerWithContext::~a2dWalkerIOHandlerWithContext()
{
}

void a2dWalkerIOHandlerWithContext::Initialize()
{
}

    //! Start traversing at object, returns true.
bool a2dWalkerIOHandlerWithContext::Start( a2dCanvasObject* object )
{
    a2dWalker_SetBoolProperty setp( PROPID_Check, false );
    setp.Start( object );

    SetDepthFirst( false );
    m_result = true;
    m_context->SetClipStatus( _ON );
    m_context->SetRenderChildDerived( false );
    object->WalkerWithContext( *m_context, NULL, *this );
    return m_result;
}

//----------------------------------------------------------------------------
// a2dWalker_RenderLayers
//----------------------------------------------------------------------------

a2dWalker_RenderLayers::a2dWalker_RenderLayers( a2dIterC& ic )
    :a2dWalkerIOHandlerWithContext( ic )
{

}

a2dWalker_RenderLayers::~a2dWalker_RenderLayers()
{

}

bool a2dWalker_RenderLayers::WalkTask( a2dIterC& ic, wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dCanvasObjectStart )
    {
        a2dCanvasObject* parentobj = (a2dCanvasObject*) parent;
        a2dCanvasObject* canobj = (a2dCanvasObject*) object;
        OVERLAP clipparent = ic.GetParentClipStatus();
        OVERLAP childclip = _IN;
        // if parent is checked it means, it is _ON or _IN
        childclip = canobj->GetClipStatus( ic, clipparent );
        ic.SetClipStatus( childclip );
        //if ( childclip != _OUT ) //if a child is _OUT, no need to render it.
        {
            Render( ic, canobj, childclip );
        }
    }
    if ( event == a2dWalker_a2dCanvasObjectPostChild )
        return false;

    return true;
}

void a2dWalker_RenderLayers::Render( a2dIterC& ic, a2dCanvasObject* canobj, OVERLAP clipparent )
{
    wxUint16 layer = canobj->GetLayer();
    // Check if the object is not about to be deleted
    if ( canobj->GetRelease( ) )
        return;

    if ( !ic.FilterObject( canobj ) )
    {
        ic.EndFilterObject( canobj );
        return;
    }

    //Now we will either render the object or children or both on the given layer.
    //OR in case layer == wxLAYER_ALL, everything will be rendered at once.
    //Style of objects will be according to their own style properties of using the object
    //m_layer id.


    //get bbox at the absolute position
    //first map without pen width which is not included in the boundingbox

    // if 0 in width or height, nothing will be rendered in principle.
    // But the stroke width is not included in bbox, so it might still be visible.
    if ( !canobj->GetFlag( a2dCanvasOFlags::NoRenderCanvasObject) && canobj->GetBbox().GetWidth() && canobj->GetBbox().GetHeight() )
    {
        a2dBoundingBox absarea = canobj->GetBbox();
        if ( !ic.GetTransform().IsIdentity())
            absarea.MapBbox( ic.GetTransform() );

        double size = wxMax( absarea.GetWidth(), absarea.GetHeight() );
        if ( ic.GetDrawer2D()->GetPrimitiveThreshold() != 0
             && size < ic.GetDrawer2D()->DeviceToWorldXRel( ic.GetDrawer2D()->GetPrimitiveThreshold() )  )
        {
            if ( ic.GetDrawer2D()->GetThresholdDrawRectangle() )
            {
                wxRect absareadev = canobj->GetAbsoluteArea( ic, 0 );
                ic.GetDrawer2D()->DrawRoundedRectangle( canobj->GetBbox().GetMinX(), canobj->GetBbox().GetMinY(),
                    canobj->GetBbox().GetWidth(), canobj->GetBbox().GetHeight(),0);

                if ( canobj->GetHighLight() )
                    canobj->DrawHighLighted( ic );
            }
            ic.EndFilterObject( canobj );
            return;
        }
    }

    // a2dIterCU scope ends for DrawHighLighted( ic )
    {
        //here the Drawer gets a new relative transform
        //Every call for drawing something on it, will use it from now on.
        // we go one level deeper in transform to the child level
        a2dIterCU cu( ic, canobj );

        //if ( m_flags.m_HighLight )
        //    DrawHighLighted( ic );


        //if the propertylist NOT contains style properties,
        //we need to set the style according to the layer setting.
        bool fillset = false;
        bool strokeset = false;
        bool viewSpecific = false;

        a2dLayers* layers = canobj->GetCanvasDocument()->GetLayerSetup();
        //if style not set by the properties ,do it now using the layers.
        if ( layers )
        {
            if ( !fillset  )
                ic.GetDrawer2D()->SetDrawerFill( layers->GetFill(layer) );
            if ( !strokeset )
                ic.GetDrawer2D()->SetDrawerStroke( layers->GetStroke(layer) );
        }
        else
        {
            if ( !fillset  )
                ic.GetDrawer2D()->SetDrawerFill( *a2dBLACK_FILL );
            if ( !strokeset )
                ic.GetDrawer2D()->SetDrawerStroke( *a2dBLACK_STROKE );
        }

        //if the object has sub objects (apart from the childobjects which are handled here),
        //those subobjects must be rendered by iterating on layer when needed/wanted, simular to child objects.
        //We do not iterate here, since that is only needed if indeed there or subobjects.
        //This will be know in a "wxDerivedCanvasObject DoRender".
        //SO parent objects that call this function here, MUST:
        // 1-  clip object against area to redraw.
        // 2-  iterate on layers when needed.
        if ( ic.GetLayer() == layer || ic.GetLayer() == wxLAYER_ALL || canobj->GetIgnoreLayer() )
        {

            // DoRender() should not change the matrix of the drawing context, or at least restore it.
            // To prevent taking time for this.
            //a2dAffineMatrix tworld = ic.GetTransform();

            canobj->CallDoRender( ic, clipparent );
        }
    }

    if ( canobj->GetHighLight() )
        canobj->DrawHighLighted( ic );

    ic.EndFilterObject( canobj );
}

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