gen.cpp

Go to the documentation of this file.

/*! \file general/src/gen.cpp
    \author Klaas Holwerda

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: gen.cpp,v 1.154 2009/09/26 19:01:07 titato Exp $
*/

#include "docviewprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include <wx/tokenzr.h>
    #include <wx/utils.h>


    #include "wx/general/gen.h"
    #include "wx/general/comevt.h"

    #if wxART2D_USE_CVGIO
        #include "wx/xmlparse/genxmlpars.h"
    #endif //wxART2D_USE_CVGIO
#endif

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

/*
// 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

// explicit template instantiations
template class a2dPropertyIdTyped<a2dObjectPtr, a2dProperty>;

template class a2dSmrtPtrList<a2dObject>;

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

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

static int wxGenIdCount = 0;

A2DGENERALDLLEXP long wxGenNewId()
{
    return ++ wxGenIdCount;
}

A2DGENERALDLLEXP void wxGenRegisterId( long id )
{
    wxGenIdCount = id;
}

//!@{      \ingroup errorcodes
const a2dError a2dError_NoError( wxT("a2dError_NoError"), wxT("All Oke") );
const a2dError a2dError_CommandError( wxT("a2dError_CommandError"), wxT("") );
const a2dError a2dError_NotSpecified( wxT("a2dError_NotSpecified"), wxT("") );
const a2dError a2dError_CanceledFileDialog( wxT("a2dError_CanceledFileDialog"), wxT("") );
const a2dError a2dError_FileCouldNotOpen( wxT("a2dError_FileCouldNotOpen"), _("Sorry, could not open file for saving") );
const a2dError a2dError_CouldNotCreateDocument( wxT("a2dError_CouldNotCreateDocument"), wxT("") );
const a2dError a2dError_NoDocTemplateRef( wxT("a2dError_NoDocTemplateRef"), wxT("") );
const a2dError a2dError_DocumentsOpened( wxT("a2dError_DocumentsOpened"), _("No template defined in a2dDocument::OnSaveAsDocument") );
const a2dError a2dError_SetEnv( wxT("a2dError_SetEnv"), wxT("") );
const a2dError a2dError_GetEnv( wxT("a2dError_GetEnv"), wxT("") );
const a2dError a2dError_GetVar( wxT("a2dError_GetVar"), wxT("") );
const a2dError a2dError_SaveFile( wxT("a2dError_SaveFile"), _("Sorry, could not save document to file") );
const a2dError a2dError_LoadFile( wxT("a2dError_LoadFile"),  _("Sorry, could not load file into document") );
const a2dError a2dError_ExportFile( wxT("a2dError_ExportFile"), _("Sorry, could not export document to file") );
const a2dError a2dError_ImportFile( wxT("a2dError_ImportFile"),  _("bad stream") );
const a2dError a2dError_IOHandler( wxT("a2dError_IOHandler"), _("suitable template I/O handler for loading not available in document templates") );
const a2dError a2dError_SaveObject( wxT("a2dError_SaveObject"), _("I/O handler cannot save document" ) );
const a2dError a2dError_LoadObject( wxT("a2dError_LoadObject"), _("I/O handler cannot load document" ) );
const a2dError a2dError_FileHistory( wxT("a2dError_FileHistory"), wxT("") );
const a2dError a2dError_ImportObject( wxT("a2dError_ImportObject"), wxT("") );
const a2dError a2dError_XMLparse( wxT("a2dError_XMLparse"), wxT("") );
const a2dError a2dError_LoadLayers( wxT("a2dError_LoadLayers"), _("Could not load layers") );
const a2dError a2dError_property( wxT("a2dError_property"), _("problems on property") );
const a2dError a2dError_NoView( wxT("a2dError_NoView"), _("Not a a2dCanvasView View") );
const a2dError a2dError_NoDocument( wxT("a2dError_NoDocument"), _("No document set for a2dCanvasView in a2dCentralCanvasCommandProcessor::SetShowObject()") );
const a2dError a2dError_NoController( wxT("a2dError_NoController"), _("No controller set for current view") );
const a2dError a2dError_NoTool( wxT("a2dError_NoTool"), _("No tool available") );
const a2dError a2dError_LinkRef( wxT("a2dError_LinkRef"), wxT("") );
const a2dError a2dError_NoWrapper( wxT("a2dError_NoWrapper"), wxT("") );
const a2dError a2dError_LinkPin( wxT("a2dError_LinkPin"), wxT("") );
const a2dError a2dError_NoPinClass( wxT("a2dError_NoPinClass"), wxT("") );
const a2dError a2dError_CouldNotEvaluatePath( wxT("a2dError_CouldNotEvaluatePath"), wxT("") );
const a2dError a2dError_Canceled( wxT("a2dError_Canceled"), wxT("") );
const a2dError a2dError_CouldNotLoad( wxT("a2dError_CouldNotLoad"), _("I/O handler error during loading this format.") );
const a2dError a2dError_NoSelection( wxT("a2dError_NoSelection"), wxT("") );
const a2dError a2dError_ToManyOpen( wxT("a2dError_ToManyOpen"), wxT("") );
const a2dError a2dError_canvasObjectRelease( wxT("a2dError_canvasObjectRelease"), _("could not release a2dCanvasObject in a2dCommand_ReleaseObject::Do") );
//!@}

a2dErrorHash& a2dError::GetHashMap()
{
    static a2dMemoryCriticalSectionHelper helper;
    static a2dErrorHash ms_Name2Id;
    return ms_Name2Id;
}


#if (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))
// by using it, but it is not fully instantiated as required for a library
#ifdef _MSC_VER
#pragma warning(disable: 4660)
#endif

// Explicit template instantiations for DLL

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
    template class A2DGENERALDLLEXP a2dSmrtPtr<a2dObject>;
    template class A2DGENERALDLLEXP a2dPropertyIdTyped<a2dSmrtPtr<a2dObject>, a2dProperty>;
    template class A2DGENERALDLLEXP a2dAutoZeroPtr<class a2dObject>;
    template class A2DGENERALDLLEXP a2dPropertyIdTyped<a2dAutoZeroPtr<a2dObject>, a2dAutoZeroProperty>;
    template class A2DGENERALDLLEXP a2dPropertyIdTyped<a2dPathList,     a2dPathListProperty>   ;
//  template class A2DGENERALDLLEXP a2dSmrtPtr<a2dIOHandler>;
    template class A2DGENERALDLLEXP a2dSmrtPtrList<a2dObject>;
    template class A2DGENERALDLLEXP a2dlist<class a2dSmrtPtr<class a2dObject> >;
#endif

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

#endif // (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))

IMPLEMENT_ABSTRACT_CLASS(a2dObject,wxObject)
IMPLEMENT_ABSTRACT_CLASS(a2dNamedProperty,a2dObject)
IMPLEMENT_DYNAMIC_CLASS(a2dProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dAutoZeroProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dBoolProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dStringProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dVoidPtrProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dInt16Property,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dUint16Property,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dInt32Property,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dUint32Property,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dDoubleProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dFloatProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dArrayStringProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dFileNameProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dMenuProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dWindowProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dTipWindowProperty,a2dWindowProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dDateTimeProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dPathListProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dColourProperty,a2dNamedProperty)
IMPLEMENT_DYNAMIC_CLASS(a2dPropObject, a2dObject)
IMPLEMENT_DYNAMIC_CLASS(a2dObjectProperty, a2dNamedProperty )

WX_DEFINE_LIST( a2dResolveIdList );

//----------------------------------------------------------------------------
// a2dResolveIdInfo
//----------------------------------------------------------------------------

bool a2dResolveIdInfo::Assign( a2dObject *ptr )
{
    switch ( m_mode )
    {
    case mode_a2dObjectSmrtPtr:
        if( !ptr )
            return false;
        *m_storedHere.m_a2dObjectSmrtPtr = wxStaticCast( ptr, a2dObject );
        return true;

    case mode_a2dObjectAutoZeroPtr:
        if( !ptr )
            return false;
        *m_storedHere.m_a2dObjectAutoZeroPtr = wxStaticCast( ptr, a2dObject );
        return true;

    case mode_link:
        return m_storedHere.m_link->LinkReference( ptr );

    case mode_inform:
        m_storedHere.m_inform->ResolveInform();
        return true;

    default:
        wxASSERT(0);
        return false;
    }
}

//----------------------------------------------------------------------------
// a2dObject
//----------------------------------------------------------------------------

#ifdef _DEBUG
// Here are two globals that can be used as registers in the debugger
a2dObject *_dbro1 = 0;
a2dObject *_dbro2 = 0;
#endif

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    A2DGENERALDLLEXP_DATA (wxObject *) CurrentSmartPointerOwner = 0;
#endif

a2dPropertyIdBool* a2dObject::PROPID_Check = NULL;

INITIALIZE_PROPERTIES_BASE( a2dObject )
{
    PROPID_Check = new a2dPropertyIdBool( wxT("Check"),
        a2dPropertyId::flag_temporary | a2dPropertyId::flag_norender, false,
        a2dPropertyIdBool::Get( &a2dObject::GetCheck ),
        a2dPropertyIdBool::Set( &a2dObject::SetCheck ) );
    AddPropertyId( PROPID_Check );
    return true;
}

a2dNamedProperty* a2dObject::GetProperty( const a2dPropertyId* propertyId, a2dPropertyId::Flags flags ) const
{
    static a2dNamedPropertyPtr returnproperty = NULL;

    // now assemble properties with this id, which is normally just one.
    a2dNamedPropertyList props;
    CollectProperties2( &props, propertyId, flags );
    // normally just one found with this specific Id.
    if( props.begin() != props.end() )
        returnproperty = *props.begin();
    else
        returnproperty = NULL;
    return returnproperty;
}

void a2dObject::SetProperty( a2dNamedProperty* propertyHolder, a2dPropertyId::SetFlags setflags )
{
    wxASSERT( !m_recursion_active );

    propertyHolder->GetId()->SetNamedPropertyToObject( this, propertyHolder );
    OnPropertyChanged( propertyHolder->GetId() );
}

void a2dObject::SetProperty( const a2dNamedProperty& propertyHolder, a2dPropertyId::SetFlags setflags )
{
    wxASSERT( !m_recursion_active );

    propertyHolder.GetId()->SetNamedPropertyToObject( this, const_cast<a2dNamedProperty*>(&propertyHolder) );
    OnPropertyChanged( propertyHolder.GetId() );
}

bool a2dObject::AddProperty( a2dNamedProperty *property )
{
    static a2dNamedPropertyPtr prop = NULL;
    prop = property;
    return false;
}

bool a2dObject::RemoveProperty( const a2dPropertyId* WXUNUSED(id), bool WXUNUSED(all) )
{
    return false;
}

bool a2dObject::HasProperty( const a2dPropertyId* id, const wxString &stringvalue ) const
{
    if ( ! HasPropertyId( id ) )
        return false;

    bool ret = false;
    a2dNamedPropertyPtr prop = GetProperty( id );
    if ( prop && ! stringvalue.IsEmpty() )
        ret = prop->StringValueRepresentation() == stringvalue;
    else
        ret = prop.Get() != NULL;
    return ret;
}

a2dObject::a2dObject()
{
    m_refcount = 0;
    m_autozeroptrlist = 0;
    m_check = false;
    m_release = false;
    m_recursion_active = false;
    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        m_ownerlist = 0;
        CurrentSmartPointerOwner = this;
    #endif
}

a2dObject::a2dObject( const a2dObject& other )
    :wxObject( other )
{
    m_refcount = 0;
    m_autozeroptrlist = 0;
    m_check = false;
    m_release = false;
    m_recursion_active = false;

    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        m_ownerlist = 0;
        CurrentSmartPointerOwner = this;
    #endif
}

a2dObject::~a2dObject()
{
    wxASSERT_MSG(  m_refcount == 0 || m_refcount == refcount_nondynamic, wxT("deleting a2dObject while referenced") );
    m_autozeroptrlist->TargetDestructing();
}

void a2dObject:: operator = ( const a2dObject& WXUNUSED(other) )
{
    // m_refcount is not touched
    // m_autozerolist is not touched
    // m_ownerlist is not touched
    // m_recusionactive is not touched
    // m_check is not touched
}

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

#if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
void a2dObject::Dump(wxSTD ostream& str)
{
        str << GetUniqueSerializationId();
}
#endif

void a2dObject::CheckReferences()
{
    if ( m_refcount <= 0 )
        delete this;
}

bool a2dObject::SmrtPtrRelease()
{
    m_refcount--;
    wxASSERT_MSG( m_refcount >= 0, wxT("a2dObject Own/Release not matched (extra Release calls)") );
    if ( m_refcount <= 0 )
    {
        delete this;
        return true;
    }
    return false;
}

a2dObject* a2dObject::SetNonDynamic()
{
    wxASSERT_MSG( m_refcount == 0, wxT("Setting a referenced a2dObject to non-dynamic") );
    m_refcount += refcount_nondynamic;
    return this;
}

wxString a2dObject::GetName() const
{
    return wxString::Format(wxT("%d"), GetUniqueSerializationId() );
}

#if wxART2D_USE_CVGIO
void a2dObject::Save( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dObjectList* towrite )
{
    //only write once, if already written,
    if ( m_check == true )
    {
        //save this object as a reference to another by only writing one id attribute.
        out.WriteStartElementAttributes( wxT("o") );
        out.WriteAttribute( wxT("classname"), GetClassInfo()->GetClassName() );
        out.WriteAttribute( wxT("refid"), GetUniqueSerializationId() );
        out.WriteEndAttributes();
        out.WriteEndElement();
        return;
    }

    if( IsTemporary_DontSave())
        return;

    out.WriteStartElementAttributes( wxT("o") );
    out.WriteAttribute( wxT("classname"), GetClassInfo()->GetClassName() );
    if( m_refcount > 1 || AlwaysWriteSerializationId() )
        out.WriteAttribute( wxT("id"), GetUniqueSerializationId() );
    //the default name is same as address of object, there is no need to save that.
    wxString idstr;
    idstr << GetUniqueSerializationId();
    if ( GetName() != idstr )
        out.WriteAttribute( wxT("name"), GetName() );

    DoSave( parent, out, a2dXmlSer_attrib, towrite );

    out.WriteEndAttributes();

    DoSave( parent, out, a2dXmlSer_Content, towrite );

    out.WriteEndElement();
    m_check = true;
}


void a2dObject::Load( wxObject* parent, a2dIOHandlerXmlSerIn& parser )
{
    parser.Require( START_TAG, wxT("o") );
    parser.SetLastObjectLoadedId( wxT("") );

    if ( parser.HasAttribute( wxT("refid") ) )
    {
        // If the object has a refid, preserve refid in
        wxUint32 refId = parser.GetAttributeValueInt( wxT("refid") );

        if ( refId )
        {
            wxString resolveKey;
            resolveKey << refId;
            parser.SetLastObjectLoadedId( resolveKey );
        }
        m_check = true;

/*      If this is needed again for some reason, that's wrong, only a reference id should be enough.
        So think twice:
        <o classname="a2dArc" refid="4660970"> </o>

        DoLoad( parent, parser, a2dXmlSer_attrib );
        parser.Next();

        DoLoad( parent, parser, a2dXmlSer_Content );
*/
        parser.Next();
        parser.Require( END_TAG, wxT("o") );
        parser.Next();

        return;
    }

    if ( parser.HasAttribute( wxT("id") ) )
    {
        // If the object has an id, insert the object into the object hash map
        int id = parser.GetAttributeValueInt( wxT("id") );
        wxASSERT( id!=0 );
        wxString resolveKey;
        resolveKey << id;
        parser.GetObjectHashMap()[resolveKey] = this;
    }

    DoLoad( parent, parser, a2dXmlSer_attrib );
    parser.Next();

    DoLoad( parent, parser, a2dXmlSer_Content );

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

