comevt.cpp

Go to the documentation of this file.

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

    Copyright: 2001-2004 (C) Klaas Holwerda 

    Licence: wxWidgets licence

    RCS-ID: $Id: comevt.cpp,v 1.113 2009/08/23 19:49:38 titato Exp $
*/

#include "docviewprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

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

#if defined(_DEBUG) 
//    #define A2D_COMMAND_DEBUG
#endif

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

#ifndef WX_PRECOMP
    #include "wx/string.h"
    #include "wx/dc.h"
    #include "wx/list.h"
#endif

#include "wx/general/comevt.h"

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

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

// ----------------------------------------------------------------------------
// wxWindows macros
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(a2dEvtHandler, a2dPropObject)
IMPLEMENT_DYNAMIC_CLASS(a2dCommandProcessor, a2dEvtHandler)
IMPLEMENT_DYNAMIC_CLASS( a2dCommand_SetProperty, a2dCommand )
IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetVariable, a2dCommand )
IMPLEMENT_DYNAMIC_CLASS(a2dCommand_SetEnvironmentVariable, a2dCommand )
IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GetVariable, a2dCommand )
IMPLEMENT_DYNAMIC_CLASS(a2dCommand_GetEnvVariable, a2dCommand )

DEFINE_EVENT_TYPE(wxEVT_DO)
DEFINE_EVENT_TYPE(wxEVT_UNDO)
DEFINE_EVENT_TYPE(wxEVT_REDO)
DEFINE_EVENT_TYPE(wxEVT_MENUSTRINGS)
DEFINE_EVENT_TYPE(wxEVT_BEGINBUSY)
DEFINE_EVENT_TYPE(wxEVT_ENDBUSY)
DEFINE_EVENT_TYPE(a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT)

/*
 * class a2dDynamicEventProperty
 */
#if (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))
//klion: Is this second template declaration realy need to __GNUC__???
//template class A2DGENERALDLLEXP a2dPropertyIdProp< a2dDynamicEventProperty >;

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

IMPLEMENT_DYNAMIC_CLASS( a2dDynamicEventProperty, a2dNamedProperty );

a2dDynamicEventProperty::a2dDynamicEventProperty(): a2dNamedProperty()
{
    m_eventType = -1;
    m_id = -1;
    m_lastId = -1;
    m_fn = NULL;
}

a2dDynamicEventProperty::a2dDynamicEventProperty( const a2dPropertyIdDynamicEventProperty* propid, 
                                                  int evType, int id, int idLast, a2dObjectEventFunction fn )
        :a2dNamedProperty( propid )
{
    m_eventType = evType;
    m_id = id;
    m_lastId = idLast;
    m_fn = fn;
}

a2dDynamicEventProperty::a2dDynamicEventProperty(const a2dDynamicEventProperty &other )
    :a2dNamedProperty( other )
{
    m_eventType = other.m_eventType;
    m_id = other.m_id;
    m_lastId = other.m_lastId;
    m_fn = other.m_fn;
}

a2dDynamicEventProperty::~a2dDynamicEventProperty()
{
}

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

void a2dDynamicEventProperty::Assign( const a2dNamedProperty &other )
{
    a2dDynamicEventProperty *propcast = wxStaticCast( &other, a2dDynamicEventProperty);
    m_eventType = propcast->m_eventType;
    m_id = propcast->m_id;
    m_lastId = propcast->m_lastId;
    m_fn = propcast->m_fn;
}

#if wxART2D_USE_CVGIO

void a2dDynamicEventProperty::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut& WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts), a2dObjectList* WXUNUSED(towrite) )
{
    wxASSERT(0);
}

#endif //wxART2D_USE_CVGIO

#if wxART2D_USE_CVGIO

void a2dDynamicEventProperty::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
    wxASSERT(0);
}

#endif //wxART2D_USE_CVGIO

// ----------------------------------------------------------------------------
// a2dEvtHandler
// ----------------------------------------------------------------------------

//! initialize timestamp
long a2dEvent::ms_timestamp = 0;

//! initialize static data in a2dEvtHandler
const a2dEventTable *a2dEvtHandler::GetEventTable() const
    { return &a2dEvtHandler::sm_eventTable; }

//! initialize static data in a2dEvtHandler
const a2dEventTable a2dEvtHandler::sm_eventTable =
    { (const a2dEventTable *)NULL, &a2dEvtHandler::sm_eventTableEntries[0] };

//! initialize static data in a2dEvtHandler
const a2dEventTableEntry a2dEvtHandler::sm_eventTableEntries[] =
    { A2D_DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL, 0, 0, (a2dObjectEventFunction)NULL, NULL) };


/*
 * Event handler
 */

a2dEvtHandler::a2dEvtHandler()
{
    m_enabled = true;
}

a2dEvtHandler::a2dEvtHandler( const a2dEvtHandler& other, CloneOptions options )
    :a2dPropObject( other, options ) 
{
    m_enabled = true;
}

a2dEvtHandler::~a2dEvtHandler()
{
}

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

a2dEvtHandler* a2dEvtHandler::GetEventHandler() const 
{ 
    return const_cast<a2dEvtHandler*> ( this ); 
}

/*
 * Event table stuff
 */

bool a2dEvtHandler::ProcessEvent(wxEvent& event)
{
    // An event handler can be enabled or disabled
    if ( GetEvtHandlerEnabled() )
    {
        // klion: to speed up we check a property list at first
        if ( HasDynamicProperties() )
            if ( SearchDynamicEventProperties( event ) )
                return true;

        //static per-class event tables
        const a2dEventTable *table = GetEventTable();

        // Search upwards through the inheritance hierarchy
        while (table)
        {
            if ( SearchEventTable((a2dEventTable&)*table, event) )
                return true;
            table = table->baseTable;
        }

        if ( event.IsCommandEvent() &&  GetParentEvtHandler() )
        {
             return GetParentEvtHandler()->GetEventHandler()->ProcessEvent(event);
        }

    }
    return false;
}