#if wxART2D_USE_CVGIO
void a2dObject::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut& WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts) , a2dObjectList* WXUNUSED(towrite) )
{
}

void a2dObject::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
}
#endif //wxART2D_USE_CVGIO

wxInt64 a2dObject::GetUniqueSerializationId() const
{
    return ((wxInt64) this) >> 3;
}

bool a2dObject::AlwaysWriteSerializationId() const
{
    return false;
}

bool a2dObject::LinkReference( a2dObject* WXUNUSED(other) )
{
    // This should only happen, if the class has put a a2dResolveIdInfo in the list
    wxASSERT(0);
    return false;
}

void a2dObject::ResolveInform(  )
{
    // This should only happen, if the class has put a a2dResolveIdInfo in the list
    wxASSERT(0);
}

void a2dObject::Walker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    if ( handler.GetUseCheck() && GetCheck() )
        return;

    handler.IncCurrentDepth();

    handler.WalkTask( parent, this, a2dWalker_a2dObjectStart );

    DoWalker( parent, handler );

    handler.WalkTask( parent, this, a2dWalker_a2dObjectEnd );
    handler.DecCurrentDepth();
}

void a2dObject::DoWalker( wxObject *parent, a2dWalkerIOHandler& WXUNUSED(handler) )
{
}

bool a2dObject::DistributeEvent( wxEvent& event )
{
    if ( a2dGeneralGlobals && a2dGeneralGlobals->GetEventDistributer() )
        return a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );
    return false;
}

//----------------------------------------------------------------------------
// a2dNamedProperty
//----------------------------------------------------------------------------
#ifdef _DEBUG
static int _debug_cnt;
#endif

#ifdef CLASS_MEM_MANAGEMENT
a2dMemManager a2dNamedProperty::sm_memManager(wxT("a2dNamedProperty memory manager"));
#endif //CLASS_MEM_MANAGEMENT

a2dNamedProperty::a2dNamedProperty()
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_ownerlist = NULL;
#endif

    m_id = 0;

    #ifdef _DEBUG
        _debug_id = _debug_cnt++;
    //      wxLogDebug( wxT("%p=%d"), this, _debug_id );
    #endif

    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        CurrentSmartPointerOwner = this;
    #endif
}

a2dNamedProperty::a2dNamedProperty( const a2dPropertyId* id )
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_ownerlist = NULL;
#endif
    m_id = id;

    #ifdef _DEBUG
        _debug_id = _debug_cnt++;
    //      wxLogDebug( wxT("%p=%d"), this, _debug_id );
    #endif

    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        CurrentSmartPointerOwner = this;
    #endif
}

a2dNamedProperty::a2dNamedProperty( const a2dNamedProperty &other )
:   a2dObject( other )
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_ownerlist = NULL;
#endif
    m_id = other.m_id;

    #ifdef _DEBUG
        _debug_id = _debug_cnt++;
    //      wxLogDebug( wxT("%p=%d"), this, _debug_id );
    #endif

    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        CurrentSmartPointerOwner = this;
    #endif
}

a2dNamedProperty::~a2dNamedProperty()
{
}

#if wxART2D_USE_CVGIO
void a2dNamedProperty::Save( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dObjectList* towrite )
{
    if( m_id->IsTemporary() )
        return;

    out.WriteStartElementAttributes( wxT("o") );
    out.WriteAttribute( wxT("classname"), GetClassInfo()->GetClassName() );
    out.WriteAttribute( wxT("name"), m_id->GetName() );

    DoSave( parent, out, a2dXmlSer_attrib, towrite );

    out.WriteEndAttributes();

    DoSave( parent, out, a2dXmlSer_Content, towrite );

    out.WriteEndElement();
}


void a2dNamedProperty::Load( wxObject* parent, a2dIOHandlerXmlSerIn& parser )
{
    parser.Require( START_TAG, wxT("o") );

    wxString name;
    name = parser.RequireAttributeValue( wxT("name") );

    a2dPropertyId *id = wxStaticCast( parent, a2dPropObject )->HasPropertyId( name );
    if ( !id )
    {
        //id = new a2dPropertyIdInt32( CLASSNAME( a2dPropObject ), name, a2dPropertyId::flag_none, 0 );
        //id->SetPropertyToObject( parent, 0 );
        //a2dGeneralGlobals->GetPropertyIdList()->push_back( id );

        wxString error;
        error.Printf( wxT("Property with name: %s has no internal a2dPropertyId binding name to internal property"), name.c_str() );
        a2dGeneralGlobals->ReportErrorF( a2dError_XMLparse, error );
        parser.SetLastError( a2dGeneralGlobals->GetLastError() );
    }

    DoLoad( parent, parser, a2dXmlSer_attrib );

    parser.Next();

    DoLoad( parent, parser, a2dXmlSer_Content );

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

#if wxART2D_USE_CVGIO
void a2dNamedProperty::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut& WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts), a2dObjectList* WXUNUSED(towrite) )
{
}

void a2dNamedProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    if ( xmlparts == a2dXmlSer_attrib )
    {
        wxString name  = parser.RequireAttributeValue( wxT("name") );
        m_id = wxStaticCast( parent, a2dPropObject )->HasPropertyId( name );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO


void a2dNamedProperty::Walker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, this, a2dWalker_a2dNamedPropertyStart );
    handler.IncCurrentDepth();

    DoWalker( parent, handler );

    handler.WalkTask( parent, this, a2dWalker_a2dNamedPropertyEnd );
    handler.DecCurrentDepth();
}

void a2dNamedProperty::DoWalker( wxObject *parent, a2dWalkerIOHandler& WXUNUSED(handler) )
{
}

wxString a2dNamedProperty::GetString() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dStringProperty") );
    return wxT("");
}

double a2dNamedProperty::GetDouble() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dDoubleProperty") );
    return 0.0;
}

float a2dNamedProperty::GetFloat() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dFloatProperty") );
    return 0.0;
}

bool a2dNamedProperty::GetBool() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dBoolProperty") );
    return false;
}

wxInt16 a2dNamedProperty::GetInt16() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dInt16Property") );
    return 0;
}

wxUint16 a2dNamedProperty::GetUint16() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dUint16Property") );
    return 0;
}

wxInt32 a2dNamedProperty::GetInt32() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dInt32Property") );
    return 0;
}

wxUint32 a2dNamedProperty::GetUint32() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dUint32Property") );
    return 0;
}

void* a2dNamedProperty::GetVoidPtr() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dVoidPtrProperty") );
    return 0;
}

a2dObject* a2dNamedProperty::GetRefObject() const
{
    wxASSERT_MSG( 0, wxT("Not derived from a2dProperty") );
    return 0;
}

a2dObject* a2dNamedProperty::GetRefObjectNA() const
{
    return 0;
}

double a2dNamedProperty::ParseDouble( unsigned int& position )
{
    const wxChar* buffer = StringValueRepresentation().c_str();

    const wxChar *start = buffer + position;
    wxChar *end;
    double val = wxStrtod(start, &end);
    position = end - buffer;

    if ( start == end )
        a2dGeneralGlobals->ReportErrorF( a2dError_NotSpecified, _("Not a number while parsing string %s"), start );

    return val;
}

void a2dNamedProperty::SkipCommaSpaces( unsigned int& position )
{
    char current;
    for(;;)
    {
        current = StringValueRepresentation()[position];
        switch (current)
        {
            default:
                return;
            case wxT(','): case 0x20: case 0x09: case 0x0D: case 0x0A:
                position++;
                break;
        }
    }
}

void a2dNamedProperty::SkipSpaces( unsigned int& position )
{
    char current;
    for(;;)
    {
        current = StringValueRepresentation()[position];
        switch (current)
        {
            default:
                return;
            case 0x20: case 0x09: case 0x0D: case 0x0A:
                position++;
                break;
        }
    }
}

//----------------------------------------------------------------------------
// a2dNamedPropertyList
//----------------------------------------------------------------------------

a2dNamedPropertyList::a2dNamedPropertyList( const a2dNamedPropertyList &other )
{
    // Copy the list of property object

    a2dNamedPropertyList::const_iterator iter;
    for( iter = other.begin(); iter != other.end(); ++iter )
    {
        a2dNamedProperty *obj = *iter;
        push_back( obj->Clone( a2dObject::clone_flat ) );

    }
}

a2dNamedPropertyList::~a2dNamedPropertyList()
{
}

bool a2dNamedPropertyList::Remove( const a2dPropertyId* id, bool all )
{
    bool did=false;

    a2dNamedPropertyList::iterator iter = begin();
    while( iter != end() )
    {
        a2dNamedProperty *prop = *iter;
        if ( prop->GetId() == id )
        {
            iter = erase( iter );
            if (!all)
            {
                return true;
            }
            else
                did = true;
        }
        else
            iter++;
    }
    return did;
}

void a2dNamedPropertyList::RemoveTemporary()
{
    a2dNamedPropertyList::iterator iter = begin();
    while( iter != end() )
    {
        a2dNamedProperty *prop = *iter;
        if ( prop->GetId()->IsTemporary() )
        {
            iter = erase( iter );
        }
        else
            iter++;
    }
}

void a2dNamedPropertyList::Walker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, parent, a2dWalker_a2dNamedPropertyListStart );

    a2dNamedPropertyList::iterator iter = begin();
    iter = begin();
    while( iter != end() )
    {
        a2dNamedProperty *prop = *iter;
        prop->Walker( parent, handler );
        iter++;
    }

    handler.WalkTask( parent, parent, a2dWalker_a2dNamedPropertyListEnd );
}

//----------------------------------------------------------------------------
// a2dBoolProperty
//----------------------------------------------------------------------------

a2dBoolProperty::a2dBoolProperty(): a2dNamedProperty()
{
    m_value = true;
}

a2dBoolProperty::a2dBoolProperty( const a2dPropertyIdBool* id, bool value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dBoolProperty::~a2dBoolProperty()
{
}

a2dBoolProperty::a2dBoolProperty( const a2dBoolProperty &other, a2dObject::CloneOptions WXUNUSED(options) )
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty* a2dBoolProperty::Clone( a2dObject::CloneOptions options ) const
{
    return new a2dBoolProperty( *this, options );
};

void a2dBoolProperty::Assign( const a2dNamedProperty &other )
{
    a2dBoolProperty *propcast = wxStaticCast( &other, a2dBoolProperty);
    m_value = propcast->m_value;
}

a2dBoolProperty *a2dBoolProperty::CreatePropertyFromString( const a2dPropertyIdBool* id, const wxString &value )
{
    // Remove leading/trailing spaces and convert to lowercase.
    wxString lower = value.Lower().Trim( true ).Trim( false );
    // Notice that _("yes") is different from wxT("yes"),since it allows for i18n, so it could read as wxT("ja").
    bool val = ( lower == wxT("true") ) || ( lower == wxT("yes") ) || ( lower == wxT("y") ) || ( lower == wxT("1") ) || ( lower == _("yes") );

    return new a2dBoolProperty( id, val );
}

#if wxART2D_USE_CVGIO
void a2dBoolProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dBoolProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser.GetAttributeValueBool( wxT("value"), true );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dBoolProperty::SetValue( bool value )
{
    m_value = value;
}

wxString a2dBoolProperty::StringRepresentation() const
{
    return m_value == true? GetName() + wxT("true"): GetName() + wxT("false");
}

wxString a2dBoolProperty::StringValueRepresentation() const
{
    return m_value == true? wxT("true"): wxT("false");
}

//----------------------------------------------------------------------------
// a2dStringProperty
//----------------------------------------------------------------------------

a2dStringProperty::a2dStringProperty(): a2dNamedProperty()
{
    m_value = wxT("");
}

a2dStringProperty::a2dStringProperty( const a2dPropertyIdString* id, const wxString& value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dStringProperty::~a2dStringProperty()
{
}

a2dStringProperty::a2dStringProperty( const a2dStringProperty &other, a2dObject::CloneOptions WXUNUSED(options) )
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dStringProperty::Clone( a2dObject::CloneOptions options ) const
{
    return new a2dStringProperty( *this, options );
};

void a2dStringProperty::Assign( const a2dNamedProperty &other )
{
    a2dStringProperty *propcast = wxStaticCast( &other, a2dStringProperty);
    m_value = propcast->m_value;
}

a2dStringProperty *a2dStringProperty::CreatePropertyFromString( const a2dPropertyIdString* id, const wxString &value )
{
    return new a2dStringProperty( id, value );
}

#if wxART2D_USE_CVGIO
void a2dStringProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dStringProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser.GetAttributeValue( wxT("value"), wxT("") );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dStringProperty::SetValue( const wxString& value )
{
    m_value = value;
}

//----------------------------------------------------------------------------
// a2dObjectProperty
//----------------------------------------------------------------------------

a2dObjectProperty::a2dObjectProperty(): a2dNamedProperty()
{
}

a2dObjectProperty::a2dObjectProperty( const a2dPropertyIdObject* id, const wxObject& value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dObjectProperty::~a2dObjectProperty()
{
}

a2dObjectProperty::a2dObjectProperty( const a2dObjectProperty &other )
    : a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dObjectProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dObjectProperty(*this );
};

void a2dObjectProperty::Assign( const a2dNamedProperty &other )
{
    a2dObjectProperty *propcast = wxStaticCast( &other, a2dObjectProperty);
    m_value = propcast->m_value;
}

void a2dObjectProperty::SetValue( const wxObject& value )
{
    m_value = value;
}

//----------------------------------------------------------------------------
// a2dVoidPtrProperty
//----------------------------------------------------------------------------

a2dVoidPtrProperty::a2dVoidPtrProperty(): a2dNamedProperty()
{
    m_value = NULL;
}

a2dVoidPtrProperty::a2dVoidPtrProperty( const a2dPropertyIdVoidPtr* id, void* value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dVoidPtrProperty::~a2dVoidPtrProperty()
{
}

a2dVoidPtrProperty::a2dVoidPtrProperty( const a2dVoidPtrProperty &other )
    : a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dVoidPtrProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dVoidPtrProperty(*this );
};

void a2dVoidPtrProperty::Assign( const a2dNamedProperty &other )
{
    a2dVoidPtrProperty *propcast = wxStaticCast( &other, a2dVoidPtrProperty);
    m_value = propcast->m_value;
}

a2dVoidPtrProperty *a2dVoidPtrProperty::CreatePropertyFromString( const a2dPropertyIdVoidPtr* WXUNUSED(id), const wxString& WXUNUSED(value) )
{
    return 0;
}

#if wxART2D_USE_CVGIO
void a2dVoidPtrProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), wxT("VOID") );
    }
    else
    {
    }
}

void a2dVoidPtrProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = NULL;
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dVoidPtrProperty::SetValue( void* value )
{
    m_value = value;
}

wxString a2dVoidPtrProperty::StringRepresentation() const
{
    return m_value == 0 ?  GetName() + wxT("NULL"): GetName() + wxT("VOID");
}

wxString a2dVoidPtrProperty::StringValueRepresentation() const
{
    return m_value == 0 ? wxT("NULL") : wxT("VOID");
}

//----------------------------------------------------------------------------
// a2dProperty
//----------------------------------------------------------------------------

a2dProperty::a2dProperty(): a2dNamedProperty()
{
    m_value = NULL;
}

a2dProperty::a2dProperty( const a2dPropertyIdRefObject* id, a2dObject* value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dProperty::~a2dProperty()
{
}

a2dProperty::a2dProperty( const a2dProperty &other, a2dObject::CloneOptions options )
    : a2dNamedProperty( other )
{
    if ( options & a2dObject::clone_properties && m_id->IsCloneDeep() )
    {
        if ( other.m_value )
            m_value = other.m_value->Clone( options );
    }
    else
        m_value = other.m_value;

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

a2dNamedProperty *a2dProperty::Clone( a2dObject::CloneOptions options ) const
{
    return new a2dProperty( *this, options );
};

void a2dProperty::Assign( const a2dNamedProperty &other )
{
    a2dProperty *propcast = wxStaticCast( &other, a2dProperty);
    m_value = propcast->m_value;
}

a2dProperty *a2dProperty::CreatePropertyFromString( const a2dPropertyIdRefObject* WXUNUSED(id), const wxString& WXUNUSED(value) )
{
    return 0;
}

#if wxART2D_USE_CVGIO
void a2dProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        if ( m_value )
            m_value->Save( parent, out, towrite  );
    }
}

void a2dProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = NULL;
    }
    else
    {
        if ( parser.GetTagName() == wxT("o")  && parser.GetEventType() != END_TAG )
        {
            parser.Require( START_TAG, wxT("o") );

            wxString classname = parser.GetAttributeValue( wxT("classname") );
            m_value = wxDynamicCast( parser.CreateObject( classname ), a2dObject );
            if ( !m_value )
            {
                a2dGeneralGlobals->ReportErrorF( a2dError_XMLparse, _("could not create a2dObject %s, will be skipped line %d"),
                    classname.c_str(), parser.GetCurrentLineNumber() );
                parser.SetLastError( a2dGeneralGlobals->GetLastError() );

                parser.SkipSubTree();
                parser.Require( END_TAG, wxT("o") );
                parser.Next();
            }
            else
            {
                m_value->Load( this, parser );
                parser.ResolveOrAdd( &m_value );
            }

        }
    }
}
#endif //wxART2D_USE_CVGIO

void a2dProperty::SetValue( a2dObject* value )
{
    m_value = value;
}

wxString a2dProperty::StringRepresentation() const
{
    return m_value ?  GetName() + wxT("NULL"): GetName() + wxT("RefObject");
}

wxString a2dProperty::StringValueRepresentation() const
{
    return m_value ? wxT("NULL") : wxT("RefObject");
}

//----------------------------------------------------------------------------
// a2dAutoZeroProperty
//----------------------------------------------------------------------------

a2dAutoZeroProperty::a2dAutoZeroProperty(): a2dNamedProperty()
{
    m_value = NULL;
}

a2dAutoZeroProperty::a2dAutoZeroProperty( const a2dPropertyIdRefObjectAutoZero* id, a2dObject* value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dAutoZeroProperty::~a2dAutoZeroProperty()
{
}

a2dAutoZeroProperty::a2dAutoZeroProperty( const a2dAutoZeroProperty &other, a2dObject::CloneOptions options )
    : a2dNamedProperty( other )
{
    if ( options & a2dObject::clone_properties && m_id->IsCloneDeep() )
    {
        if ( other.m_value )
            m_value = other.m_value->Clone( options );
    }
    else
        m_value = other.m_value;

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

a2dNamedProperty *a2dAutoZeroProperty::Clone( a2dObject::CloneOptions options ) const
{
    return new a2dAutoZeroProperty( *this, options );
};

void a2dAutoZeroProperty::Assign( const a2dNamedProperty &other )
{
    a2dAutoZeroProperty *propcast = wxStaticCast( &other, a2dAutoZeroProperty);
    m_value = propcast->m_value;
}

a2dAutoZeroProperty *a2dAutoZeroProperty::CreatePropertyFromString( const a2dPropertyIdRefObjectAutoZero* WXUNUSED(id), const wxString& WXUNUSED(value) )
{
    return 0;
}

#if wxART2D_USE_CVGIO
void a2dAutoZeroProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        if ( m_value )
            m_value->Save( parent, out, towrite  );
    }
}

void a2dAutoZeroProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = NULL;
    }
    else
    {
        if ( parser.GetTagName() == wxT("o")  && parser.GetEventType() != END_TAG )
        {
            parser.Require( START_TAG, wxT("o") );

            wxString classname = parser.GetAttributeValue( wxT("classname") );
            m_value = wxStaticCast( parser.CreateObject( classname ), a2dObject );
            if ( !m_value )
            {
                a2dGeneralGlobals->ReportErrorF( a2dError_XMLparse, _("could not create a2dObject %s, will be skipped line %d"),
                    classname.c_str(), parser.GetCurrentLineNumber() );
                parser.SkipSubTree();
                parser.Require( END_TAG, wxT("o") );
                parser.Next();
            }
            else
            {
                m_value->Load( this, parser );
                parser.ResolveOrAdd( &m_value );
            }

        }
    }
}
#endif //wxART2D_USE_CVGIO

void a2dAutoZeroProperty::SetValue( a2dObject* value )
{
    m_value = value;
}

wxString a2dAutoZeroProperty::StringRepresentation() const
{
    return m_value ?  GetName() + wxT("NULL"): GetName() + wxT("RefObject");
}

wxString a2dAutoZeroProperty::StringValueRepresentation() const
{
    return m_value ? wxT("NULL") : wxT("RefObject");
}

//----------------------------------------------------------------------------
// a2dInt16Property
//----------------------------------------------------------------------------

a2dInt16Property::a2dInt16Property(): a2dNamedProperty()
{
    m_value = 0;
}

a2dInt16Property::a2dInt16Property( const a2dPropertyIdInt16* id, wxInt16 value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dInt16Property::~a2dInt16Property()
{
}

a2dInt16Property::a2dInt16Property( const a2dInt16Property &other )
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dInt16Property::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dInt16Property( *this );
};

void a2dInt16Property::Assign( const a2dNamedProperty &other )
{
    a2dInt16Property *propcast = wxStaticCast( &other, a2dInt16Property);
    m_value = propcast->m_value;
}

a2dInt16Property *a2dInt16Property::CreatePropertyFromString( const a2dPropertyIdInt16* id, const wxString &value )
{
    long intval;
    value.ToLong( &intval , 10 );
    return new a2dInt16Property( id, intval );
}

#if wxART2D_USE_CVGIO
void a2dInt16Property::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dInt16Property::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueInt( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dInt16Property::SetValue( wxInt16 value )
{
    m_value = value;
}

wxString a2dInt16Property::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %d"), GetName().c_str(), m_value );
    return  form;
}

wxString a2dInt16Property::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%d"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dUint16Property
//----------------------------------------------------------------------------

a2dUint16Property::a2dUint16Property(): a2dNamedProperty()
{
    m_value = 0;
}

a2dUint16Property::a2dUint16Property( const a2dPropertyIdUint16* id, wxUint16 value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dUint16Property::~a2dUint16Property()
{
}

a2dUint16Property::a2dUint16Property( const a2dUint16Property &other )
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dUint16Property::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dUint16Property( *this );
};

void a2dUint16Property::Assign( const a2dNamedProperty &other )
{
    a2dUint16Property *propcast = wxStaticCast( &other, a2dUint16Property);
    m_value = propcast->m_value;
}