bool a2dEvtHandler::SearchEventTable(a2dEventTable& table, wxEvent& event)
{
    wxEventType eventType = event.GetEventType();
    int eventId = event.GetId();

    // BC++ doesn't like testing for m_fn without != 0
    for ( int i = 0; table.entries[i].m_fn != 0; i++ )
    {
        // the line using reference exposes a bug in gcc: although it _seems_
        // to work, it leads to weird crashes later on during program
        // execution
#ifdef __GNUG__
        a2dEventTableEntry entry = table.entries[i];
#else
        const a2dEventTableEntry& entry = table.entries[i];
#endif

        // match only if the event type is the same and the id is either -1 in
        // the event table (meaning "any") or the event id matches the id
        // specified in the event table either exactly or by falling into
        // range between first and last
        if ( eventType == entry.m_eventType )
        {
            int tableId1 = entry.m_id,
                tableId2 = entry.m_lastId;

            if ( (tableId1 == -1) ||
                 (tableId2 == -1 && eventId == tableId1) ||
                 (tableId2 != -1 &&
                    (eventId >= tableId1 && eventId <= tableId2)) )
            {
                event.Skip(false);
                event.m_callbackUserData = entry.m_callbackUserData;

                (this->*((a2dEvtHandlerEventFunction) (entry.m_fn)))(event);

                return !event.GetSkipped();
            }
        }
    }

    return false;
}

bool a2dEvtHandler::SearchDynamicEventProperties( wxEvent& event )
{
    wxEventType eventType = event.GetEventType();
    int eventId = event.GetId();

    //search properties for the one with this id.
    a2dNamedPropertyList::iterator iter;
    for( iter = m_propertylist.begin(); iter != m_propertylist.end(); ++iter )
    {
        a2dDynamicEventProperty *prop = wxDynamicCast( (*iter).Get(), a2dDynamicEventProperty );
        if( prop && eventType == prop->m_eventType && prop->m_fn != 0 )
        {
            int tableId1 = prop->m_id,
                tableId2 = prop->m_lastId;

            if ( (tableId1 == -1) ||
                 (tableId2 == -1 && eventId == tableId1) ||
                 (tableId2 != -1 &&
                    (eventId >= tableId1 && eventId <= tableId2)) )
            {
                event.Skip(false);
                event.m_callbackUserData = prop;
                (this->*((a2dEvtHandlerEventFunction) (prop->m_fn)))(event);

                return !event.GetSkipped();
            }
        }
    }
    return false;
}

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

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

a2dCommandId::a2dCommandId( const wxString& commandName ) 
{ 
    m_name = commandName; 

    // check if name is unique
    for( int indx = 1; GetHashMap().find( commandName ) != GetHashMap().end(); indx++ )
    {
        wxASSERT_MSG( 0, _("The command id name '") + commandName + _("' already exists") );
    }

    GetHashMap()[commandName] = this;
}

const a2dCommandId& a2dCommandId::GetCommandByName(const wxString& commandName)
{
    a2dHashMapCommandIds::iterator iterCommand = GetHashMap().find(commandName);
    return iterCommand != GetHashMap().end() ? *iterCommand->second : a2dCommand::sm_noCommandId;
}

a2dHashMapCommandIds &a2dCommandId::GetHashMap()
{
    static a2dMemoryCriticalSectionHelper helper;
    static a2dHashMapCommandIds namehash;
    return namehash;
}

// ----------------------------------------------------------------------------
// base docview command 
// ----------------------------------------------------------------------------

const a2dCommandId a2dCommand::sm_noCommandId = a2dCommandId( wxT("NoCommandId") );
const a2dCommandId a2dCommand::sm_noCommandTypeId = a2dCommandId( wxT("NoCommandTypeId") );
const a2dCommandId a2dCommand::sm_groupCommandId = a2dCommandId( wxT("GroupCommandId") );

a2dCommand::a2dCommand( bool canUndo, 
                                        const a2dCommandId& commandId,
                                        const a2dCommandId& commandTypeId,
                                        const wxString& menuString )
                                       : a2dPropObject()
{
    m_cmp = 0;
    m_canUndo = canUndo;
    m_commandId = &commandId;
    m_commandTypeId = &commandTypeId;
    m_menuString = menuString;
    #if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
        extern wxObject * CurrentSmartPointerOwner;
        CurrentSmartPointerOwner = this;
    #endif
}

a2dCommand::a2dCommand( const a2dCommand &other )
:   a2dPropObject( other, a2dPropObject::clone_deep )
{
    m_commandId = other.m_commandId;
    m_commandTypeId = other.m_commandTypeId;
    m_menuString = other.m_menuString;
    m_canUndo = other.m_canUndo;
    m_cmp = other.m_cmp;
}

a2dObject* a2dCommand::Clone( CloneOptions options ) const
{
    a2dGeneralGlobals->ReportErrorF( a2dError_CommandError, _T("%s"), _("clone not implemented for this command") );
    return NULL;
}

wxString a2dCommand::GetName() const
{ 
    if ( m_menuString.IsEmpty() )
        return m_commandId->GetName(); 
    return m_menuString;
}

a2dCommand::~a2dCommand()
{
}

a2dCommand *a2dCommand::CloneAndBind( a2dPropObject* WXUNUSED(object) )
{
    wxASSERT_MSG( 0 , wxT("a2dCommand::CloneAndBind not overloaded in derived class") );
    return 0;
}

bool a2dCommand::Redo()
{
    return Do();
}

bool a2dCommand::ClearAfterCurrentCommand( a2dCommand *current )
{
    return current == this;
}

a2dCommand *a2dCommand::FindPrevious( a2dCommand* WXUNUSED(current) ) const
{
    return 0;
}

a2dCommand *a2dCommand::FindNext( a2dCommand* WXUNUSED(current) ) const
{
    return 0;
}

bool a2dCommand::Remove( a2dCommand* WXUNUSED(command) )
{
    return false;
}

bool a2dCommand::ContainsCommand( a2dCommand *command )
{
    return command == this;
}

void a2dCommand::DistributeEvent( wxEventType eventType )
{
    if ( eventType == wxEVT_DO )
    {
        a2dCommandProcessorEvent event( wxEVT_DO, this );
        event.SetEventObject(this);
        a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );
    }
    else if ( eventType == wxEVT_UNDO )
    {
        a2dCommandProcessorEvent event( wxEVT_UNDO, this );
        event.SetEventObject(this);
        a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );
    }
    else if ( eventType == wxEVT_REDO )
    {
        a2dCommandProcessorEvent event( wxEVT_REDO, this );
        event.SetEventObject(this);
        a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );
    }
}