a2dUint16Property *a2dUint16Property::CreatePropertyFromString( const a2dPropertyIdUint16* id, const wxString &value )
{
    unsigned long intval;
    value.ToULong( &intval , 10 );
    return new a2dUint16Property( id, intval );
}

#if wxART2D_USE_CVGIO
void a2dUint16Property::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dUint16Property::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueInt( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dUint16Property::SetValue( wxUint16 value )
{
    m_value = value;
}

wxString a2dUint16Property::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %d"), GetName().c_str(), m_value );
    return  form;
}

wxString a2dUint16Property::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%d"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dInt32Property
//----------------------------------------------------------------------------

a2dInt32Property::a2dInt32Property(): a2dNamedProperty()
{
    m_value = 0;
}

a2dInt32Property::a2dInt32Property( const a2dPropertyIdInt32* id, wxInt32 value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dInt32Property::~a2dInt32Property()
{
}

a2dInt32Property::a2dInt32Property( const a2dInt32Property &other )
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dInt32Property::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dInt32Property( *this );
};

void a2dInt32Property::Assign( const a2dNamedProperty &other )
{
    a2dInt32Property *propcast = wxStaticCast( &other, a2dInt32Property);
    m_value = propcast->m_value;
}

a2dInt32Property *a2dInt32Property::CreatePropertyFromString( const a2dPropertyIdInt32* id, const wxString &value )
{
    long intval;
    value.ToLong( &intval , 10 );
    return new a2dInt32Property( id, intval );
}

#if wxART2D_USE_CVGIO
void a2dInt32Property::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dInt32Property::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueInt( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dInt32Property::SetValue( wxInt32 value )
{
    m_value = value;
}

wxString a2dInt32Property::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %d"), GetName().c_str(), m_value );
    return  form;
}

wxString a2dInt32Property::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%d"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dUint32Property
//----------------------------------------------------------------------------

a2dUint32Property::a2dUint32Property(): a2dNamedProperty()
{
    m_value = 0;
}

a2dUint32Property::a2dUint32Property( const a2dPropertyIdUint32* id, wxUint32 value )
                        :a2dNamedProperty( id )
{
    m_value = value;
}

a2dUint32Property::~a2dUint32Property()
{
}

a2dUint32Property::a2dUint32Property( const a2dUint32Property &other)
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dUint32Property::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dUint32Property( *this );
};

void a2dUint32Property::Assign( const a2dNamedProperty &other )
{
    a2dUint32Property *propcast = wxStaticCast( &other, a2dUint32Property);
    m_value = propcast->m_value;
}

a2dUint32Property *a2dUint32Property::CreatePropertyFromString( const a2dPropertyIdUint32* id, const wxString &value )
{
    unsigned long intval;
    value.ToULong( &intval , 10 );
    return new a2dUint32Property( id, intval );
}

#if wxART2D_USE_CVGIO
void a2dUint32Property::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dUint32Property::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueInt( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dUint32Property::SetValue( wxUint32 value )
{
    m_value = value;
}

wxString a2dUint32Property::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %d"), GetName().c_str(), m_value );
    return  form;
}

wxString a2dUint32Property::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%d"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dDoubleProperty
//----------------------------------------------------------------------------

a2dDoubleProperty::a2dDoubleProperty(): a2dNamedProperty()
{
    m_value = 0.0;
}

a2dDoubleProperty::a2dDoubleProperty( const a2dPropertyIdDouble* id, double value )
                        : a2dNamedProperty( id )
{
    m_value = value;
}

a2dDoubleProperty::~a2dDoubleProperty()
{
}

a2dDoubleProperty::a2dDoubleProperty( const a2dDoubleProperty &other)
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dDoubleProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dDoubleProperty(*this);
};

void a2dDoubleProperty::Assign( const a2dNamedProperty &other )
{
    a2dDoubleProperty *propcast = wxStaticCast( &other, a2dDoubleProperty);
    m_value = propcast->m_value;
}

a2dDoubleProperty *a2dDoubleProperty::CreatePropertyFromString( const a2dPropertyIdDouble* id, const wxString &value )
{
    double doubleval;
    value.ToDouble( &doubleval );
    return new a2dDoubleProperty( id, doubleval );
}

#if wxART2D_USE_CVGIO
void a2dDoubleProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dDoubleProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueDouble( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dDoubleProperty::SetValue( double value )
{
    m_value = value;
}

wxString a2dDoubleProperty::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %6.3f"), GetName().c_str(), m_value );
    return form;
}

wxString a2dDoubleProperty::StringValueRepresentation() const
{
    wxString form;
    //form.Printf( wxT("%6.3f"), m_value );
    form.Printf( wxT("%g"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dFloatProperty
//----------------------------------------------------------------------------

a2dFloatProperty::a2dFloatProperty(): a2dNamedProperty()
{
    m_value = 0.0;
}

a2dFloatProperty::a2dFloatProperty( const a2dPropertyIdFloat* id, float value )
                        : a2dNamedProperty( id )
{
    m_value = value;
}

a2dFloatProperty::~a2dFloatProperty()
{
}

a2dFloatProperty::a2dFloatProperty( const a2dFloatProperty &other)
        :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dFloatProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dFloatProperty(*this);
};

void a2dFloatProperty::Assign( const a2dNamedProperty &other )
{
    a2dFloatProperty *propcast = wxStaticCast( &other, a2dFloatProperty);
    m_value = propcast->m_value;
}

a2dFloatProperty *a2dFloatProperty::CreatePropertyFromString( const a2dPropertyIdFloat* id, const wxString &value )
{
    double doubleval;
    value.ToDouble( &doubleval );
    return new a2dFloatProperty( id, (float) doubleval );
}

#if wxART2D_USE_CVGIO
void a2dFloatProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("value"), m_value );
    }
    else
    {
    }
}

void a2dFloatProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_value  = parser. GetAttributeValueDouble( wxT("value"), 0 );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dFloatProperty::SetValue( float value )
{
    m_value = value;
}

wxString a2dFloatProperty::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %6.3f"), GetName().c_str(), m_value );
    return form;
}

wxString a2dFloatProperty::StringValueRepresentation() const
{
    wxString form;
    //form.Printf( wxT("%6.3f"), m_value );
    form.Printf( wxT("%g"), m_value );
    return form;
}

//----------------------------------------------------------------------------
// a2dArrayStringProperty
//----------------------------------------------------------------------------

a2dArrayStringProperty::a2dArrayStringProperty(): a2dNamedProperty()
{
    m_value = wxArrayString();
}

a2dArrayStringProperty::a2dArrayStringProperty( const a2dPropertyIdArrayString* id, const wxArrayString& value )
    : a2dNamedProperty( id )
{
    m_value = value;
}

a2dArrayStringProperty::a2dArrayStringProperty( const a2dPropertyIdArrayString* id, const wxString& value )
    : a2dNamedProperty( id )
{
    wxStringTokenizer args( value, wxT(","));
    while ( args.HasMoreTokens() )
    {
        m_value.Add( args.GetNextToken() );
    }
}

a2dArrayStringProperty::~a2dArrayStringProperty()
{
}

a2dArrayStringProperty::a2dArrayStringProperty( const a2dArrayStringProperty &other)
    :a2dNamedProperty( other )
{
    m_value = other.m_value;
}

a2dNamedProperty *a2dArrayStringProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dArrayStringProperty(*this);
};

void a2dArrayStringProperty::Assign( const a2dNamedProperty &other )
{
    a2dArrayStringProperty *propcast = wxStaticCast( &other, a2dArrayStringProperty);
    m_value = propcast->m_value;
}

a2dArrayStringProperty *a2dArrayStringProperty::CreatePropertyFromString( const a2dPropertyIdArrayString* id, const wxString &value )
{
    wxArrayString valuenew;
    wxStringTokenizer args( value );
    while ( args.HasMoreTokens() )
    {
        valuenew.Add( args.GetNextToken() );
    }
    return new a2dArrayStringProperty( id, valuenew);
}

#if wxART2D_USE_CVGIO
void a2dArrayStringProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        wxString attrib;
        size_t j;
        for ( j=0; j < m_value.GetCount(); j++)
        {
            attrib += m_value.Item(j);
        }

        out.WriteAttribute( wxT("value"), attrib );
    }
    else
    {
    }
}

void a2dArrayStringProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        wxStringTokenizer args( parser.GetAttributeValue( wxT("value") ), wxT(",") );
        while ( args.HasMoreTokens() )
        {
            m_value.Add( args.GetNextToken() );
        }
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dArrayStringProperty::SetValue( const wxArrayString& value )
{
    m_value = value;
}

void a2dArrayStringProperty::Add( const wxString& value )
{
    m_value.Add( value );
}

wxString a2dArrayStringProperty::StringRepresentation() const
{
    wxString attrib;
    size_t j;
    for ( j=0; j < m_value.GetCount(); j++)
    {
        attrib += m_value.Item(j);
    }

    wxString form;
    form.Printf( wxT("%s = %s"), GetName().c_str(), attrib.c_str() );
    return form;
}

wxString a2dArrayStringProperty::StringValueRepresentation() const
{
    wxString attrib;
    size_t j;
    for ( j=0; j < m_value.GetCount(); j++)
    {
        attrib += m_value.Item(j);
    }

    wxString form;
    form.Printf( wxT("%s"), attrib.c_str() );
    return form;
}

//----------------------------------------------------------------------------
// a2dFileNameProperty
//----------------------------------------------------------------------------

a2dFileNameProperty::a2dFileNameProperty(): a2dNamedProperty()
{
    m_filenameObject = wxT("");
}

a2dFileNameProperty::a2dFileNameProperty( const a2dPropertyIdFileName* id, const wxFileName& filename )
                        : a2dNamedProperty( id )
{
    m_filenameObject = filename;
}

a2dFileNameProperty::~a2dFileNameProperty()
{
}

a2dFileNameProperty::a2dFileNameProperty( const a2dFileNameProperty &other)
        :a2dNamedProperty( other )
{
    m_filenameObject = other.m_filenameObject;
}

a2dNamedProperty *a2dFileNameProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dFileNameProperty(*this);
};

void a2dFileNameProperty::Assign( const a2dNamedProperty &other )
{
    a2dFileNameProperty *propcast = wxStaticCast( &other, a2dFileNameProperty);
    m_filenameObject = propcast->m_filenameObject;
}

a2dFileNameProperty *a2dFileNameProperty::CreatePropertyFromString( const a2dPropertyIdFileName* id, const wxString &value )
{
    wxFileName filenameval( value );
    return new a2dFileNameProperty( id, filenameval );
}

#if wxART2D_USE_CVGIO
void a2dFileNameProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        //!todo write complete filename object
        out.WriteAttribute( wxT("fullfilename"), m_filenameObject.GetFullPath() );
    }
    else
    {
    }
}

void a2dFileNameProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_filenameObject  = parser.GetAttributeValue( wxT("fullfilename"), wxT("") );
    }
    else
    {
    }

    //!todo read complete filename object
}
#endif //wxART2D_USE_CVGIO

void a2dFileNameProperty::SetValue( const wxFileName& filenameObject )
{
    m_filenameObject = filenameObject;
}

void a2dFileNameProperty::SetFileName( const wxFileName& filenameObject )
{
    m_filenameObject = filenameObject;
}

wxString a2dFileNameProperty::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %s"), GetName().c_str(), m_filenameObject.GetFullPath().c_str() );
    return form;
}

wxString a2dFileNameProperty::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s"), m_filenameObject.GetFullPath().c_str() );
    return form;
}

//----------------------------------------------------------------------------
// a2dDateTimeProperty
//----------------------------------------------------------------------------

a2dDateTimeProperty::a2dDateTimeProperty(): a2dNamedProperty()
{
    m_datetimeObject = wxDefaultDateTime;
}

a2dDateTimeProperty::a2dDateTimeProperty( const a2dPropertyIdDateTime* id, const wxDateTime& datetime )
                        : a2dNamedProperty( id )
{
    m_datetimeObject = datetime;
}

a2dDateTimeProperty::~a2dDateTimeProperty()
{
}

a2dDateTimeProperty::a2dDateTimeProperty( const a2dDateTimeProperty &other)
        :a2dNamedProperty( other )
{
    m_datetimeObject = other.m_datetimeObject;
}

a2dNamedProperty *a2dDateTimeProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dDateTimeProperty(*this);
};

void a2dDateTimeProperty::Assign( const a2dNamedProperty &other )
{
    a2dDateTimeProperty *propcast = wxStaticCast( &other, a2dDateTimeProperty);
    m_datetimeObject = propcast->m_datetimeObject;
}

a2dDateTimeProperty *a2dDateTimeProperty::CreatePropertyFromString( const a2dPropertyIdDateTime* id, const wxString &value )
{
    wxDateTime datetimeval;
    //datetimeval.ParseFormat( value, wxDefaultDateTimeFormat, NULL );
    datetimeval.ParseFormat( value, wxDefaultDateTimeFormat );
    return new a2dDateTimeProperty( id, datetimeval );
}

#if wxART2D_USE_CVGIO
void a2dDateTimeProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        //!todo write complete datetime object
        out.WriteAttribute( wxT("datetime"), m_datetimeObject.Format()  );
    }
    else
    {
    }
}

void a2dDateTimeProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        wxString dateTime = parser.GetAttributeValue( wxT("datetime"), wxT("") );
        //m_datetimeObject.ParseFormat( dateTime, wxDefaultDateTimeFormat, NULL  );
        m_datetimeObject.ParseFormat( dateTime, wxDefaultDateTimeFormat );
    }
    else
    {
    }

    //!todo read complete datetime object
}
#endif //wxART2D_USE_CVGIO

void a2dDateTimeProperty::SetValue( const wxDateTime& datetimeObject )
{
    m_datetimeObject = datetimeObject;
}

void a2dDateTimeProperty::SetDateTime( const wxDateTime& datetimeObject )
{
    m_datetimeObject = datetimeObject;
}

wxString a2dDateTimeProperty::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = %s"), GetName().c_str(), m_datetimeObject.Format().c_str() );
    return form;
}

wxString a2dDateTimeProperty::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s"), m_datetimeObject.Format().c_str() );
    return form;
}

//----------------------------------------------------------------------------
// a2dMenuProperty
//----------------------------------------------------------------------------

a2dMenuProperty::a2dMenuProperty(): a2dNamedProperty()
{
    m_menu = NULL;
}

a2dMenuProperty::a2dMenuProperty( const a2dPropertyIdMenu* id, wxMenu* menu )
                        : a2dNamedProperty( id )
{
    m_menu = menu;
}

a2dMenuProperty::~a2dMenuProperty()
{
}

a2dMenuProperty::a2dMenuProperty( const a2dMenuProperty &other)
        :a2dNamedProperty( other )
{
    m_menu = other.m_menu;
}

a2dNamedProperty *a2dMenuProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dMenuProperty(*this);
};

void a2dMenuProperty::Assign( const a2dNamedProperty &other )
{
    a2dMenuProperty *propcast = wxStaticCast( &other, a2dMenuProperty);
    m_menu = propcast->m_menu;
}

#if wxART2D_USE_CVGIO
void a2dMenuProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
   }
    else
    {
    }
}

void a2dMenuProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
    }

    //!todo read complete menu object
}
#endif //wxART2D_USE_CVGIO

void a2dMenuProperty::SetValue( wxMenu* menu )
{
    m_menu = menu;
}

a2dMenuProperty *a2dMenuProperty::CreatePropertyFromString( const a2dPropertyIdMenu* id, const wxString &value )
{
    return NULL;
}

//----------------------------------------------------------------------------
// a2dWindowProperty
//----------------------------------------------------------------------------

a2dWindowProperty::a2dWindowProperty(): a2dNamedProperty()
{
    m_window = NULL;
}

a2dWindowProperty::a2dWindowProperty( const a2dPropertyIdWindow* id, wxWindow* window )
: a2dNamedProperty( id )
{
    m_window = window;
}

a2dWindowProperty::~a2dWindowProperty()
{
    if(m_window)
        m_window->Close();
}

a2dWindowProperty::a2dWindowProperty( const a2dWindowProperty &other)
:a2dNamedProperty( other )
{
    m_window = other.m_window;
}

a2dNamedProperty *a2dWindowProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dWindowProperty(*this);
};

void a2dWindowProperty::Assign( const a2dNamedProperty &other )
{
    a2dWindowProperty *propcast = wxStaticCast( &other, a2dWindowProperty);
    m_window = propcast->m_window;
}

#if wxART2D_USE_CVGIO
void a2dWindowProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
    }
}

void a2dWindowProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
    }

    //!todo read complete window object
}
#endif //wxART2D_USE_CVGIO

void a2dWindowProperty::SetValue( wxWindow* window )
{
    m_window = window;
}

a2dWindowProperty *a2dWindowProperty::CreatePropertyFromString( const a2dPropertyIdWindow* id, const wxString &value )
{
    return NULL;
}

//----------------------------------------------------------------------------
// a2dWindowProperty
//----------------------------------------------------------------------------

a2dTipWindowProperty::a2dTipWindowProperty(): a2dWindowProperty()
{
    m_rectStay = wxRect( -20, -20, 40 , 40 );
}

a2dTipWindowProperty::a2dTipWindowProperty( const a2dPropertyIdWindow* id, wxTipWindow* window, const wxString& tipstring, bool useObjRect )
: a2dWindowProperty( id, window )
{
    m_useObjRect = useObjRect;
    m_tipstring = tipstring;
}

a2dTipWindowProperty::a2dTipWindowProperty( const a2dPropertyIdWindow* id, wxTipWindow* window, const wxString& tipstring, const wxRect& rect )
: a2dWindowProperty( id, window )
{
    m_rectStay = rect;
    m_useObjRect = false;
    m_tipstring = tipstring;
}

a2dTipWindowProperty::~a2dTipWindowProperty()
{
    if(m_window)
    {
        wxTipWindow* tipwindow = wxDynamicCast(m_window,wxTipWindow);
        if(tipwindow)
            tipwindow->SetTipWindowPtr(NULL);
    }
}

a2dTipWindowProperty::a2dTipWindowProperty( const a2dTipWindowProperty &other)
:a2dWindowProperty( other )
{
    m_tipstring = other.m_tipstring;
}

a2dNamedProperty *a2dTipWindowProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dTipWindowProperty(*this);
};

void a2dTipWindowProperty::Assign( const a2dNamedProperty &other )
{
    a2dTipWindowProperty *propcast = wxStaticCast( &other, a2dTipWindowProperty);
    m_window = propcast->m_window;
    m_tipstring = propcast->m_tipstring;
}

#if wxART2D_USE_CVGIO
void a2dTipWindowProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
    }
}

void a2dTipWindowProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
    }

    //!todo read complete window object
}
#endif //wxART2D_USE_CVGIO

void a2dTipWindowProperty::SetString( const wxString& tipstring )
{
    m_tipstring = tipstring;
}

a2dTipWindowProperty *a2dTipWindowProperty::CreatePropertyFromString( const a2dPropertyIdWindow* id, const wxString &value )
{
    return NULL;
}

//----------------------------------------------------------------------------
// a2dPathListProperty
//----------------------------------------------------------------------------

a2dPathListProperty::a2dPathListProperty(): a2dNamedProperty()
{
    m_pathlistObject = a2dPathList();
}

a2dPathListProperty::a2dPathListProperty( const a2dPropertyIdPathList* id, const a2dPathList& pathlist )
                        : a2dNamedProperty( id )
{
    m_pathlistObject = pathlist;
}

a2dPathListProperty::~a2dPathListProperty()
{
}

a2dPathListProperty::a2dPathListProperty( const a2dPathListProperty &other)
        :a2dNamedProperty( other )
{
    m_pathlistObject = other.m_pathlistObject;
}

a2dNamedProperty *a2dPathListProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dPathListProperty(*this);
};

void a2dPathListProperty::Assign( const a2dNamedProperty &other )
{
    a2dPathListProperty *propcast = wxStaticCast( &other, a2dPathListProperty);
    m_pathlistObject = propcast->m_pathlistObject;
}

a2dPathListProperty *a2dPathListProperty::CreatePropertyFromString( const a2dPropertyIdPathList* id, const wxString &value )
{
    a2dPathList a = a2dPathList();
    a.Add( value );
    return new a2dPathListProperty( id, a );
}

#if wxART2D_USE_CVGIO
void a2dPathListProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        //!todo write complete filename object
        //out.WriteAttribute( wxT("fullfilename"), m_pathlistObject.GetFullPath() );
    }
    else
    {
    }
}

void a2dPathListProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        //!todo m_pathlistObject  = parser.GetAttributeValue( wxT("fullfilename"), wxT("") );
    }
    else
    {
    }

    //!todo read complete filename object
}
#endif //wxART2D_USE_CVGIO

void a2dPathListProperty::SetValue( const a2dPathList& pathlistObject )
{
    m_pathlistObject = pathlistObject;
}

void a2dPathListProperty::SetFileName( const a2dPathList& pathlistObject )
{
    m_pathlistObject = pathlistObject;
}

wxString a2dPathListProperty::StringRepresentation() const
{
    wxString form;
    //!todo form.Printf( wxT("%s = %s"), GetName().c_str(), m_pathlistObject.GetFullPath().c_str() );
    return form;
}

wxString a2dPathListProperty::StringValueRepresentation() const
{
    wxString form;
    //!todo form.Printf( wxT("%s"), m_pathlistObject.GetFullPath().c_str() );
    return form;
}

//----------------------------------------------------------------------------
// a2dColourProperty
//----------------------------------------------------------------------------

A2DGENERALDLLEXP wxColour ParseSvgColour( wxString value )
{
    wxColour colour;
    value.Trim(false).Trim();
    if (value.GetChar(0) == _T('#'))
    {
        colour = HexToColour( value.After(_T('#')));
    }
    else if (value.Mid(0, 4).Lower() == _T("rgb(")) // Read values like RGB(0,0,0) / rgb(0,0,0)
    {
        long red, green, blue;
        value = value.Mid(4);
        value = value.BeforeLast(_T(')'));

        wxStringTokenizer rgb( value, _T(",") );
        if ( rgb.CountTokens() != 3 )
            wxLogWarning(_("Invalid RGB value"));
        if ( !rgb.GetNextToken().ToLong( &red ) )
            wxLogWarning(_("Invalid RGB value"));
        if ( !rgb.GetNextToken().ToLong( &green ) )
            wxLogWarning(_("Invalid RGB value"));
        if ( !rgb.GetNextToken().ToLong( &blue ) )
            wxLogWarning(_("Invalid RGB value"));

        colour.Set(red, green, blue);
    }
    else
    {
        // if exactly 6 characters and all are 0..9,a..f, assume hex colour.
        bool ishex = (value.Length() == 6);
        for ( int i = 0; ishex && i < 6; i++ )
            ishex = ( wxIsxdigit( value.GetChar( i ) ) != 0 );
        if ( ishex )
            colour = HexToColour( value );
        else {
            // if three values separated by either comma, or space assume decimal rgb
            unsigned long red, green, blue;
            bool commavalue = true;
            wxStringTokenizer rgbcomma( value, _T(","), wxTOKEN_RET_EMPTY );
            if ( rgbcomma.CountTokens() != 3 )
                commavalue = false;
            if ( !rgbcomma.GetNextToken().ToULong( &red ) )
                commavalue = false;
            if ( !rgbcomma.GetNextToken().ToULong( &green ) )
                commavalue = false;
            if ( !rgbcomma.GetNextToken().ToULong( &blue ) )
                commavalue = false;

            if ( !commavalue )
            {
                commavalue = true;
                wxStringTokenizer rgbspace( value, _T(" ") );
                if ( rgbspace.CountTokens() != 3 )
                    commavalue = false;
                if ( !rgbspace.GetNextToken().ToULong( &red ) )
                    commavalue = false;
                if ( !rgbspace.GetNextToken().ToULong( &green ) )
                    commavalue = false;
                if ( !rgbspace.GetNextToken().ToULong( &blue ) )
                    commavalue = false;
            }
            if ( commavalue )
                colour.Set(red, green, blue);
            else
            {
                // assume a colourname string.
                colour = wxTheColourDatabase->FindName( value );
            }
        }
    }
    return colour;
}

a2dColourProperty::a2dColourProperty(): a2dNamedProperty()
{
    m_colour = wxT("");
}

a2dColourProperty::a2dColourProperty( const a2dPropertyIdColour* id, const wxColour& colour )
                        : a2dNamedProperty( id )
{
    m_colour = colour;
}

a2dColourProperty::~a2dColourProperty()
{
}

a2dColourProperty::a2dColourProperty( const a2dColourProperty &other)
        :a2dNamedProperty( other )
{
    m_colour = other.m_colour;
}

a2dNamedProperty *a2dColourProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dColourProperty(*this);
};

void a2dColourProperty::Assign( const a2dNamedProperty &other )
{
    a2dColourProperty *propcast = wxStaticCast( &other, a2dColourProperty);
    m_colour = propcast->m_colour;
}

a2dColourProperty *a2dColourProperty::CreatePropertyFromString( const a2dPropertyIdColour* id, const wxString &value )
{
    return new a2dColourProperty( id, ParseSvgColour(value)  );
}

#if wxART2D_USE_CVGIO
void a2dColourProperty::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dNamedProperty::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        //!todo write complete filename object
        wxString form;
        form.Printf( wxT("%d %d %d"),  m_colour.Red(), m_colour.Green(), m_colour.Blue() );
        out.WriteAttribute( wxT("colour"), form );
    }
    else
    {
    }
}