//----------------------------------------------------------------------------
// a2dCommandGroup
//----------------------------------------------------------------------------

a2dCommandGroup::a2dCommandGroup( const wxString &name, a2dCommandGroup* parent ) 
    : a2dCommand( true, a2dCommand::sm_groupCommandId )
{
       
    wxString idName;
    idName.Printf( wxT("%s_%ld"), name.c_str(), wxGenNewId() );

    m_commandId = new a2dCommandId( idName );
    
    m_groupName = name;
    m_parentGroup = parent;
    m_active = true;
}

a2dCommandGroup::~a2dCommandGroup(void)
{
    m_subcommands.clear();
    delete m_commandId;
}

a2dObject* a2dCommandGroup::Clone( CloneOptions options ) const
{
    a2dCommandGroup* clgr = new a2dCommandGroup( m_groupName, m_parentGroup );

    a2dCommandList::const_iterator iter = m_subcommands.begin();
    while( iter != m_subcommands.end() )
    {   
        a2dCommand* obj = *iter;
        a2dCommand* clone = (a2dCommand*) obj->Clone( options );      
        clgr->m_subcommands.push_back( clone );
        iter++;
    }
    return clgr;
}

bool a2dCommandGroup::ClearAfterCurrentCommand( a2dCommand *current )
{
    if( current == this )
        return true;

    int i = 0;
    a2dCommandList::reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {   
        a2dCommand *obj = *iter;
        if( obj->ClearAfterCurrentCommand( current ) )
        {
            // Everything after this command must be removed.
            a2dCommandList::reverse_iterator iterr = m_subcommands.rbegin();
            while( i > 0 && iterr != m_subcommands.rend() )
            {   
                m_subcommands.rerase( iterr ) ;
                i--;
            }
            return true;
        }
        iter++;
        i++;
    }
    return false;
}

bool a2dCommandGroup::ClearCommandsById( const a2dCommandId& commandId, a2dCommand *fromcommand )
{
    bool start = false;
    bool found = false;
    a2dCommandList::iterator iter = m_subcommands.begin();
    while( iter != m_subcommands.end() )
    {   
        a2dCommand *command = *iter;
        if( ( fromcommand == NULL || fromcommand == command || start ) )
        {
            start = true;
            if ( command->GetCommandId() == &commandId )
            {
                iter = m_subcommands.erase( iter );
                found = true;
            }
            else
                iter++;
        }
        else
            iter++;
    }
    return found;
}

a2dCommand *a2dCommandGroup::FindPrevious( a2dCommand *current ) const
{

    a2dCommandList::const_reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {   
        a2dCommand *obj = *iter;
        // Check if this command/group contains the current command
        if( obj->ContainsCommand( current ) )
        {
            // Check if this command/group also has a previous command
            a2dCommand *previous = obj->FindPrevious( current );
            
            // If yes, this is what we want
            if( previous )
                return previous;

            // Else find a command previous from our list
            iter++;
            if( iter != m_subcommands.rend() )
                return *iter;

            return 0;
        }
        iter++;
    }

    return 0;
}

a2dCommand *a2dCommandGroup::FindNext( a2dCommand *current ) const
{
    a2dCommandList::const_reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {   
        a2dCommand *obj = *iter;
        // Check if this command/group contains the current command
        if( obj->ContainsCommand( current ) )
        {
            // Check if this command/group also has a next command
            a2dCommand *next = obj->FindNext( current );
            
            // If yes, this is what we want
            if( next )
                return next;

            // Else find a command next from our list
            if( iter != m_subcommands.rbegin() )
                iter--;
            else
                return 0;

            if( iter != m_subcommands.rend() )
                return *iter;

            return 0;
        }
        iter++;
    }

    return 0;
}

bool a2dCommandGroup::Remove( a2dCommand *command )
{
    a2dCommandList::reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {    
        a2dCommand *obj = *iter;
        if ( command == obj )
        {
            iter = m_subcommands.rerase( iter );
            return true;
        }
        //check recursive/nested groups
        if ( obj->Remove( command ) )
        {
            return true;
        }
        iter++;
    }
    return false;
}

void a2dCommandGroup::Add( a2dCommand *command )
{
    m_subcommands.push_back( command );
}

bool a2dCommandGroup::ContainsCommand( a2dCommand *command )
{
    if( command==this )
        return true;

    a2dCommandList::reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {    
        a2dCommand *obj = *iter;
        if ( obj->ContainsCommand( command ) )
            return true;
        iter++;
    }
    return false;
}

bool a2dCommandGroup::Do()
{
    m_active = true;
    // Redo is forward
    a2dCommandList::iterator iter = m_subcommands.begin();
    while( iter != m_subcommands.end() )
    {    
        a2dCommand *obj = *iter;
        obj->SetCommandProcessor( m_cmp );
        if ( !obj->Do() )
            return false;
        iter++;
    }
    m_cmp->CommandGroupEnd( this );
    return true;
}

bool a2dCommandGroup::Undo()
{
    // Undo is backward
    a2dCommandList::reverse_iterator iter = m_subcommands.rbegin();
    while( iter != m_subcommands.rend() )
    {    
        a2dCommand *obj = *iter;
        if ( !obj->Undo() )
            return false;
        iter++;
    }
    return true;
}


//----------------------------------------------------------------------------
// a2dPropertyEditEvent
//----------------------------------------------------------------------------
DEFINE_EVENT_TYPE( wxEVT_PROPOBJECT_EDITPROPERTIES_EVENT )

a2dPropertyEditEvent::a2dPropertyEditEvent( a2dPropObject* object, a2dNamedPropertyList* properties ) 
    : a2dEvent(  wxID_ANY, a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT )
{    
    SetEventObject( object );
    m_properties = properties;
    m_edited = false;
}

a2dPropertyEditEvent::a2dPropertyEditEvent( const a2dPropertyEditEvent& other )
    : a2dEvent( other )
{
    m_properties = other.m_properties;
    m_edited = other.m_edited;
}