void a2dColourProperty::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dNamedProperty::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        wxString colstr  = parser.GetAttributeValue( wxT("colour"), wxT("") );
        m_colour = ParseSvgColour(colstr);
    }
    else
    {
    }

    //!todo read complete filename object
}
#endif //wxART2D_USE_CVGIO

void a2dColourProperty::SetValue( const wxColour& colour )
{
    m_colour = colour;
}

void a2dColourProperty::SetColour( const wxColour& colour )
{
    m_colour = colour;
}

wxString a2dColourProperty::StringRepresentation() const
{
    wxString form;
    form.Printf( wxT("%s = {%d %d %d}"), GetName().c_str(), m_colour.Red(), m_colour.Green(), m_colour.Blue() );

    return form;
}

wxString a2dColourProperty::StringValueRepresentation() const
{
    wxString form;
    form.Printf( wxT("{%d %d %d}"), m_colour.Red(), m_colour.Green(), m_colour.Blue() );
    return form;
}

//----------------------------------------------------------------------------
// a2dObjectList
//----------------------------------------------------------------------------
A2DGENERALDLLEXP_DATA(a2dObjectList*) wxNullRefObjectList = 0;

//IMPLEMENT_CLASS(a2dObjectList, wxRefObjectBaseList)

a2dObjectList::a2dObjectList()
{
}

a2dObjectList::~a2dObjectList()
{
}

void a2dObjectList::MakeUnique()
{
    for( a2dObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dObject *obj = *iter;
        if ( obj && obj->GetOwnedBy() > 1)
        {
            *iter = obj->Clone( a2dObject::clone_flat );
        }
    }
}

a2dObjectList* a2dObjectList::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{

    if ( this == wxNullRefObjectList )
        return wxNullRefObjectList;
    else
        return new a2dObjectList( *this );
}

bool a2dObjectList::Release( const wxString& classname, bool all )
{
    bool did=false;

    a2dObjectList::iterator iter = begin();
    while ( iter != end() )
    {
        a2dObject *obj = (*iter);
        if ( classname.IsEmpty() || obj->GetClassInfo()->GetClassName()==classname )
        {
            did = true;
            iter = erase( iter );
            if (!all)
                return did;
        }
        else
            iter++;
    }

    return did;
}

a2dObject* a2dObjectList::Find( const wxString& classname, const wxString& name )
{
    for( a2dObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dObject *cobj = *iter;

        if (
            ( classname.IsEmpty() || cobj->GetClassInfo()->GetClassName()==classname ) &&
            ( name.IsEmpty() || cobj->GetName() == name )
        )
        {
            return cobj;
        }
    }

    return (a2dObject*) NULL;
}

int a2dObjectList::CollectObjects( a2dObjectList* total, const wxString& propertyNameFilter, const wxString& classname )
{
    int count = 0;
    for( a2dObjectList::iterator iter = begin(); iter != end(); ++iter )
    {
        a2dObject *cobj = *iter;

        if ( (classname.IsEmpty() || cobj->GetClassInfo()->GetClassName() == classname ) &&
             ( propertyNameFilter.IsEmpty() || ( cobj->GetName().Matches( propertyNameFilter) ) )
           )
        {
            if ( total && total != wxNullRefObjectList )
                total->push_back(cobj);
            count++;
        }
    }

    return count;
}

//----------------------------------------------------------------------------
// a2dVariablesHash
//----------------------------------------------------------------------------

a2dVariablesHash::a2dVariablesHash()
{
}

a2dVariablesHash::a2dVariablesHash( const a2dVariablesHash &other )
:
    a2dVariablesHashBase( other )
{
    // all objects in here need to be cloned
    iterator i;
    for( i = begin(); i != end(); ++i )
    {
        i->second = i->second->Clone( a2dObject::clone_flat );
    }
}

void a2dVariablesHash::operator = ( const a2dVariablesHash &other )
{
    a2dVariablesHashBase::operator = ( other );
    // all objects in here need to be cloned
    iterator i;
    for( i = begin(); i != end(); ++i )
    {
        i->second = i->second->Clone( a2dObject::clone_flat );
    }
}

a2dVariablesHash::~a2dVariablesHash()
{
    iterator i;
    for( i = begin(); i != end(); ++i )
    {
        delete i->second;
    }
}

bool a2dVariablesHash::SetVariable( const wxString& variableName, a2dNamedProperty *property )
{
    iterator iter = find( variableName );
    if( iter != end() )
    {
        delete iter->second;
    }

    (*this)[ variableName ] = property;

    return iter != end();
}

bool a2dVariablesHash::SetVariableRefObject( const wxString& variableName, a2dObject *value )
{
    iterator iter = find( variableName );
    if( iter != end() )
    {
        delete iter->second;
    }

    (*this)[ variableName ] = new a2dProperty( a2dPropertyIdRefObject::GetDummy(), value );

    return iter != end();
}

bool a2dVariablesHash::SetVariableString( const wxString& variableName, const wxString &value )
{
    iterator iter = find( variableName );
    if( iter != end() )
    {
        delete iter->second;
    }

    (*this)[ variableName ] = new a2dStringProperty( a2dPropertyIdString::GetDummy(), value );

    return iter != end();
}

bool a2dVariablesHash::SetVariableDouble( const wxString& variableName, double value )
{
    iterator iter = find( variableName );
    if( iter != end() )
    {
        delete iter->second;
    }

    (*this)[ variableName ] = new a2dDoubleProperty( a2dPropertyIdDouble::GetDummy(), value );

    return iter != end();
}

bool a2dVariablesHash::SetVariableInt( const wxString& variableName, int value )
{
    iterator iter = find( variableName );
    if( iter != end() )
    {
        delete iter->second;
    }

    (*this)[ variableName ] = new a2dInt32Property( a2dPropertyIdInt32::GetDummy(), value );

    return iter != end();
}

const a2dNamedProperty *a2dVariablesHash::GetVariable( const wxString& variableName )
{
    iterator iter = find( variableName );
    if( iter == end() )
        return NULL;// error, alias does not exist

    return iter->second;
}

a2dNamedProperty *a2dVariablesHash::GetVariableClone( const wxString& variableName )
{
    iterator iter = find( variableName );
    if( iter == end() )
        return NULL;// error, alias does not exist

    return iter->second->Clone( a2dObject::clone_flat );
}

a2dObject* a2dVariablesHash::GetVariableRefObject( const wxString& variableName )
{
    iterator iter = find( variableName );
    if( iter == end() )
        return NULL;// error, alias does not exist

    return iter->second->GetRefObjectNA();
}

wxString* a2dVariablesHash::GetVariableString( const wxString& variableName )
{
    iterator iter = find( variableName );
    if( iter == end() )
        return NULL;// error, alias does not exist

    a2dStringProperty *prop = wxDynamicCast( iter->second, a2dStringProperty );
    if( prop )
        return prop->GetValuePtr();
    else
        return 0;
}

//----------------------------------------------------------------------------
// a2dVariablesArray
//----------------------------------------------------------------------------

a2dVariablesArray::a2dVariablesArray()
{
    m_nelements = 0;
    m_melements = 100;
    m_properties = new a2dNamedProperty*[m_melements];

    for( int i=0; i<100; i++ )
    {
        m_properties[i] = 0;
    }
}

a2dVariablesArray::~a2dVariablesArray()
{
    for( int i=0; i<m_nelements; i++ )
    {
        delete m_properties[i];
    }
    delete [] m_properties;
}

void a2dVariablesArray::DeleteAll()
{
    for( int i=0; i<m_nelements; i++ )
    {
        delete m_properties[i];
        m_properties[i] = 0;
    }
    m_nelements = 0;
}

void a2dVariablesArray::AppendVariable( a2dNamedProperty *value )
{
    SetMinSize( m_nelements + 1 );
    m_properties[ m_nelements++ ] = value;
}

void a2dVariablesArray::AppendVariableRefObject( a2dObject *value )
{
    SetMinSize( m_nelements + 1 );
    m_properties[ m_nelements++ ] = new a2dProperty( a2dPropertyIdRefObject::GetDummy(), value );
}

void a2dVariablesArray::AppendVariableString( const wxString &value )
{
    SetMinSize( m_nelements + 1 );
    m_properties[ m_nelements++ ] = new a2dStringProperty( a2dPropertyIdString::GetDummy(), value );
}

void a2dVariablesArray::AppendVariableDouble( double value )
{
    SetMinSize( m_nelements + 1 );
    m_properties[ m_nelements++ ] = new a2dDoubleProperty( a2dPropertyIdDouble::GetDummy(), value );
}

void a2dVariablesArray::AppendVariableInt( int value )
{
    SetMinSize( m_nelements + 1 );
    m_properties[ m_nelements++ ] = new a2dInt32Property( a2dPropertyIdInt32::GetDummy(), value );
}

const a2dNamedProperty &a2dVariablesArray::GetVariable( int index )
{
    wxASSERT( index < m_nelements && index >= 0 );
    return *m_properties[index];
}

a2dNamedProperty *a2dVariablesArray::GetVariableClone( int index )
{
    wxASSERT( index < m_nelements && index >= 0 );
    return m_properties[index]->Clone( a2dObject::clone_flat );
}

a2dObject* a2dVariablesArray::GetVariableRefObject( int index )
{
    wxASSERT( index < m_nelements && index >= 0 );
    return m_properties[index]->GetRefObject();
}

wxString a2dVariablesArray::GetVariableString( int index )
{
    wxASSERT( index < m_nelements && index >= 0 );
    return m_properties[index]->GetString();
}

wxString a2dVariablesArray::GetVariableAsString( int index )
{
    wxASSERT( index < m_nelements && index >= 0 );
    return m_properties[index]->StringValueRepresentation();
}

void a2dVariablesArray::SetMinSize( int size )
{
    if( size > m_melements )
    {
        int i;
        if( size < m_melements * 2 )
            m_melements *= 2;
        else
            m_melements = size;
        a2dNamedProperty **newdata = new a2dNamedProperty*[m_melements];

        for( i=0; i<m_nelements; i++ )
        {
            newdata[i] = m_properties[i];
        }
        for( ; i<m_melements; i++ )
        {
            newdata[i] = 0;
        }
        delete [] m_properties;
        m_properties = newdata;
    }
}

// ----------------------------------------------------------------------------
// a2dPathList
// ----------------------------------------------------------------------------
#define PATHLENGTH 255 * 4

// MT-FIXME: get rid of this horror and all code using it
static wxChar wxFileFunctionsBuffer[PATHLENGTH];

a2dPathList::a2dPathList()
{
}

a2dPathList::~a2dPathList()
{
    Clear();
}

wxString a2dPathList::GetAsString()
{
    wxString ret;

#if wxCHECK_VERSION(2,7,0)
    for (wxPathList::iterator node = begin(); node != end(); node++ )
#else
    for (wxStringList::compatibility_iterator node = GetFirst(); node; node = node->GetNext())
#endif
    {
        wxString path = node->GetData();
        ret += wxPATH_SEP + path;
    }
    return ret;
}

wxString a2dPathList::FindValidPath (const wxString& file)
{
    wxFileName ffile( file );
    wxString fileUnix = ffile.GetFullPath(wxPATH_UNIX);

    if ( ExpandPath( fileUnix ) && wxFileExists( fileUnix ) )
       return wxString(m_b);

    wxFileName fileobj = wxFileName( fileUnix );

    // relative ./whatdir/file.ext should also be searched for.
    wxString filename = fileobj.IsAbsolute() ? fileobj.GetFullName() : fileobj.GetFullPath();

#if wxCHECK_VERSION(2,7,0)
    for (wxPathList::iterator node = begin(); node != end(); node++ )
#else
    for (wxStringList::compatibility_iterator node = GetFirst(); node; node = node->GetNext())
#endif
    {
        wxFileName filep( node->GetData() );
        filep.GetFullPath(wxPATH_UNIX);
        wxString path = filep.GetFullPath(wxPATH_UNIX);
        if ( !path.IsEmpty() )
        {
            wxChar ch = path[wxStrlen(path)-1];
            if (ch != wxT('\\') && ch != wxT('/'))
                path += wxT("/");
        }
        path += filename;

        if ( ExpandPath( path ) && wxFileExists( path ) )
            return wxString(m_b); // Found!
    }

    return wxEmptyString; //Not found
}

wxString a2dPathList::FindAbsoluteValidPath (const wxString& file)
{
    wxString f = FindValidPath(file);
    if ( f.empty() || wxIsAbsolutePath(f) )
        return f;

    wxString buf = wxGetCwd();

    if ( !wxEndsWithPathSeparator(buf) )
    {
        buf += wxFILE_SEP_PATH;
    }
    buf += f;

    return buf;
}

void a2dPathList::IncC()
{
    if (m_c == 0) //get first character from buffer
    {
        //m_c = m_path.wchar_str();
        m_c = m_path.c_str();
    }
    else
    {
        if (*m_c != wxT('\0') )
            m_c++;
    }
    a = *m_c;
}

//  <name>          ::= { LETTER | DIGIT | UNDERSCORE | MINUS }*
// Check Name specification
bool a2dPathList::Name()
{
    m_varref.Empty();
    if ( !( wxIsalnum(a) || a == wxT('_') ||  a == wxT('-') ) )
    {
        m_error_mes = wxT("wrong name");
        return false;   // invalid name (begin char)
    }
    m_varref += a;
    IncC();
    while( wxIsalnum(a) || a == wxT('_') )
    {
        m_varref+=a;
        IncC();
    }
    return true;    // name is validated
}

//<path>=  { <aliasref> | <envref> | {CHAR}* }*
bool a2dPathList::ExpandPath( wxString& pathToExpand )
{
    wxString result;
    m_path = pathToExpand;
    m_b.Clear();
    m_b.Alloc(PATHLENGTH);

    bool change = true;
    while ( change )
    {
        change = false;
        m_b.Clear();
        m_varref.Clear();
        m_error_mes.Clear();
        m_c=0;

        IncC();

        while( a != wxT('\t') && a != wxT('\0') && a != wxT('\n') && a != wxT(';') )
        {
    /*
            if (a == wxT('\\') ) //take the next character
            {   IncC();
                if ( a == wxT('\n') )
                    IncC(); //treat it as if it was a space

                if ( a == wxT(' ') || a == wxT('\t') || a == wxT('\0') || a == wxT(';') )
                    break; //treat it as word seperator

                //all other backslash character take them
                m_b += a;
                IncC();
                continue;
            }
    */
            if ( (a == wxT('$') ) || ( a == wxT('%') ) || ( a == wxT('@') ) )
            {
                 if (!VarRef(a))
                    return false;
                 change = true;
                 continue;
            }

            //all other characters
            m_b += a;
            IncC();
        }

        m_path = m_b;
    }

    wxFileName ffile( m_b );
    pathToExpand = ffile.GetFullPath(wxPATH_UNIX);

    return true;
}

// Get Alias value
// <aliasref>           ::= ('%') { <name> <blank> | ('{') <name> ('}') }
// Get Environment string
//  <envstring>     ::= ('$') { <name> <blank> | ('{') <name> ('}') }
bool a2dPathList::VarRef( wxChar type)
{
    if( a != type ) // '$' or '%' must be there
    {
        m_error_mes = wxT("wrong environment $ or % or @ missing");
        return false;
    }

    IncC();
    if( a == wxT('{') ) // brace could be there
    {
        IncC();
        if( !Name() )
            return false; // error, wrong alias name
        if( a != '}' ) // brace must be there
        {
            m_error_mes = wxT("wrong environment name, end brace missing");
            return false; // error, wrong alias, endbrace missing or wrong name
        }
        IncC();
    }
    else
    {
        if( !Name() )
            return false; // error, wrong alias name
    }

    wxString evaluated;
    if (type == wxT('$') )
    {
        if (m_varref.Len()==0)
            return false;   // A name is needed

        if( !wxGetEnv(m_varref, &evaluated) )
        {
            m_error_mes = wxT("wrong environment Variable, environment does not exist");
            return false;// error, alias does not exist
        }
    }
    else
    {
        a2dVariablesHash aliaslist = a2dGeneralGlobals->GetVariablesHash();
        const a2dNamedProperty *prop = a2dGeneralGlobals->GetVariablesHash().GetVariable( m_varref );
        if( !prop )
        {
            m_error_mes = wxT("wrong Variable name, Variable does not exist");
            return false;// error, alias does not exist
        }
        evaluated = prop->StringValueRepresentation();
    }

    m_b += evaluated;
    return true;
}

// ----------------------------------------------------------------------------
// Definition of a2dIOHandler
// ----------------------------------------------------------------------------
a2dIOHandler::a2dIOHandler()
{
    m_refcount = 0;
    m_toResolve.DeleteContents( true );
    m_lastObjectId.Empty();
}

a2dIOHandler::~a2dIOHandler()
{
    wxASSERT_MSG(  m_refcount == 0, wxT("deleting a2dDocument while referenced") );
    m_objecthashmap.clear();
    m_objectCreate.clear();
    m_toResolve.Clear();
    m_lastObjectId.Empty();
}

a2dObject* a2dIOHandler::Clone( CloneOptions WXUNUSED(options) ) const
{
    wxFAIL_MSG( wxT("cannot clone a2dIOHandler") );
    return NULL;
}

#if wxART2D_USE_CVGIO
void a2dIOHandler::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut& WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts), a2dObjectList* WXUNUSED(towrite) )
{
    wxFAIL_MSG( wxT("cannot Save a2dIOHandler") );
}

void a2dIOHandler::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
    wxFAIL_MSG( wxT("cannot Load a2dIOHandler") );
}
#endif //wxART2D_USE_CVGIO

wxObject* a2dIOHandler::CreateObject( const wxString& symbolicName )
{
    a2dHashMapCreateObject::iterator obj = m_objectCreate.find( symbolicName );

    if( obj == m_objectCreate.end() )
    {
        return wxCreateDynamicObject( symbolicName );
    }
    return wxCreateDynamicObject( obj->second );
}

void a2dIOHandler::Initialize()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
    m_lastObjectId.Empty();
}

void a2dIOHandler::Reset()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
    m_lastObjectId.Empty();
}

bool a2dIOHandler::ResolveOrAdd( a2dSmrtPtr<a2dObject>* storedHere, const wxString &id )
{
    if ( storedHere && ( !id.IsEmpty() || !m_lastObjectId.IsEmpty() ) )
    {
        a2dHashMapIntToObject::iterator obj = m_objecthashmap.find( id.IsEmpty() ? m_lastObjectId : id );

        if( obj == m_objecthashmap.end() )
        {
            a2dResolveIdInfo* a = new a2dResolveIdInfo( id.IsEmpty() ? m_lastObjectId : id, storedHere );
            m_toResolve.Append( a );
            if( id.IsEmpty() )
                m_lastObjectId.Empty();
            return false;
        }

        //the object referenced is already found, link it now.
        *storedHere =  wxDynamicCast( obj->second, a2dObject );
        if( id.IsEmpty() )
            m_lastObjectId.Empty();
        return true;
    }
    return false;
}

bool a2dIOHandler::ResolveOrAdd( a2dAutoZeroPtr<a2dObject>* storedHere, const wxString &id )
{
    if ( storedHere && ( !id.IsEmpty() || !m_lastObjectId.IsEmpty() ) )
    {
        a2dHashMapIntToObject::iterator obj = m_objecthashmap.find( id.IsEmpty() ? m_lastObjectId : id );

        if( obj == m_objecthashmap.end() )
        {
            a2dResolveIdInfo* a = new a2dResolveIdInfo( id.IsEmpty() ? m_lastObjectId : id, storedHere );
            m_toResolve.Append( a );
            if( id.IsEmpty() )
                m_lastObjectId.Empty();
            return false;
        }

        //the object referenced is already found, link it now.
        *storedHere =  wxDynamicCast( obj->second, a2dObject );
        if( id.IsEmpty() )
            m_lastObjectId.Empty();
        return true;
    }
    return false;
}

bool a2dIOHandler::ResolveOrAddLink( a2dObject *owner, const wxString &id )
{
    if ( owner && ( !id.IsEmpty() || !m_lastObjectId.IsEmpty() ) )
    {
        a2dHashMapIntToObject::iterator obj = m_objecthashmap.find( id.IsEmpty() ? m_lastObjectId : id );

        if( obj == m_objecthashmap.end() )
        {
            a2dResolveIdInfo* a = new a2dResolveIdInfo( id.IsEmpty() ? m_lastObjectId : id, owner );
            m_toResolve.Append( a );
            if( id.IsEmpty() )
                m_lastObjectId.Empty();
            return false;
        }

        //the object referenced is already found, link it now.
        owner->LinkReference( obj->second );
        if( id.IsEmpty() )
            m_lastObjectId.Empty();
        return true;
    }
    return false;
}

void a2dIOHandler::ResolveInform( a2dObject *obj )
{
    a2dResolveIdInfo* a = new a2dResolveIdInfo( obj );
    m_toResolve.Append( a );
}

void a2dIOHandler::SetLastObjectLoadedId( const wxString& lastid )
{
    wxASSERT_MSG( m_lastObjectId.IsEmpty(), wxT("last refid not resolved") );
    m_lastObjectId = lastid;
}

bool a2dIOHandler::LinkReferences()
{
    a2dResolveIdList::compatibility_iterator node = m_toResolve.GetFirst();
    while (node)
    {
        a2dResolveIdList::compatibility_iterator delnode = node;
        node = node->GetNext();
        wxString toLinkName = delnode->GetData()->m_idStr;
        a2dHashMapIntToObject::iterator obj = m_objecthashmap.find( toLinkName );
        if( obj != m_objecthashmap.end() )
        {
            delnode->GetData()->Assign( obj->second );
            m_toResolve.DeleteNode( delnode );
        }
        else
#if wxCHECK_VERSION(2,9,0)
            wxLogWarning(  wxT("%s%s"), _("Reference not resolved: "), toLinkName );
#else
            wxLogWarning(  wxT("%s%s"), _("Reference not resolved: "), toLinkName.c_str() );
#endif //wxCHECK_VERSION(2,9,0)

    }
    return true;
}

// ----------------------------------------------------------------------------
// Definition of a2dIOHandlerStrIn
// ----------------------------------------------------------------------------
a2dIOHandlerStrIn::a2dIOHandlerStrIn( wxMBConv& conv ): m_conv(conv)
{
    m_mode = wxEOL_NATIVE;
    if (m_mode == wxEOL_NATIVE)
    {
#if defined(__WXMSW__) || defined(__WXPM__)
        m_mode = wxEOL_DOS;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
        m_mode = wxEOL_MAC;
#else
        m_mode = wxEOL_UNIX;
#endif
    }
}

a2dIOHandlerStrIn::~a2dIOHandlerStrIn()
{
    wxASSERT_MSG(  m_refcount == 0, wxT("deleting a2dDocument while referenced") );
}

void a2dIOHandlerStrIn::InitializeLoad()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
}

void a2dIOHandlerStrIn::ResetLoad()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
}

char a2dIOHandlerStrIn::Peek()
{
#if wxUSE_STD_IOSTREAM
        return m_streami->peek();
#else
        return m_streami->Peek();
#endif
}

char a2dIOHandlerStrIn::GetC()
{
#if wxUSE_STD_IOSTREAM
        return m_streami->get();
#else
        return m_streami->GetC();
#endif
}

bool a2dIOHandlerStrIn::Eof() const
{
#if wxUSE_STD_IOSTREAM
        if (m_streami->eof())
#else
        if (m_streami->Eof())
#endif
            return true;
    return false;
}

bool a2dIOHandlerStrIn::IsOk() const
{
#if wxUSE_STD_IOSTREAM
    return ( m_streami->fail() || m_streami->bad());
#else
    return ( m_streami->IsOk() );
#endif
}

a2dIOHandlerStrIn& a2dIOHandlerStrIn::SeekI( wxFileOffset pos )
{
#if wxUSE_STD_IOSTREAM
    m_streami->clear(); // not interested in stream errors here
    m_streami->seekg( pos, wxSTD ios::beg );
#else
    m_streami->SeekI( pos );
#endif
    return *this;
}
/*
size_t a2dIOHandlerStrIn::Read( wxChar* buffer, size_t size)
{
#if wxUSE_STD_IOSTREAM
    m_streami->read( buffer, size);
    size_t len = m_streami->gcount();
#else
    size_t len = m_streami->Read( buffer, size).LastRead();
#endif
    return len;
}
*/

//#if wxUSE_UNICODE
size_t a2dIOHandlerStrIn::Read( char* buffer, size_t size)
{
#if wxUSE_STD_IOSTREAM
    m_streami->read( buffer, size);
    size_t len = m_streami->gcount();
#else
    size_t len = m_streami->Read( buffer, size).LastRead();
#endif
    return len;
}
//#endif

void a2dIOHandlerStrIn::SetMode(wxEOL mode)
{
    m_mode = mode;
    if (m_mode == wxEOL_NATIVE)
    {
#if defined(__WXMSW__) || defined(__WXPM__)
        m_mode = wxEOL_DOS;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
        m_mode = wxEOL_MAC;
#else
        m_mode = wxEOL_UNIX;
#endif
    }
}

// ----------------------------------------------------------------------------
// Definition of a2dIOHandlerStrOut
// ----------------------------------------------------------------------------
a2dIOHandlerStrOut::a2dIOHandlerStrOut( wxMBConv& conv ): m_conv(conv)
{
    m_mode = wxEOL_NATIVE;
    if (m_mode == wxEOL_NATIVE)
    {
#if defined(__WXMSW__) || defined(__WXPM__)
        m_mode = wxEOL_DOS;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
        m_mode = wxEOL_MAC;
#else
        m_mode = wxEOL_UNIX;
#endif
    }
}