//----------------------------------------------------------------------------
// a2dCommand_SetProperty
//----------------------------------------------------------------------------

const a2dCommandId a2dCommand_SetProperty::Id = a2dCommandId( wxT("SetProperty") );

a2dCommand_SetProperty::a2dCommand_SetProperty():
    a2dCommand( true, Id )
{
    m_propRefObject = NULL;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyId* id ):
    a2dCommand( true, Id )
{
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, a2dNamedProperty* property ):
    a2dCommand( true, Id )
{
    m_property = property;
    m_propRefObject = object;
    m_id = property->GetId();
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdRefObject* id, a2dObject* value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dProperty* prop = new a2dProperty( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdObject* id, const wxObject& value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dObjectProperty* prop = new a2dObjectProperty( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdString* id, const wxString& value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dStringProperty* prop = new a2dStringProperty( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdBool* id, bool value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dBoolProperty* prop = new a2dBoolProperty( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdBool* id, const wxString& value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dNamedProperty *prop = id->CreatePropertyFromString( value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdInt16* id, wxInt16 value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dInt16Property* prop = new a2dInt16Property( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdUint16* id, wxUint16 value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dUint16Property* prop = new a2dUint16Property( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdInt32* id, wxInt32 value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dInt32Property* prop = new a2dInt32Property( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdUint32* id, wxUint32 value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dUint32Property* prop = new a2dUint32Property( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdDouble* id, double value ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dDoubleProperty* prop = new a2dDoubleProperty( id, value );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdColour* id, const wxColour& colour ):
    a2dCommand( true, Id, sm_noCommandTypeId, id->GetName() )
{
    a2dColourProperty* prop = new a2dColourProperty( id, colour );

    m_property = prop;
    m_propRefObject = object;
    m_id = id;
}


a2dCommand_SetProperty::~a2dCommand_SetProperty(void)
{
    m_propRefObject = NULL;
}

a2dCommand_SetProperty::a2dCommand_SetProperty( const a2dCommand_SetProperty &other )
:   a2dCommand ( other )
{
    m_propRefObject = other.m_propRefObject;
    m_property = other.m_property->Clone(a2dObject::clone_flat);
    m_id = other.m_id;
}

bool a2dCommand_SetProperty::Do(void)
{
    if ( m_propRefObject ) 
    {
        a2dNamedPropertyPtr propertyold = m_propRefObject->GetProperty( m_id );
        m_propRefObject->SetProperty( m_property );
        m_property = propertyold;
    }
        
    return true;
}

bool a2dCommand_SetProperty::Undo(void)
{
    if ( m_propRefObject )
    {
        a2dNamedPropertyPtr propertyold = m_propRefObject->GetProperty( m_id );
        
        if ( !m_property )
        {
            //the property did not exist before, so we need to remove the one that was added.
            m_propRefObject->RemoveProperty( m_id, true );
        }
        else
        {
            m_propRefObject->SetProperty( m_property );
        }

        m_property = propertyold;
    }

    return true;
}

// ----------------------------------------------------------------------------
// a2dCommandProcessor
// ----------------------------------------------------------------------------

const a2dCommandId a2dCommand_SetVariable::Id( wxT("SetVariable") );
const a2dCommandId a2dCommand_SetEnvironmentVariable::Id( wxT("SetEnv") );
const a2dCommandId a2dCommand_GetVariable::Id( wxT("GetVariable") );

a2dCommandProcessor::a2dCommandProcessor(int maxCommands)
{
    m_rootGroup = new a2dCommandGroup( _("Root"), NULL );
    m_currentGroup = m_rootGroup;
    m_maxNoCommands = maxCommands;
    m_currentCommand = NULL;
    m_undoAccelerator = wxT("\tCtrl+Z");
    m_redoAccelerator = wxT("\tCtrl+Y");
}

a2dCommandProcessor::~a2dCommandProcessor()
{
    ClearCommands();
}

bool a2dCommandProcessor::SmrtPtrRelease()
{
    static bool clearingCommands = false;
    if ( !clearingCommands )
    {
        //during clearing of command to not re-enter here.
        clearingCommands = true;
        ClearCommands();
        clearingCommands = false;
    }

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

a2dCommandGroup *a2dCommandProcessor::FindActiveGroup()
{
    a2dCommandGroup *group = m_currentGroup;

    for(;;)
    {
        if( group->m_subcommands.empty() )
            break;

        a2dCommandGroup *next = group->m_subcommands.back()->IsCommandGroup();
        if( !next || !next->m_active )
            break;

        group = next;
    }

    return group;
}

void a2dCommandProcessor::SetCurrentToLastActive()
{
    a2dCommandGroup *group = m_currentGroup;

    for(;;)
    {
        if( group->m_subcommands.empty() )
            break;

        a2dCommandGroup *next = group->m_subcommands.back()->IsCommandGroup();
        if( !next || !next->m_active || next->m_subcommands.empty() )
            break;

        group = next;
    }

    m_currentCommand = ( group->m_subcommands.empty() ) ? 0 : group->m_subcommands.back();
}

bool a2dCommandProcessor::DoCommand(a2dCommand& cmd)
{
#if defined(A2D_COMMAND_DEBUG) 
    wxLogDebug( wxT( "Do name = %s 0x%p" ), cmd.GetName().c_str(), &cmd );
#endif
    bool ret = cmd.Do();
    
    if ( ret )
        cmd.DistributeEvent( wxEVT_DO );
    return ret;
}

bool a2dCommandProcessor::UndoCommand(a2dCommand& cmd)
{
#if defined(A2D_COMMAND_DEBUG) 
    wxLogDebug( wxT( "UnDo name = %s 0x%p" ), cmd.GetName().c_str(), &cmd );
#endif
    bool ret = cmd.Undo();

    if ( ret )
        cmd.DistributeEvent( wxEVT_UNDO );
    return ret;
}

bool a2dCommandProcessor::RedoCommand(a2dCommand& cmd)
{
#if defined(A2D_COMMAND_DEBUG) 
    wxLogDebug( wxT( "ReDo name = %s 0x%p" ), cmd.GetName().c_str(), &cmd );
#endif
    bool ret = cmd.Redo();

    if ( ret )
        cmd.DistributeEvent( wxEVT_REDO );
    return ret;
}

void a2dCommandProcessor::SentBusyEvent( bool start, a2dCommand *command )
{
    if ( start )
    {
        a2dCommandProcessorEvent event( wxEVT_BEGINBUSY, command );
        event.SetEventObject(this);
        this->ProcessEvent( event );
    }
    else
    {
        a2dCommandProcessorEvent event( wxEVT_ENDBUSY, command );
        event.SetEventObject(this);
        this->ProcessEvent( event );
    }
}

// Pass a command to the processor. The processor calls Do();
// if successful, is appended to the command history unless
// storeIt is false.
bool a2dCommandProcessor::Submit(a2dCommand *command, bool storeIt)
{
    wxCHECK_MSG( command, false, _T("no command in a2dCommandProcessor::Submit") );

    SentBusyEvent( true, command );

    // to properly delete it if needed
    a2dSmrtPtr<a2dCommand> lcommand = command;

    command->SetCommandProcessor( this );
    if ( command->IsCommandGroup() )
    {
        wxStaticCast( command, a2dCommandGroup )->m_parentGroup = m_currentGroup; 
    }

    //first store, and if not right command, remove it again.
    if ( storeIt )
        Store(command);

    bool oke = false;
    try
    {
        oke = DoCommand(*command);
    }
    catch (const a2dCommandException& e)
    {
        a2dGeneralGlobals->ReportErrorF( a2dError_CommandError, _T("%s"),  e.getMessage().c_str() );
        oke = false;
    }


    if ( !oke )
    {
        if ( storeIt )
        {
            m_currentGroup->Remove( command );
            SetCurrentToLastActive();
        }

        SentBusyEvent( false, command );
        // the user code expects the command to be released/deleted
        return false;
    }

    SentBusyEvent( false, command );
    return true;
}

void a2dCommandProcessor::Store(a2dCommand *command)
{
    wxCHECK_RET( command, _T("no command in a2dCommandProcessor::Store") );

    // If there are too many command in the command list, delete one
    if (m_currentGroup->m_subcommands.size() == m_maxNoCommands)
        m_currentGroup->m_subcommands.pop_front();

    // If the complete list was undone, m_currentCommand will be 0
    // In this case, all commands must be cleared
    // This also happens if no commands have been added yet, but in this case
    // it doesn't hurt to clear the list
    if( !m_currentCommand )
        ClearCommands();
    else
        m_currentGroup->ClearAfterCurrentCommand( m_currentCommand );

    m_currentCommand = command;
    m_currentGroup->m_subcommands.push_back( command );
    //FindActiveGroup()->m_subcommands.push_back( command );
    SetMenuStrings();
}

bool a2dCommandProcessor::Undo()
{
    if ( m_currentCommand && m_currentCommand->CanUndo() )
    {
        if ( UndoCommand(*m_currentCommand) )
        {
            m_currentCommand = m_currentGroup->FindPrevious( m_currentCommand );
            SetMenuStrings();
            return true;
        }
    }

    return false;
}

bool a2dCommandProcessor::Redo()
{
    a2dCommand *redoCommand = (a2dCommand *) NULL;

    if ( m_currentCommand )
    {
        // is there anything to redo?
        a2dCommand *next = m_currentGroup->FindNext( m_currentCommand );
        if ( next )
        {
            redoCommand = next;
        }
    }
    else // no current command, redo the first one
    {
        // m_currentCommand is 0 is all commands have been undone
        // OR if no command was inserted yet
        if ( !m_currentGroup->m_subcommands.empty() )
            redoCommand = m_currentGroup->m_subcommands.front();
    }

    if (redoCommand)
    {
        bool success = RedoCommand(*redoCommand);
        if (success)
        {
            m_currentCommand = redoCommand;
            SetMenuStrings();
            return true;
        }
    }
    return false;
}

bool a2dCommandProcessor::CanUndo() const
{
    a2dCommand *command = GetCurrentCommand();

    return command && command->CanUndo();
}

bool a2dCommandProcessor::CanRedo() const
{
    if( m_currentCommand )
    {
        a2dCommand *next = m_currentGroup->FindNext( m_currentCommand );
        return next != 0;
    }
    else
    {
        return m_currentGroup->m_subcommands.size() != 0;
    }
}

void a2dCommandProcessor::Initialize()
{
    SetCurrentToLastActive();
    SetMenuStrings();
}

void a2dCommandProcessor::SetMenuStrings()
{
    // sent event wxEVT_MENUSTRINGS
    a2dCommandProcessorEvent event( 
            m_currentCommand,
            GetUndoMenuLabel(),
            CanUndo(),
            GetRedoMenuLabel(),
            CanRedo()
        );
    event.SetEventObject(this);
    a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( event );
}

// Gets the current Undo menu label.
wxString a2dCommandProcessor::GetUndoMenuLabel() const
{
    wxString buf;
    if (m_currentCommand)
    {
        wxString commandName(m_currentCommand->GetName());
        if (commandName == wxT("")) commandName = _("Unnamed command");
        bool canUndo = m_currentCommand->CanUndo();
        if (canUndo)
            buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator;
        else
            buf = wxString(_("Can't &Undo ")) + commandName + m_undoAccelerator;
    }
    else
    {
        buf = _("&Undo") + m_undoAccelerator;
    }
    
    return buf;
}

// Gets the current Undo menu label.
wxString a2dCommandProcessor::GetRedoMenuLabel() const
{
    a2dCommand *redoCommand;
    wxString buf;

    if (m_currentCommand)
    {
        // We can redo, if we're not at the end of the history.
        redoCommand = m_currentGroup->FindNext( m_currentCommand );
    }
    else
    {
        redoCommand = m_currentGroup->m_subcommands.empty() ? 0 : m_currentGroup->m_subcommands.front();
    }
    if ( redoCommand )
    {
        wxString redoCommandName(redoCommand->GetName());
        if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command");
        buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
    }
    else
    {
        buf = _("&Redo") + m_redoAccelerator;
    }
    return buf;
}

void a2dCommandProcessor::ClearCommands()
{
    m_rootGroup->m_subcommands.clear();

    m_currentCommand = 0;
}

bool a2dCommandProcessor::SetOrAddPropertyToObject( a2dPropObject* propRefObject, const wxString& name, const wxString& value, bool withUndo )
{
    wxASSERT_MSG( propRefObject != 0 , wxT("a2dPropObject not NULL") );

    // get the id object from the id hash table
    a2dPropertyId *id = propRefObject->HasPropertyId( name );
    if( !id )
        return false;

    a2dNamedProperty *prop = id->CreatePropertyFromString( value );

    if( !prop )
        return false;

    return Submit( new a2dCommand_SetProperty( propRefObject, prop ), withUndo );
}

bool a2dCommandProcessor::SetOrAddPropertyToObject( a2dPropObject* propRefObject, a2dNamedProperty *property, bool withUndo )
{
    wxASSERT_MSG( propRefObject != 0, wxT("a2dPropObject not NULL") );

    return Submit( new a2dCommand_SetProperty( propRefObject, property ), withUndo );
}

a2dCommandGroup *a2dCommandProcessor::CommandGroupBegin( const wxString &name )
{
    a2dCommandGroup *group = new a2dCommandGroup( name, m_currentGroup );
#if defined(A2D_COMMAND_DEBUG) 
    wxLogDebug( wxT( "Open Group = %s 0x%p" ), name.c_str(), group );
#endif
    group->SetCommandProcessor( this );
    //store in the group m_currentGroup!!
    Store( group );
    //now change to the new group
    m_currentGroup = group;
    return group;
}

void a2dCommandProcessor::CommandGroupEnd( a2dCommandGroup *group )
{
    m_currentGroup = group->m_parentGroup;
    group->m_active = false;
    a2dCommandGroup* activeGroup = FindActiveGroup();
#if defined(A2D_COMMAND_DEBUG) 
    wxLogDebug( wxT( "End Group = %s 0x%p" ), group->GetGroupName().c_str(), group );
#endif
    wxASSERT( activeGroup == m_currentGroup );
    //parent group must be active
    wxASSERT( m_currentGroup->m_active );
    SetCurrentToLastActive();
    SetMenuStrings();
}

//----------------------------------------------------------------------------
// a2dEventDistributer
//----------------------------------------------------------------------------

a2dEventDistributer::a2dEventDistributer()
{

}

a2dEventDistributer::~a2dEventDistributer()
{
    m_handlers.clear();
}

bool a2dEventDistributer::ProcessEvent( wxEvent& event)
{
    bool retCode = false; 
    wxEventHandlersList::iterator iter;
    for( iter = m_handlers.begin(); iter != m_handlers.end(); ++iter )
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;
        if ( wrappedhandler->m_valid && 
             event.GetEventObject() != wrappedhandler->m_handler && //not to itself
             wrappedhandler->WantsType( event.GetEventType() )
           ) 
        {
            if ( wrappedhandler->m_type == a2dDistributedEventReceiver::a2dReceiverwxEvtHandler )
                retCode |= ((wxEvtHandler*)wrappedhandler->m_handler)->ProcessEvent( event );
            else if ( wrappedhandler->m_type == a2dDistributedEventReceiver::a2dReceivera2dObject )
//              klion: next code not works for classes from a2dObject, which are not used with SmartPtr.
//              && ((a2dEvtHandler*)wrappedhandler->m_handler)->GetOwnedBy())
                retCode |= ((a2dObject*)wrappedhandler->m_handler)->ProcessEvent( event );
        }

        //we do not care if it was skipped in one of the subhandlers or not
        //the others still need to be done.
        event.Skip( false );
    }
    event.Skip( true );

    //now clean up unregistrated handlers in the last iteration.
    //This delayed deletion prevents going to handlers that are removed by any handler during the 
    //processing of the event here.
    //When Unregistering an event, only a flag is set, 
    //which is checked before sending an event to the handler.
    iter = m_handlers.begin();
    while ( iter != m_handlers.end() )
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;

        if ( ! wrappedhandler->m_valid  )
            iter = m_handlers.erase( iter );
        else
            iter++;
    }

    return retCode;
}

a2dDistributedEventReceiver* a2dEventDistributer::Register( wxEvtHandler* handler )
{
    bool found = false;

    wxEventHandlersList::iterator iter = m_handlers.begin();
    while ( iter != m_handlers.end() && !found)
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;

        if ( wrappedhandler->m_valid && wrappedhandler->m_handler == handler )
        {
            found = true;
            break;
        }
        iter++;
    }

    if ( !found )
    {
        m_handlers.push_back( new a2dDistributedEventReceiver( handler ) );
        return m_handlers.back();
    }
    else
        return *iter;
}

bool a2dEventDistributer::Unregister( wxEvtHandler* handler )
{
    bool found = false;

    forEachIn( wxEventHandlersList, &m_handlers )
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;
        if ( wrappedhandler->m_valid && wrappedhandler->m_handler == handler )
        {
            found = true;
            wrappedhandler->m_valid = false;
        }
    }

    return found;
}

a2dDistributedEventReceiver* a2dEventDistributer::Register( a2dObject* handler )
{
    bool found = false;

    wxEventHandlersList::iterator iter = m_handlers.begin();
    while ( iter != m_handlers.end() && !found)
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;

        if ( wrappedhandler->m_valid && (wxObject*)wrappedhandler->m_handler == (wxObject*)handler )
        {
            found = true;
            break;
        }
        iter++;
    }

    if ( !found )
    {
        m_handlers.push_back( new a2dDistributedEventReceiver( handler ) );
        return m_handlers.back();
    }
    else
        return *iter;
}

bool a2dEventDistributer::Unregister( a2dObject* handler )
{
    bool found = false;

    wxEventHandlersList::iterator iter = m_handlers.begin();
    while ( iter != m_handlers.end() && !found)
    {
        a2dDistributedEventReceiver *wrappedhandler = *iter;

        if ( wrappedhandler->m_valid && (wxObject*)wrappedhandler->m_handler == (wxObject*)handler )
        {
            found = true;
            wrappedhandler->m_valid = false;
        }
        iter++;
    }

    return found;
}

// ----------------------------------------------------------------------------
// a2dGeneralModule
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(a2dGeneralModule, wxModule)

//! a global pointer to get to global instance of important classes.
A2DGENERALDLLEXP a2dSmrtPtr<a2dGeneralGlobal> a2dGeneralGlobals = new a2dGeneralGlobal();
//a2dGeneralGlobal* a2dGeneralGlobals = NULL;


bool a2dGeneralModule::OnInit()
{
    a2dGeneralGlobals = new a2dGeneralGlobal();
    return true;
}

void a2dGeneralModule::OnExit()
{
    a2dGeneralGlobals = NULL;
}

// ----------------------------------------------------------------------------
// a2dGeneralGlobal
// ----------------------------------------------------------------------------

a2dPathList a2dGeneralGlobal::m_configpath = a2dPathList();
bool a2dGeneralGlobal::m_showlog = true;
a2dErrorVector a2dGeneralGlobal::m_errors = a2dErrorVector();
a2dEventDistributer* a2dGeneralGlobal::m_docviewEventDistributer = new a2dEventDistributer();
wxArrayInt a2dGeneralGlobal::m_ignoredErrorIds = wxArrayInt();
a2dVariablesHash a2dGeneralGlobal::m_variableList = a2dVariablesHash();
a2dPropertyIdList a2dGeneralGlobal::m_dynamicIdList = a2dPropertyIdList();

IMPLEMENT_DYNAMIC_CLASS(a2dGeneralGlobal, a2dObject)

a2dGeneralGlobal::a2dGeneralGlobal()
{
    m_showlog = true;
}

a2dGeneralGlobal::~a2dGeneralGlobal()
{
    m_errors.clear();
    //klion: it is for check last instance the 'a2dGeneralGlobal' class 
    //       to destroy static member 'm_docviewEventDistributer'
    if ( a2dGeneralGlobals == (a2dGeneralGlobal*)NULL )
    {
        if ( m_docviewEventDistributer )
            delete m_docviewEventDistributer;
        m_docviewEventDistributer = NULL;
    }
    m_dynamicIdList.DeleteObjects();
}

a2dObject* a2dGeneralGlobal::Clone( CloneOptions WXUNUSED(options) ) const
{
    wxLogMessage( _("Not implemented") );
    return NULL;
}

#if wxART2D_USE_CVGIO
void a2dGeneralGlobal::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut &WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts), a2dObjectList* WXUNUSED(towrite) )
{
    wxLogMessage( _("Not implemented") );
}

void a2dGeneralGlobal::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
    wxLogMessage( _("Not implemented") );
}

#endif //wxART2D_USE_CVGIO

void a2dGeneralGlobal::SetEventDistributer( a2dEventDistributer* docviewEventDistributer ) 
{ 
    if ( m_docviewEventDistributer )
        delete m_docviewEventDistributer;
    m_docviewEventDistributer = docviewEventDistributer; 
}

void a2dGeneralGlobal::ResetErrors() 
{ 
    m_errors.clear();
    //wxLog* target = wxLog::GetActiveTarget();
    //target->Flush();
}

void a2dGeneralGlobal::IgnoreError( unsigned int id )
{
    if( m_ignoredErrorIds.Index( id ) == wxNOT_FOUND )
    {
        m_ignoredErrorIds.Add( id );
    }
}

void a2dGeneralGlobal::ReportError( const a2dError& error, const wxString& errorstr )
{
    if( m_ignoredErrorIds.Index( error.GetErrorCode() ) != wxNOT_FOUND )
        return;

    a2dError errorc( error );
    if ( !errorstr.IsEmpty() )
        errorc.SetErrorMessage(errorstr);

    m_errors.push_back( errorc  );

    if ( m_showlog )
        wxLogError( errorc.GetErrorMessage() );
}


#if wxCHECK_VERSION(2,9,0)

#if !wxUSE_UTF8_LOCALE_ONLY
void a2dGeneralGlobal::DoPrintfWchar( const a2dError& error, const wxChar *format, ...)
{
    va_list args;
    va_start(args, format);
    wxString out;

    out.PrintfV(format, args);
    va_end(args);

    ReportError( error, out );
}
#endif // !wxUSE_UTF8_LOCALE_ONLY

#if wxUSE_UNICODE_UTF8
void a2dGeneralGlobal::DoPrintfUtf8( const a2dError& error, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    wxString out;

    out.PrintfV(format, args);
    va_end(args);

    ReportError( error, out );
}
#endif // wxUSE_UNICODE_UTF8

#else
/*
void a2dGeneralGlobal::ReportErrorFF( const a2dError& error, ... )
{
    wxString errorformat = error.GetErrorMessage(); 
    if ( errorformat.IsEmpty() )
        errorformat = wxT("%s");

    va_list ap;

    wxString errorstr;
    va_start( ap, errorformat );
   
    errorstr.PrintfV( errorformat, ap );
    va_end( ap );

    ReportError( error, errorstr );
}
*/
void a2dGeneralGlobal::ReportErrorF( const a2dError& error, const wxChar* Format, ... )
{       
    va_list ap;

    wxString errorstr;
    va_start( ap, Format );
   
    errorstr.PrintfV( Format, ap );
    va_end( ap );

    ReportError( error, errorstr );
}

void a2dGeneralGlobal::ReportWarningF( const a2dError& error, const wxChar* Format, ... )
{
    va_list ap;

    wxString errorstr;
    va_start( ap, Format );
   
    errorstr.PrintfV( Format, ap );
    va_end( ap );

    ReportWarning( error, errorstr );
}

#endif //wxCHECK_VERSION(2,9,0)


void a2dGeneralGlobal::ReportWarning( const a2dError& error, const wxString& errorstr )
{
    if( m_ignoredErrorIds.Index( error.GetErrorCode() ) != wxNOT_FOUND )
        return;

    wxString errorsmes = error.GetErrorMessage(); 
    if ( !errorstr.IsEmpty() )
        errorsmes = errorstr;
    m_errors.push_back( a2dError( error.GetIdName(), errorsmes, true ) );


    if ( m_showlog )
        wxLogError( errorsmes );
}

wxString a2dGeneralGlobal::GetErrorsAsString()
{
    wxString errors;
    forEachIn( a2dErrorVector, &m_errors )
    {
        a2dErrorVector::value_type errorRecord = *iter;
        errors += errorRecord.GetErrorMessage() + wxT(".\n");
    }
    return errors;    
}

void a2dGeneralGlobal::SendToLogTarget()
{
    forEachIn( a2dErrorVector, &m_errors )
    {         
        a2dErrorVector::value_type errorRecord = *iter;
        wxLogError( errorRecord.GetErrorMessage() );
    }
    ResetErrors();
}

a2dErrorWarningCode a2dGeneralGlobal::GetLastErrorCode() const
{ 
    if ( m_errors.size() ) 
        return m_errors.back().GetErrorCode();
    return a2dError_NoError.GetErrorCode();
}

a2dError a2dGeneralGlobal::GetLastError() const
{ 
    if ( m_errors.size() ) 
        return m_errors.back();
    return a2dError_NoError;
}


wxString* a2dGeneralGlobal::GetVariableString( const wxString& variablename )
{
    wxString*  prop = GetVariablesHash().GetVariableString( variablename );

    if( !prop )
    {
        a2dGeneralGlobals->ReportError( a2dError_GetVar, _("wrong variable name, variable does not exist") );
        return NULL;// error, variable does not exist
    }

    return prop;
}

wxString a2dGeneralGlobal::GetWxArt2DVar( bool withSep ) const
{
    wxString art2Droot;
    wxGetEnv(_T("WXART2D"), &art2Droot );
    if( art2Droot.IsEmpty() )
    {
#ifndef _GUNIX
        wxMessageBox(_T(" WXART2D variable not set\nPlease set the WXART2D environment string to the correct dir.\n\nExample : WXART2D=c:\\wxArt2D\n\n"),_T("environment error"), wxOK);
#else
        wxMessageBox(_T(" WXART2D variable not set\nPlease set the WXART2D environment string to the correct dir.\n\nExample : WXART2D=/user/home/wxArt2D; export WXART2D \n\n"),_T("environment error"), wxOK);
#endif
    }
    else
    {
        if ( withSep )
            return art2Droot + wxT("/");
    }
    return art2Droot;
}

wxString a2dGeneralGlobal::GetWxArt2DArtVar( bool withSep ) const
{
    wxString* artdir = a2dGeneralGlobals->GetVariablesHash().GetVariableString(  wxT( "WXART2D_ART" ) );
    wxString artroot;
    if ( !artdir || artdir->IsEmpty() )
    {
        wxGetEnv(_T("WXART2D_ART"), &artroot );
        if( artroot.IsEmpty() )
        {
            wxGetEnv(_T("WXART2D"), &artroot );
            if( artroot.IsEmpty() )
            {
        #ifndef _GUNIX
                wxMessageBox(_T("WXART2D_ART or WXART2D variable not set\nPlease set the WXART2D environment string to the correct dir.\n\nExample : WXART2D=c:\\wxArt2D\n\n"),_T("environment error"), wxOK);
        #else
                wxMessageBox(_T("WXART2D_ART or WXART2D variable not set\nPlease set the WXART2D environment string to the correct dir.\n\nExample : WXART2D=/user/home/wxArt2D; export WXART2D \n\n"),_T("environment error"), wxOK);
        #endif
                return artroot;
            }
            artroot += wxT("/art");
        }
    }
    else
        artroot = *artdir;
    if ( withSep )
        return artroot + wxT("/");
    return artroot;
}


//----------------------------------------------------------------------------
// a2dComEvent
//----------------------------------------------------------------------------
DEFINE_EVENT_TYPE( a2dComEvent::sm_changedProperty )
DEFINE_EVENT_TYPE( a2dComEvent::sm_changedRefObject )
DEFINE_EVENT_TYPE( a2dComEvent::sm_non )

IMPLEMENT_DYNAMIC_CLASS( a2dComEvent, wxEvent )

DEFINE_EVENT_TYPE( a2dEVT_COM_EVENT )

a2dComEvent::a2dComEvent( wxObject* sender, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = 0;
    m_ownProp = false;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
} 

a2dComEvent::a2dComEvent( a2dPropObject* sender, const a2dPropertyId* id, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = sender->FindProperty( id );
    m_ownProp = false;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, a2dNamedProperty* property, const wxEventType* eventid, bool ownProp )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    if ( ownProp )
        m_property = property->Clone( a2dObject::clone_flat );
    else
        m_property = property;
    m_ownProp = ownProp;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dNamedProperty& property, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = property.Clone( a2dObject::clone_flat );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, a2dObject* refObject, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dProperty( a2dPropertyIdRefObject::GetDummy(), refObject );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdRefObject* id, a2dObject* refObject, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dProperty( id, refObject );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdBool* id, bool propertyValue, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dBoolProperty( id, propertyValue );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdUint16* id, wxUint16 propertyValue, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dUint16Property( id, propertyValue );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdInt32* id, wxInt32 propertyValue, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dInt32Property( id, propertyValue );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdDouble* id, double propertyValue, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dDoubleProperty( id, propertyValue );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent( wxObject* sender, const a2dPropertyIdString* id, const wxString&  propertyValue, const wxEventType* eventid )
    : wxEvent( wxID_ANY, a2dEVT_COM_EVENT )
{
    SetEventObject( sender );
    m_handler = NULL;
    m_property = new a2dStringProperty( id, propertyValue );
    m_ownProp = true;
    m_comid = eventid;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::a2dComEvent()
    : wxEvent( -1, a2dEVT_COM_EVENT )
{
    SetEventObject( 0 );
    m_handler = NULL;
    m_ownProp = false;
    m_comid = &sm_non;
    m_comReturn = &sm_non;
    m_refcount = 0;
}

a2dComEvent::~a2dComEvent()
{
    wxASSERT_MSG(  m_refcount == 0, wxT("deleting a2dComEvent while referenced") );
    if ( m_ownProp )
        delete m_property;
}

a2dComEvent::a2dComEvent( const a2dComEvent& other )
    : wxEvent( other )
{
    m_property = other.m_property ? other.m_property->Clone( a2dObject::clone_flat ) : 0;
    m_ownProp = true;
    m_comid = other.m_comid;
    m_comReturn = other.m_comReturn;
    m_handler = other.m_handler;

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

wxEvent* a2dComEvent::Clone(void) const
{
    return new a2dComEvent( *this );
}

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