a2dIOHandlerStrOut::~a2dIOHandlerStrOut()
{
}

void a2dIOHandlerStrOut::InitializeSave()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
}

void a2dIOHandlerStrOut::ResetSave()
{
    m_objecthashmap.clear();
    m_toResolve.Clear();
}

void a2dIOHandlerStrOut::WriteString(const wxString& string )
{
    size_t len = string.length();

    wxString out;
    out.reserve(len);

    if ( m_mode != wxEOL_UNIX )
    {
        for ( size_t i = 0; i < len; i++ )
        {
            const wxChar c = string[i];
            if ( c == wxT('\n') )
            {
                switch ( m_mode )
                {
                    case wxEOL_DOS:
                        out << _T("\r\n");
                        continue;

                    case wxEOL_MAC:
                        out << _T('\r');
                        continue;

                    default:
                        wxFAIL_MSG( _T("unknown EOL mode in a2dIOHandlerStrOut") );
                        // fall through

                    case wxEOL_UNIX:
                        // don't treat '\n' specially
                        ;
                }
            }

            out << c;
       }
    }
    else
        out = string;

#if wxUSE_STD_IOSTREAM

    // We must not write the trailing NULL here
#if wxUSE_UNICODE
    #if !wxUSE_WSTREAM
        //in memory converted to wide char unicode string with wxConvLocal, and convert with m_conv e.g UTF-8
        wxString str2(out.wc_str(wxConvLocal ), m_conv);
        m_streamo->write(str2.mb_str(), str2.Len());
    #else
        m_streamo->write(  out, len );
    #endif
#else
    m_streamo->write(out.c_str(), out.length() );
#endif

#else
    // We must not write the trailing NULL here
#if wxUSE_UNICODE
    wxCharBuffer buffer = m_conv.cWC2MB( out );
    m_streamo->Write( (const char*) buffer, strlen( (const char*) buffer ) );
#else
    //in memory converted to wide char unicode string with wxConvLocal, and convert with m_conv e.g UTF-8
    wxString str2(out.wc_str(wxConvLocal ), m_conv);
    m_streamo->Write(str2.mb_str(), str2.Len());
#endif

#endif
}

void a2dIOHandlerStrOut::Write32(wxUint32 i)
{
    wxString str;
    str.Printf(wxT("%u"), i);

    WriteString(str);
}

void a2dIOHandlerStrOut::Write16(wxUint16 i)
{
    wxString str;
    str.Printf(wxT("%u"), i);

    WriteString(str);
}

void a2dIOHandlerStrOut::Write8(wxUint8 i)
{
    wxString str;
    str.Printf(wxT("%u"), i);

    WriteString(str);
}

void a2dIOHandlerStrOut::WriteDouble(double d)
{
    wxString str;

    str.Printf(wxT("%f"), d);
    WriteString(str);
}

bool a2dIOHandlerStrOut::IsOk() const
{
#if wxUSE_STD_IOSTREAM
    return ( m_streamo->fail() || m_streamo->bad()) == 0;
#else
    return ( m_streamo->IsOk() );
#endif
}

a2dIOHandlerStrOut& a2dIOHandlerStrOut::PutChar(wxChar c)
{
    WriteString( wxString(&c, m_conv, 1) );
    return *this;
}

//----------------------------------------------------------------------------
// a2dWalkerIOHandler
//----------------------------------------------------------------------------

extern a2dWalkEvent a2dWalker_a2dObjectStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dObjectEnd = wxNewId();
extern a2dWalkEvent a2dWalker_a2dPropObjectStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dPropObjectEnd = wxNewId();
extern a2dWalkEvent a2dWalker_a2dNamedPropertyListStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dNamedPropertyListEnd = wxNewId();
extern a2dWalkEvent a2dWalker_a2dNamedPropertyStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dNamedPropertyEnd = wxNewId();

extern a2dWalkEvent a2dWalker_a2dCanvasObjectStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dCanvasObjectProperties = wxNewId();
extern a2dWalkEvent a2dWalker_a2dCanvasObjectPreChild = wxNewId();
extern a2dWalkEvent a2dWalker_a2dCanvasObjectPostChild = wxNewId();
extern a2dWalkEvent a2dWalker_a2dCanvasObjectEnd = wxNewId();
extern a2dWalkEvent a2dWalker_a2dDerivedCanvasObjectStart = wxNewId();
extern a2dWalkEvent a2dWalker_a2dDerivedCanvasObjectEnd = wxNewId();

a2dWalkerIOHandler::a2dWalkerIOHandler()
{
    m_useCheck = false;
    m_depthFirst = false;
    Initialize();
}

a2dWalkerIOHandler::~a2dWalkerIOHandler()
{
}

void a2dWalkerIOHandler::Initialize()
{
    m_currentDepth = 0;
    m_currentParent = NULL;
    m_stopWalking = false;
    m_result = false;
}

bool a2dWalkerIOHandler::WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event )
{
    a2dObjectIOFn* function = m_register.find( object->GetClassInfo()->GetClassName() )->second;

    if ( function )
    {
        (*function)( parent, object, event );
        return true;
    }
    return false;
}

// ----------------------------------------------------------------------------
// Definition of a2dPropObject
// ----------------------------------------------------------------------------

a2dPropertyIdString* a2dPropObject::PROPID_Name = NULL;
a2dPropertyIdString* a2dPropObject::PROPID_URL = NULL;
a2dPropertyIdVoidPtr* a2dPropObject::PROPID_autozeroptrlist = NULL;

INITIALIZE_PROPERTIES( a2dPropObject, a2dObject )
{
    A2D_PROPID_D_F( a2dPropertyIdString, URL, wxT(""), a2dPropertyId::flag_isEditable );
    A2D_PROPID_D_F( a2dPropertyIdString, Name, wxT(""), a2dPropertyId::flag_isEditable );
    A2D_PROPID_D( a2dPropertyIdVoidPtr, autozeroptrlist, 0 );
    return true;
}

DEFINE_EVENT_TYPE( a2dPropObject::sm_Edit_properties )

a2dPropObject::a2dPropObject()
{
}

a2dPropObject::~a2dPropObject()
{
}

a2dObject* a2dPropObject::Clone( CloneOptions options ) const
{
    return new a2dPropObject( *this, options );
}

a2dPropObject::a2dPropObject( const a2dPropObject &other, CloneOptions options )
:   a2dObject( other )
{
    a2dNamedPropertyList::const_iterator iter;
    for( iter = other.m_propertylist.begin(); iter != other.m_propertylist.end(); ++iter )
    {
        const a2dNamedProperty *prop = *iter;
        //properties it self are not refcounted, but its data may be, therefore options are also needed there.
        m_propertylist.push_back( prop->Clone( options ) );
    }

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

bool a2dPropObject::EditProperties( const a2dPropertyId* id, bool withUndo )
{
    a2dNamedPropertyList allprops;

    CollectProperties2( &allprops, id, a2dPropertyId::flag_none );

    bool res = false;

    a2dPropertyEditEvent event( this, &allprops );
    event.SetEventObject( this );

    // first try the object itself, this makes object specific property editing possible.
    if ( ! ProcessEvent( event ) )
        // now try any class which is interested
        a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );

    if ( event.GetEdited() && !allprops.empty() )
    {
        res = true;
        a2dNamedPropertyList::iterator iter;
        for( iter = allprops.begin(); iter != allprops.end(); ++iter )
        {
            a2dNamedProperty *prop = *iter;
            prop->SetToObject( this );
        }
    }

    return res;
}

void a2dPropObject::TakeOverProperties( a2dPropObject* from, a2dPropertyIdList* listOfIds )
{
    if ( !listOfIds )
        return;

    forEachIn( a2dPropertyIdList, listOfIds )
    {
        a2dPropertyId *id = *iter;
        a2dNamedProperty *property = from->GetProperty( id );
        if ( property )
            property->SetToObject( this );
    }
}

bool a2dPropObject::AddProperty( a2dNamedProperty *property )
{
    m_propertylist.push_back( property );
    return true;
}

a2dNamedProperty* a2dPropObject::FindProperty( const a2dPropertyId* id, a2dPropertyId::Flags flags )
{
    a2dNamedPropertyList::iterator iter;
    for( iter = m_propertylist.begin(); iter != m_propertylist.end(); ++iter )
    {
        a2dNamedProperty *prop = *iter;
        if (  id->CheckCollect( prop->GetId(), flags ) ) 
            return prop;
    }

    return NULL;
}

const a2dNamedProperty* a2dPropObject::FindProperty( const a2dPropertyId* id, a2dPropertyId::Flags flags ) const
{
    a2dNamedPropertyList::const_iterator iter;
    for( iter = m_propertylist.begin(); iter != m_propertylist.end(); ++iter )
    {
        const a2dNamedProperty *prop = *iter;
        if (  id->CheckCollect( prop->GetId(), flags ) ) 
            return prop;
    }

    return NULL;
}

bool a2dPropObject::RemoveProperty( const a2dPropertyId* id, bool all )
{
    if( m_propertylist.Remove( id, all ) )
    {
        OnPropertyChanged( id );
        return true;
    }
    else
        return false;
}

void a2dPropObject::RemoveTemporaryProperties( )
{
    m_propertylist.RemoveTemporary();
}

void a2dPropObject::SetURL( const wxString& url )
{
    PROPID_URL->SetPropertyToObject( this, url );
}

wxString a2dPropObject::GetURL() const
{
    return PROPID_URL->GetPropertyValue( this );
}

void a2dPropObject::SetName(const wxString& name)
{
    PROPID_Name->SetPropertyToObject( this, name );
}

wxString a2dPropObject::GetName() const
{
    //first search if a reserved property exists
    const a2dNamedProperty *p = FindProperty( PROPID_Name );
    if (p)
        return p->StringValueRepresentation();
    return a2dObject::GetName();
}

#if wxART2D_USE_CVGIO

void a2dPropObject::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts, a2dObjectList* towrite )
{
    if ( xmlparts == a2dXmlSer_attrib )
    {
        a2dObject::DoSave( this, out, xmlparts, towrite);
    }
    else
    {
        a2dObject::DoSave( this, out, xmlparts, towrite);

        if ( !m_propertylist.empty() )
        {
            out.WriteNewLine();
            out.WriteStartElement( wxT("properties") );

            a2dNamedPropertyList::iterator iter;
            for( iter = m_propertylist.begin(); iter != m_propertylist.end(); ++iter )
            {
                a2dNamedProperty *prop = *iter;
                // Don't store temporary properties
                if( !prop->GetId()->IsTemporary() )
                {
                    prop->Save( this, out, towrite );
                }
            }

            out.WriteEndElement();
            out.WriteNewLine();
        }
    }
}

void a2dPropObject::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dObject::DoLoad( parent, parser, xmlparts );

    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        if ( parser.GetTagName() == wxT("properties") )
        {
            parser.Next();
            while( parser.GetTagName() == wxT("o") )
            {
                wxString classname = parser.GetAttributeValue( wxT("classname") );
                wxObject *obj = parser.CreateObject( classname );
                a2dNamedProperty *property = wxDynamicCast( obj, a2dNamedProperty );
                if ( !property )
                {
                    a2dGeneralGlobals->ReportErrorF( a2dError_XMLparse, _("could not create a2dNamedProperty %s, will be skipped line %d"),
                        classname.c_str(), parser.GetCurrentLineNumber() );
                    parser.SkipSubTree();
                    parser.Require( END_TAG, wxT("o") );
                    parser.Next();
                }
                else
                {
                    property->Load( this, parser );
                    property->SetToObject( this );
                }
            }

            parser.Require( END_TAG, wxT("properties") );
            parser.Next();
        }
    }
}

#endif //wxART2D_USE_CVGIO

void a2dPropObject::DoWalker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, this, a2dWalker_a2dPropObjectStart );

    if ( !handler.GetStopWalking() )
    {
        m_propertylist.Walker( this, handler );
    }
    handler.WalkTask( parent, this, a2dWalker_a2dPropObjectEnd );
}


// 3-digit hex to wxColour
wxColour HexToColour(const wxString& hex)
{
    if (hex.Length() == 6)
    {
        long r, g, b;
        r = g = b = 0;
        hex.Mid(0,2).ToLong(&r, 16);
        hex.Mid(2,2).ToLong(&g, 16);
        hex.Mid(4,2).ToLong(&b, 16);
        return wxColour(r, g, b);
    }
    else
        return wxColour(0,0,0);
}

// RGB to 3-digit hex
wxString ColourToHex(const wxColour& colour)
{
    wxChar buf[7];
    unsigned int red = colour.Red();
    unsigned int green = colour.Green();
    unsigned int blue = colour.Blue();

    wxDecToHex(red, buf);
    wxDecToHex(green, buf+2);
    wxDecToHex(blue, buf+4);

    return wxString(buf);
}

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