comevt.h

Go to the documentation of this file.

/*! \file wx/general/comevt.h
    \brief command processor and intializing and event handling classes specific for wxDocview.

    wxDocview has its own event handling classes which are almost equal to the wxWidgets ones.
    But had to be duplicated to be able to have a a2dObject at the top the class tree.
    So things like an a2dCanvasObject can be serialized, even if it can handle events.

    a2dGeneralGlobal is the class for storing basic stuff like error messages and application wide
    variables. It is also used for distributing messages ( a2dEventDistributer )with the wxDocview library.
    
    a2dCommandProcessor is the basic class on which command processing is based.

    \author Klaas Holwerda
    \date Created 05/07/03

    Copyright: 2001-2004 (C) Klaas Holwerda

    Licence: wxWidgets licence

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

#ifndef _COMEVTH__
#define _COMEVTH__

#include "wx/list.h"
#include "wx/event.h"
#include "wx/cmdproc.h"
#include <wx/module.h>

#if wxCHECK_VERSION(2,9,0)
#include "wx/chartype.h"
#include "wx/strvararg.h"
#endif

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

class A2DGENERALDLLEXP a2dEvtHandler;

//! \cond

typedef void (a2dEvtHandler::*a2dObjectEventFunction)(wxEvent&);
typedef void (a2dEvtHandler::*a2dEventFunction)(wxEvent&);

#if wxUSE_GUI
typedef void (a2dEvtHandler::*a2dCommandEventFunction)(wxCommandEvent&);
typedef void (a2dEvtHandler::*a2dScrollEventFunction)(wxScrollEvent&);
typedef void (a2dEvtHandler::*a2dScrollWinEventFunction)(wxScrollWinEvent&);
typedef void (a2dEvtHandler::*a2dSizeEventFunction)(wxSizeEvent&);
typedef void (a2dEvtHandler::*a2dMoveEventFunction)(wxMoveEvent&);
typedef void (a2dEvtHandler::*a2dPaintEventFunction)(wxPaintEvent&);
typedef void (a2dEvtHandler::*a2dEraseEventFunction)(wxEraseEvent&);
typedef void (a2dEvtHandler::*a2dMouseEventFunction)(wxMouseEvent&);
typedef void (a2dEvtHandler::*a2dCharEventFunction)(wxKeyEvent&);
typedef void (a2dEvtHandler::*a2dFocusEventFunction)(wxFocusEvent&);
typedef void (a2dEvtHandler::*a2dChildFocusEventFunction)(wxChildFocusEvent&);
typedef void (a2dEvtHandler::*a2dActivateEventFunction)(wxActivateEvent&);
typedef void (a2dEvtHandler::*a2dMenuEventFunction)(wxMenuEvent&);
typedef void (a2dEvtHandler::*a2dJoystickEventFunction)(wxJoystickEvent&);
typedef void (a2dEvtHandler::*a2dDropFilesEventFunction)(wxDropFilesEvent&);
typedef void (a2dEvtHandler::*a2dInitDialogEventFunction)(wxInitDialogEvent&);
typedef void (a2dEvtHandler::*a2dUpdateUIEventFunction)(wxUpdateUIEvent&);
typedef void (a2dEvtHandler::*a2dIdleEventFunction)(wxIdleEvent&);
typedef void (a2dEvtHandler::*a2dCloseEventFunction)(wxCloseEvent&);
typedef void (a2dEvtHandler::*a2dShowEventFunction)(wxShowEvent&);
typedef void (a2dEvtHandler::*a2dIconizeEventFunction)(wxIconizeEvent&);
typedef void (a2dEvtHandler::*a2dMaximizeEventFunction)(wxMaximizeEvent&);
typedef void (a2dEvtHandler::*a2dNavigationKeyEventFunction)(wxNavigationKeyEvent&);
typedef void (a2dEvtHandler::*a2dPaletteChangedEventFunction)(wxPaletteChangedEvent&);
typedef void (a2dEvtHandler::*a2dQueryNewPaletteEventFunction)(wxQueryNewPaletteEvent&);
typedef void (a2dEvtHandler::*a2dWindowCreateEventFunction)(wxWindowCreateEvent&);
typedef void (a2dEvtHandler::*a2dWindowDestroyEventFunction)(wxWindowDestroyEvent&);
typedef void (a2dEvtHandler::*a2dSetCursorEventFunction)(wxSetCursorEvent&);
typedef void (a2dEvtHandler::*a2dNotifyEventFunction)(wxNotifyEvent&);
typedef void (a2dEvtHandler::*a2dHelpEventFunction)(wxHelpEvent&);
typedef void (a2dEvtHandler::*a2dContextMenuEventFunction)(wxContextMenuEvent&);
typedef void (a2dEvtHandler::*a2dMouseCaptureChangedEventFunction)(wxMouseCaptureChangedEvent&);
typedef void (a2dEvtHandler::*a2dCommandEventFunction)(wxCommandEvent&);
#endif // wxUSE_GUI

//! \endcond

/*! \addtogroup eventhandlers
*  @{
*/

//! updating user interface event
#define A2D_EVT_UPDATE_UI(id, func) \
     A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_UPDATE_UI, id, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dUpdateUIEventFunction > ( & func ), (wxObject *) NULL ),
//! add menu event
#define A2D_EVT_MENU(id, func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_MENU_SELECTED, id, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCommandEventFunction > ( & func ), (wxObject *) NULL ),

// Generic events
#define A2D_EVT_CUSTOM(event, winid, func) A2D_DECLARE_EVENT_TABLE_ENTRY( event, winid, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) & func, (wxObject *) NULL ),
#define A2D_EVT_CUSTOM_RANGE(event, id1, id2, func) A2D_DECLARE_EVENT_TABLE_ENTRY( event, id1, id2, (a2dObjectEventFunction) (a2dEventFunction) & func, (wxObject *) NULL ),

// Miscellaneous
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SIZE(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SIZE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dSizeEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SIZING(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SIZING, -1, -1, (a2dObjectEventFunction) (a2dEventFunction) (a2dSizeEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOVE(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOVE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMoveEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOVING(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOVING, -1, -1, (a2dObjectEventFunction) (a2dEventFunction) (a2dMoveEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CLOSE(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CLOSE_WINDOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCloseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_END_SESSION(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_END_SESSION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCloseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_QUERY_END_SESSION(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_QUERY_END_SESSION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCloseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_PAINT(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_PAINT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dPaintEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_NC_PAINT(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_NC_PAINT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dPaintEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_ERASE_BACKGROUND(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ERASE_BACKGROUND, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dEraseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CHAR(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CHAR, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCharEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_KEY_DOWN(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_KEY_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCharEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_KEY_UP(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_KEY_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCharEventFunction) & func, (wxObject *) NULL ),
#if wxUSE_HOTKEY
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_HOTKEY(id, func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_HOTKEY, id, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCharEventFunction) & func, (wxObject *) NULL ),
#endif
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CHAR_HOOK(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CHAR_HOOK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCharEventFunction) & func, NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MENU_OPEN(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_OPEN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMenuEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MENU_CLOSE(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_CLOSE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMenuEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MENU_HIGHLIGHT(winid, func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_HIGHLIGHT, winid, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMenuEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MENU_HIGHLIGHT_ALL(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_HIGHLIGHT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMenuEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SET_FOCUS(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SET_FOCUS, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dFocusEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_KILL_FOCUS(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_KILL_FOCUS, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dFocusEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CHILD_FOCUS(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CHILD_FOCUS, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (wxCommandEventFunction) (a2dChildFocusEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_ACTIVATE(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ACTIVATE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dActivateEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_ACTIVATE_APP(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ACTIVATE_APP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dActivateEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_END_SESSION(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_END_SESSION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCloseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_QUERY_END_SESSION(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_QUERY_END_SESSION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCloseEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_DROP_FILES(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_DROP_FILES, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dDropFilesEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_INIT_DIALOG(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_INIT_DIALOG, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dInitDialogEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SYS_COLOUR_CHANGED(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SYS_COLOUR_CHANGED, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dSysColourChangedFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SHOW(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SHOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dShowEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MAXIMIZE(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MAXIMIZE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMaximizeEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_ICONIZE(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ICONIZE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dIconizeEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_NAVIGATION_KEY(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_NAVIGATION_KEY, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dCommandEventFunction) (a2dNavigationKeyEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_PALETTE_CHANGED(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_PALETTE_CHANGED, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dPaletteChangedEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_QUERY_NEW_PALETTE(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_QUERY_NEW_PALETTE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dQueryNewPaletteEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_WINDOW_CREATE(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CREATE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dWindowCreateEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_WINDOW_DESTROY(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_DESTROY, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dWindowDestroyEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_SET_CURSOR(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_SET_CURSOR, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dSetCursorEventFunction) & func, (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOUSE_CAPTURE_CHANGED(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOUSE_CAPTURE_CHANGED, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) (a2dMouseCaptureChangedEventFunction) & func, (wxObject *) NULL ),

// Mouse events
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_LEFT_DOWN(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_LEFT_UP(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MIDDLE_DOWN(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MIDDLE_UP(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_RIGHT_DOWN(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_RIGHT_UP(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOTION(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOTION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_LEFT_DCLICK(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MIDDLE_DCLICK(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_RIGHT_DCLICK(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_LEAVE_WINDOW(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEAVE_WINDOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_ENTER_WINDOW(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ENTER_WINDOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOUSEWHEEL(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOUSEWHEEL, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),

//! All mouse events together 
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_MOUSE_EVENTS(func) \
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_DOWN, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_UP, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOTION, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEFT_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MIDDLE_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_RIGHT_DCLICK, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ENTER_WINDOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_LEAVE_WINDOW, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),\
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MOUSEWHEEL, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dMouseEventFunction > ( & func ), (wxObject *) NULL ),

// Idle event
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_IDLE(func) \
 A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_IDLE, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) (a2dEventFunction) static_cast < a2dIdleEventFunction > ( & func ), (wxObject *) NULL ),

//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_BUTTON(id, func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_BUTTON_CLICKED, id, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCommandEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_BUTTON_ANY(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_BUTTON_CLICKED, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCommandEventFunction > ( & func ), (wxObject *) NULL ),

//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CHOICE(id, func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_CHOICE_SELECTED, id, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCommandEventFunction > ( & func ), (wxObject *) NULL ),
//! a2dEvtHandler equivalent of wxEvthandler macro
#define A2D_EVT_CHOICE_ANY(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_CHOICE_SELECTED, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCommandEventFunction > ( & func ), (wxObject *) NULL ),

//!  @} eventhandlers

class A2DGENERALDLLEXP a2dDynamicEventProperty;
#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
    template class A2DGENERALDLLEXP a2dPropertyIdProp< a2dDynamicEventProperty >;
#endif
typedef a2dPropertyIdProp< class a2dDynamicEventProperty> a2dPropertyIdDynamicEventProperty;

// ============================================================================
// event handler and related classes
// ============================================================================

//! an entry from a static event table
/*!
  \ingroup events
*/
struct A2DGENERALDLLEXP a2dEventTableEntry
{
    //! constructor
    a2dEventTableEntry(const int& evType, int winid, int idLast,
                      a2dObjectEventFunction fn, wxObject *data)
        : m_eventType(evType),
          m_id(winid),
          m_lastId(idLast),
          m_callbackUserData(data),
          m_fn(fn)
    { }

    //! the reference to event type: this allows us to not care about the
    //! (undefined) order in which the event table entries and the event types
    //! are initialized: initially the value of this reference might be
    //! invalid, but by the time it is used for the first time, all global
    //! objects will have been initialized (including the event type constants)
    //! and so it will have the correct value when it is needed
    const int& m_eventType;

    //! the range of ids for this entry: if m_lastId == wxID_ANY, the range
    //! consists only of m_id, otherwise it is m_id..m_lastId inclusive
    int m_id,
        m_lastId;

    //! arbitrary user data asosciated with the callback
    wxObject* m_callbackUserData;

    //! function to call: not a2dEventFunction, because of dependency problems
    a2dObjectEventFunction m_fn;

    a2dEventTableEntry& operator=(const a2dEventTableEntry&);
};

// ----------------------------------------------------------------------------
// a2dEventTable: an array of event entries terminated with {0, 0, 0, 0, 0}
// ----------------------------------------------------------------------------

//! for defining static event tables specific for a2dObject/a2dEvtHandler derived objects.
struct A2DGENERALDLLEXP a2dEventTable
{
    const a2dEventTable *baseTable;    // base event table (next in chain)
    const a2dEventTableEntry *entries; // bottom of entry array
};

//! declarates one entry in a static event table.
#define A2D_DECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj) \
    a2dEventTableEntry(type, winid, idLast, fn, obj)


//! property used to add dynamic events to the a2dEvtHandler
/*!
    You can add properties of this type ( or derived ) to a2dPropObject.
    The wxEvtHandler will call the event function when the proper event is found.

    \ingroup events property
*/
class A2DGENERALDLLEXP a2dDynamicEventProperty : public a2dNamedProperty
{
    DECLARE_DYNAMIC_CLASS(a2dDynamicEventProperty)

public:

    a2dDynamicEventProperty();

    a2dDynamicEventProperty( const a2dPropertyIdDynamicEventProperty* propid, int evType, int id, int idLast, a2dObjectEventFunction fn );

    a2dDynamicEventProperty( const a2dDynamicEventProperty &other );

    virtual ~a2dDynamicEventProperty();

    a2dNamedProperty* Clone( a2dObject::CloneOptions options ) const;

    virtual void Assign( const a2dNamedProperty &other );

    //! Construct a new property object from a string
    //! If this is not appropriate, this may return NULL
    static a2dDynamicEventProperty *CreatePropertyFromString(  const a2dPropertyIdDynamicEventProperty* WXUNUSED(id), const wxString& WXUNUSED(value) ) { return 0; }

    //! type of the event.
    int m_eventType;

    //! the range of ids for this entry: if m_lastId == wxID_ANY, the range
    //! consists only of m_id, otherwise it is m_id..m_lastId inclusive
    int m_id;
    
    //! see m_id
    int m_lastId;

    //! function to call. 
    a2dObjectEventFunction m_fn; 

protected:

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );
    virtual void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

};

class A2DGENERALDLLEXP a2dEvent : public wxEvent
{

public:

    a2dEvent(int id = 0, wxEventType eventType = wxEVT_NULL)
        : wxEvent( id, eventType )
    {
        SetIntTimeStamp();
    }

    void SetIntTimeStamp()
    {
        if ( ms_timestamp == LONG_MAX )   
            ms_timestamp = 0;
        SetTimestamp( ++ms_timestamp );         
    }    

    static long ms_timestamp;
};

//! a2dEvtHandler the base class for all objects which are handling events and are derived 
/*! 
    from a2dPropObject and therefore have refcounting.
    The a2dEvtHandler is a smaller version of wxEvtHandler, but works the same
    for static event tables, as they are elsewhere in wxWindows.
    It was needed to limit the memory usage for each a2dCanvasObject.
    Next to this it handles dynamic event properties. Those properties are searched first followed
    by static event handling.
    For dynamic event a2dDynamicEventProperty ( or a derived property class ) is added to the property list.
    The userdata of the event that is handled by this property is set to the property itself just before calling
    the event handling function as is contained within a2dDynamicEventProperty. This makes it easy to get to the property
    within the event handling function.

    \ingroup events eventhandlers
*/
class A2DGENERALDLLEXP a2dEvtHandler : public a2dPropObject
{
public:

    //!constructor
    a2dEvtHandler();

    //!constructor
    a2dEvtHandler( const a2dEvtHandler& other, CloneOptions options );

    //! destructor
    virtual ~a2dEvtHandler();

    //! create an exact copy of this property
    virtual a2dObject* Clone( CloneOptions options ) const;

    //! to set this handler enabled or disabled.
    void SetEvtHandlerEnabled(bool enabled) { m_enabled = enabled; }

    //! is this handler enabled?
    bool GetEvtHandlerEnabled() const { return m_enabled; }

    //!get currently used eventhandler 
    a2dEvtHandler *GetEventHandler() const; 

    //! get parent object if available
    /*!
        A wxCommandEvent is sent to a parent when available.
    */
    virtual a2dEvtHandler* GetParentEvtHandler() { return NULL; }

    //!process an event right now for the object, starting with the first eventhandler
    //! in the list.
    /*!
        \param event event that is to be processed by object.
    */
    virtual bool ProcessEvent(wxEvent& event);

    //! search an event in the event table of the table returned by GetEventTable() 
    //! if processes return true else continue with baseclass event table.
    virtual bool SearchEventTable(a2dEventTable& table, wxEvent& event);


private:

    //! search for dynamic event properties
    bool SearchDynamicEventProperties( wxEvent& event );

    //!a dummy to make  BEGIN_EVENT_TABLE macro work 
    static const a2dEventTableEntry sm_eventTableEntries[];

protected:

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts, a2dObjectList* towrite );
    virtual void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    //!a dummy to make  BEGIN_EVENT_TABLE macro work 
    static const a2dEventTable sm_eventTable;

    //!virtual 
    /*!
        In a derived class this overriden function is where event searching begins.
        The following macros define this function in derived classes.
        Plus add a event table in the derived class.
        

        DECLARE_EVENT_TABLE() and BEGIN_EVENT_TABLE(theClass, baseClass) 
        END_EVENT_TABLE()  
    */
    virtual const a2dEventTable *GetEventTable() const;

    // Is event handler enabled?
    bool m_enabled;

private:

    DECLARE_DYNAMIC_CLASS(a2dEvtHandler)

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dEvtHandler( const a2dEvtHandler &other );
};

#if defined(WXDOCVIEW_USINGDLL)
template class A2DGENERALDLLEXP a2dSmrtPtr<a2dEvtHandler>;
#endif

typedef void (a2dEvtHandler::*a2dEvtHandlerEventFunction)(wxEvent&);

#define A2D_DECLARE_EVENT_TABLE() \
    private: \
        static const a2dEventTableEntry sm_eventTableEntries[]; \
    protected: \
        static const a2dEventTable        sm_eventTable; \
        virtual const a2dEventTable*      GetEventTable() const; 

// N.B.: when building DLL with Borland C++ 5.5 compiler, you must initialize
//       sm_eventTable before using it in GetEventTable() or the compiler gives
//       E2233 (see http://groups.google.com/groups?selm=397dcc8a%241_2%40dnews)

/*! \addtogroup eventhandlers
*  @{
*/

#define A2D_BEGIN_EVENT_TABLE(theClass, baseClass) \
    const a2dEventTable theClass::sm_eventTable = \
        { &baseClass::sm_eventTable, &theClass::sm_eventTableEntries[0] }; \
    const a2dEventTable *theClass::GetEventTable() const \
        { return &theClass::sm_eventTable; } \
    const a2dEventTableEntry theClass::sm_eventTableEntries[] = { \


#define A2D_BEGIN_EVENT_TABLE_TEMPLATE1(theClass, baseClass, T1) \
    template<typename T1> \
    const a2dEventTable theClass<T1>::sm_eventTable = \
        { &baseClass::sm_eventTable, &theClass<T1>::sm_eventTableEntries[0] }; \
    template<typename T1> \
    const a2dEventTable *theClass<T1>::GetEventTable() const \
        { return &theClass<T1>::sm_eventTable; } \
    template<typename T1> \
    const a2dEventTableEntry theClass<T1>::sm_eventTableEntries[] = { \

#define A2D_BEGIN_EVENT_TABLE_TEMPLATE2(theClass, baseClass, T1, T2) \
    template<typename T1, typename T2> \
    const a2dEventTable theClass<T1, T2>::sm_eventTable = \
        { &baseClass::sm_eventTable, &theClass<T1, T2>::sm_eventTableEntries[0] }; \
    template<typename T1, typename T2> \
    const a2dEventTable *theClass<T1, T2>::GetEventTable() const \
        { return &theClass<T1, T2>::sm_eventTable; } \
    template<typename T1, typename T2> \
    const a2dEventTableEntry theClass<T1, T2>::sm_eventTableEntries[] = { \

#define A2D_BEGIN_EVENT_TABLE_TEMPLATE3(theClass, baseClass, T1, T2, T3) \
    template<typename T1, typename T2, typename T3> \
    const a2dEventTable theClass<T1, T2, T3>::sm_eventTable = \
        { &baseClass::sm_eventTable, &theClass<T1, T2, T3>::sm_eventTableEntries[0] }; \
    template<typename T1, typename T2, typename T3> \
    const a2dEventTable *theClass<T1, T2, T3>::GetEventTable() const \
        { return &theClass<T1, T2, T3>::sm_eventTable; } \
    template<typename T1, typename T2, typename T3> \
    const a2dEventTableEntry theClass<T1, T2, T3>::sm_eventTableEntries[] = { \

#define A2D_END_EVENT_TABLE() A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_NULL, 0, 0, 0, 0 ) };

// helpers for writing shorter code below: declare an event macro taking 2, 1
// or none ids (the missing ids default to wxID_ANY)
//
// macro arguments:
//  - evt one of wxEVT_XXX constants
//  - id1, id2 ids of the first/last id
//  - fn the function (should be cast to the right type)
#define a2d__DECLARE_EVT2(evt, id1, id2, fn) \
    A2D_DECLARE_EVENT_TABLE_ENTRY(evt, id1, id2, fn, NULL),
#define a2d__DECLARE_EVT1(evt, id, fn) \
    a2d__DECLARE_EVT2(evt, id, wxID_ANY, fn)
#define a2d__DECLARE_EVT0(evt, fn) \
    a2d__DECLARE_EVT1(evt, wxID_ANY, fn)

//!  @} eventhandlers


class A2DGENERALDLLEXP a2dCommandProcessor;
#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DGENERALDLLEXP a2dSmrtPtr<a2dCommandProcessor>;
#endif

class A2DGENERALDLLEXP a2dCommandId;

class A2DGENERALDLLEXP a2dHashMapCommandIds;
class A2DGENERALDLLEXP a2dHashMapCommandIds_wxImplementation_HashTable;
class A2DGENERALDLLEXP a2dHashMapCommandIds_wxImplementation_KeyEx;

//! This hash table is used for a2dCommandId with name
WX_DECLARE_HASH_MAP_WITH_DECL( wxString, a2dCommandId*, wxStringHash, wxStringEqual, a2dHashMapCommandIds, class A2DGENERALDLLEXP );
//#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
//template class A2DGENERALDLLEXP a2dHashMap<wxString,a2dCommandId*>::wxhash;
//template class A2DGENERALDLLEXP a2dHashMap<wxString,a2dCommandId*>;
//#endif

//! Each a2dCommand is given a command id at construction.
/*!
    The command id used to test for a specific commandId when intercepting command events.

<code>   
    A2D_EVT_REDO( a2dObjectDerivedClass::OnComEvent )
   
    void a2dObjectDerivedClass::OnComEvent( a2dComEvent& event )
    {
        // now you can test what the command was.
        event.GetCommand()->GetCommandId()
    }

    EVT_REDO( wxEvtHandlerDerivedClass::OnComEvent )

    void wxEvtHandlerDerivedClass::OnComEvent( a2dComEvent& event )
    {
        // now you can test what the command was.
        event.GetCommand()->GetCommandId()
    }
</code>    

    \ingroup commands commandid
*/
class A2DGENERALDLLEXP a2dCommandId
{
public:

    //! constructor
    a2dCommandId( const wxString& commandName );
    
    //! destructor
    virtual ~a2dCommandId() {};
    
    //! get name of class  
    virtual wxString GetIdClassName() { return wxT("a2dCommandId"); }

    //! get name
    wxString GetName() const { return m_name; }

    //! search Id given the name of the command
    static const a2dCommandId& GetCommandByName(const wxString& commandName);

    //! return hash of commands
    static a2dHashMapCommandIds &GetHashMap();

private:

    //! name of command
    wxString m_name;
};

//! a base command for the a2dCommandProcessor
/*!
    When a2dCommandProcessor gets this command submitted, it will set itself
    to the command. The command will be added to the undo stack, and if it can be undone, the information
    to make this happen is part of the this command stored on the undo stack.
    So normally for each command one derives from a2dCommand, in order to have the derived command
    class store the right information for undoing an action, and define how to Do() and Undo() this action.

    To makes things a bit more flexible, this class is derived from a2dPropObject, therefore it can have a2dProperty's.
    This can be used to  add extra information on a command.

    \ingroup commands 
*/
class A2DGENERALDLLEXP a2dCommand: public a2dPropObject
{

public:

    //! property for command id
    static const a2dCommandId sm_noCommandId;
    //! property for type of command id
    static const a2dCommandId sm_noCommandTypeId;
    //! property for group command id
    static const a2dCommandId sm_groupCommandId;

    //! constructor
    /*!
            \param canUndo can this command be undone
            \param commandId Id of the command
            \param commandTypeId Type Id of the command belong to a group of commands
            \param menuString command is associated with a menu string
    */
    a2dCommand( bool canUndo  = false, 
                        const a2dCommandId& commandId = sm_noCommandId,
                        const a2dCommandId& commandTypeId = sm_noCommandTypeId,
                        const wxString& menuString = wxEmptyString
                      );

    //! destructor
    ~a2dCommand(void);

    //!Clone this object and return a pointer to the new object
    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const;

    inline a2dCommand* TClone( CloneOptions options = clone_deep  ) { return (a2dCommand*) Clone( options ); }

    //! return command name
    //! if m_menuName is set this will be used for menu Undo/Redo labels, else the m_commandId its name is used.
    virtual wxString GetName() const;

    //! a specific id for this command.
    /*!
        A command can have an id set to it, to easily identify it.
        This can be done by m_commandName comparison, but id's are saver.
    */
    const a2dCommandId* GetCommandId() { return m_commandId; }

    //! used to identify groups of simular commands
    const a2dCommandId* GetCommandTypeId() { return m_commandTypeId; }

    //! Copy and instantiate the command
    /*! This is usefull for commands that are used as command templates in widgets.
        The widget owns a command template, that is not bound to an object. This
        function clones the command object and binds it to the given object.

        \\param object for which the command is to be generated.
    */
    virtual a2dCommand *CloneAndBind( a2dPropObject *object );

    // Override this to perform a command
    virtual bool Do() = 0;

    // Override this to undo a command
    virtual bool Undo() = 0;

    virtual bool CanUndo() const { return m_canUndo; }

    // Override this to redo a command
    // Default is the same as do
    virtual bool Redo();

    //! set when submitting this command via a2dCommandProcessor
    void SetCommandProcessor( a2dCommandProcessor* cmp ) { m_cmp = cmp; }

    a2dCommandProcessor* GetCommandProcessor() { return m_cmp; }

    //! Hierarchically clear all commands after current command
    /*!
        When storing commands, normally when no undo or redo is done yet, the command will be stored 
        at the end of the undo stack. But if several Undo have bin done, the currentcommand is not pointing 
        to the end of the stack. When at that moment a new command is submitted, this will be added after 
        the current command, BUT first all commands after the current command will be cleared.
        As a result on can Redo all Undo's sofar as long as no new command is submitted yet.
    */  
    virtual bool ClearAfterCurrentCommand( a2dCommand *current );

    //! This is like a wxDynamicCast, but much faster
    virtual class a2dCommandGroup *IsCommandGroup() { return 0; }

    //! Find the previous command of the given command
    virtual a2dCommand *FindPrevious( a2dCommand *current ) const;

    //! Find the next command of the given command
    virtual a2dCommand *FindNext( a2dCommand *current ) const;

    //! Remove the given command
    virtual bool Remove( a2dCommand *command );

    //! return true if this command/group are nested group contains the given command
    virtual bool ContainsCommand( a2dCommand *command );

    virtual void DistributeEvent( wxEventType eventType );

protected:

    //! can this command be undone
    bool m_canUndo;

    //! can be used to identify the command
    const a2dCommandId* m_commandId;

    //! if set can be used to identify groups of commands
    const a2dCommandId* m_commandTypeId;

    //! allows commands to get to the command processor that submitted the command.
    a2dCommandProcessor* m_cmp;

    //! if set this will be used for menu Undo/Redo labels, else the m_commandId its name is used.
    wxString m_menuString;

    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dCommand( const a2dCommand &other );
};

typedef a2dSmrtPtr<a2dCommand> a2dCommandPtr;

//! For exceptions thrown from commands
/*!
    \ingroup commands commandid
*/
class a2dCommandException
{

public:
    //! Constructor.
    a2dCommandException( const wxString& exMessage): m_message(exMessage) {}

    //! Copy constructor.
    a2dCommandException( const a2dCommandException& other) 
    {  m_message       = other.m_message; }

    a2dCommandException& operator=(const a2dCommandException& other) 
    {
      if (&other != this) {
        m_message = other.m_message;
      }

      return *this;
    }

    virtual ~a2dCommandException() {}

    wxString getMessage() const  { return m_message; }
    void setMessage( const wxString& exMessage)  { m_message = exMessage; }

  protected:

    wxString m_message;
};

//! a list of commands used by the command processor or command groups

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
    template class A2DGENERALDLLEXP a2dSmrtPtr<a2dCommand>;
    template class A2DGENERALDLLEXP std::allocator<class a2dSmrtPtr<class a2dCommand> >;
    template class A2DGENERALDLLEXP std::allocator< std::_List_nod<class a2dSmrtPtr<class a2dCommand>, std::allocator<class a2dSmrtPtr<class a2dCommand> > >::_Node >;
    template class A2DGENERALDLLEXP std::allocator< std::_List_ptr<class a2dSmrtPtr<class a2dCommand>, std::allocator<class a2dSmrtPtr<class a2dCommand> > >::_Nodeptr >;
    template class A2DGENERALDLLEXP std::list<class a2dSmrtPtr<class a2dCommand> >;
    template class A2DGENERALDLLEXP a2dlist<class a2dSmrtPtr<class a2dCommand> >;
    template class A2DGENERALDLLEXP a2dSmrtPtrList<class a2dCommand >;
#endif 

typedef class A2DGENERALDLLEXP a2dSmrtPtrList< a2dCommand > a2dCommandList;

//! a group of commands, used to group commands together for undo/redo
/*!
    A group can be recorded distributed across the application, you start a command group, and you end it.
    See CommandGroupBegin() CommandGroupEnd().
    All command submitted in between become part of the group. This is very handy when commands lead to
    other commands indirectly. Like when moving objects connected with wires: moving an object will create 
    a move command, but the wires will be re-routed, generating extra move commands for all moved wires.
    Combining those in a group, will Undo this as a whole, which is what a user does expect.
    Same for a polygon which is drawn vertex by vertex, while bussy doing this, an Undo action should remove 
    the last added vertex. But when finishing a polygon, and drawing several more, the Undo should remove the 
    polygon as a whole in one Undo action. This behaviour is all handled within a2dCommandProcessor(), it
    knows which group is currently active, and commands in nested groups are undone/redone at once, while single commands in the active 
    group are undone one by one. Undo-ing/redo-ing a group, means it will undo/redo all seperate nested commands, but to the users it is
    as if it is one action.

    Another application of groups is simple to assemble a group of commands, which can be submitted as a new command.
    A group gets a unique a2dCommandId at construction.
    The group of commands is submitted in one row in Do().

    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommandGroup: public a2dCommand
{
public:

    //! constructor
    /*!
            \param name name of this command
            \param parent of this group
    */
    a2dCommandGroup( const wxString &name, a2dCommandGroup* parent = NULL );

    //! destructor
    ~a2dCommandGroup(void);

    //!Clone this object and return a pointer to the new object
    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const;

    inline a2dCommand* TClone( CloneOptions options = clone_deep  ) { return (a2dCommand*) Clone( options ); }

    //! return command name
    virtual wxString GetGroupName() const { return m_groupName; }

    //! erase commands with a certain id, starting  at fromcommand
    bool ClearCommandsById( const a2dCommandId& commandId, a2dCommand *fromcommand = NULL );

    //! Hierarchically clear all commands after current
    virtual bool ClearAfterCurrentCommand( a2dCommand *current );

    //! This is like a wxDynamicCast, but much faster
    virtual class a2dCommandGroup *IsCommandGroup() { return this; }

    //! Find the previous command of the given command
    virtual a2dCommand *FindPrevious( a2dCommand *current ) const;

    //! Find the next command of the given command
    virtual a2dCommand *FindNext( a2dCommand *current ) const;

    //! Remove the given command in this group or a subgroup
    virtual bool Remove( a2dCommand *command );

    //! add a command to the group
    void Add( a2dCommand *command );

    //! return true if this command/group are nested group contains the given command
    virtual bool ContainsCommand( a2dCommand *command );

    //! return the parent group of this group
    a2dCommandGroup* GetParentGroup() { return m_parentGroup; }

    //! set the parent group of this group
    void SetParentGroup( a2dCommandGroup* parent ) { m_parentGroup = parent; }

public:
    // Base class overloads
    virtual bool Do();
    virtual bool Undo();

protected:

    //! this is the parent group of this group
    a2dCommandGroup* m_parentGroup;

    //! name of group of commands
    wxString m_groupName; 

    //! If true, this command group is not yet closed and may still receive commands
    bool m_active;
    //! the list of subcommands
    a2dCommandList m_subcommands;
    //! a2DocumentCommandProcessor may access the list directly
    friend class a2dCommandProcessor;
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DGENERALDLLEXP a2dAutoZeroPtr< a2dPropObject >;
#endif 

//! used to change a property on objects
/*!
    A a2dObject property is set on the a2dPropObject, and the first property 
    on the a2dPropObject with the same name is used for undo.
    Properties with the starting with __M_ are wrapped properties, and or often used to set member variables 
    of classes. 
    Special name properties starting with just __ are used to set predefined properties.
    Both these type of properties can be set by this command.
    If the property was not yet set for the object, in Undo the new property is just removed, else
    the old value is restored.

    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommand_SetProperty: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetProperty)

public:

    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! for dynamic creation
    a2dCommand_SetProperty();

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.
        
       \param object the canvas object to set the property on.
       \param property the property to set
    */
    a2dCommand_SetProperty( a2dPropObject* object, a2dNamedProperty* property );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdRefObject* id, a2dObject *value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdObject* id, const wxObject& value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdString* id, const wxString& value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdBool* id, bool value );

    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdBool* id, const wxString& value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdInt16* id, wxInt16 value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdUint16* id, wxUint16 value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdInt32* id, wxInt32 value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdUint32* id, wxUint32 value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdDouble* id, double value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the a2dPropertyId of the property to set.
        \param colour the value to set the property to.
    */
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyIdColour* id, const wxColour& colour );

    ~a2dCommand_SetProperty(void);

    //! copy constructor
    a2dCommand_SetProperty( const a2dCommand_SetProperty &other );


    //! property that is set packed as a2dNamedProperty.
    a2dNamedProperty* GetProperty() { return m_property; }

    //! property that is set packed as a2dNamedProperty.
    const a2dPropertyId* GetPropertyId() { return m_id; }

    a2dPropObject* GetObject() { return m_propRefObject.Get(); }

    bool Do();
    bool Undo();

protected:
    //! this is for derived classes and derived properties
    a2dCommand_SetProperty( a2dPropObject* object, const a2dPropertyId* id );

    //! all property references will be set NULL when this object, having the property, will be deleted.
    a2dAutoZeroPtr< a2dPropObject > m_propRefObject;

    //! property set to the object.
    a2dNamedPropertyPtr m_property;

    //! id of the property that is set.
    const a2dPropertyId *m_id;
};


/**********************************************
 New events Document and View events.
**********************************************/
BEGIN_DECLARE_EVENT_TYPES()
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_BEGINBUSY, 1 )
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_ENDBUSY, 1 )
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_DO, 1 )
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_UNDO, 1 )
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_REDO, 1 )
    //! see a2dCommandProcessorEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, wxEVT_MENUSTRINGS, 1 )
    //! see a2dPropertyEditEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT, 1)
END_DECLARE_EVENT_TYPES()


//! sent from a2dPropObject::EditProperties() to central event distribution.
/*!
    This event is sent to a2dGeneralGlobals->GetEventDistributer(), you can intercept it 
    anywhere you want, and do the editing of the supplied properties there.

    Currently the following Id's:

    - ::a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT sent when a2dPropObject::EditProperties() requires editing of properties.

    \ingroup events
*/
class A2DGENERALDLLEXP a2dPropertyEditEvent: public a2dEvent
{
public:

    //! constructor
    a2dPropertyEditEvent( a2dPropObject* object, a2dNamedPropertyList* properties = NULL );

    //! constructor
    a2dPropertyEditEvent( const a2dPropertyEditEvent& other );

    //! clone the event
    virtual wxEvent *Clone() const { return new a2dPropertyEditEvent(*this); }

    a2dNamedPropertyList* GetPropertyList() { return m_properties; }

    //! when properties where edited, this must become true
    bool GetEdited() { return m_edited; }

    //! set to signal that properties where edited.
    void SetEdited( bool edited ) { m_edited = edited; }

private:

    a2dNamedPropertyList* m_properties;

    bool m_edited;
};

//! event function for a2dPropertyEditEvent
typedef void ( a2dEvtHandler::*a2dPropertyEditEventFunction )( a2dPropertyEditEvent& );
//! event function for a2dPropertyEditEvent
typedef void ( wxEvtHandler::*a2dPropertyEditEventFunctionEvt )( a2dPropertyEditEvent& );

/*! \addtogroup eventhandlers
*  @{
*/

//! static event table macro for a2dCanvasObject when editing properties for a2dEvtHandler
#define A2D_EVT_PROPOBJECT_EDITPROPERTIES_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dPropertyEditEventFunction > ( & func ), (wxObject *) NULL ),
//! static event table macro for NON a2dCanvasObject when editing properties for wxEvtHandler
#define EVT_PROPOBJECT_EDITPROPERTIES_EVENT(func) DECLARE_EVENT_TABLE_ENTRY( a2dEVT_PROPOBJECT_EDITPROPERTIES_EVENT, wxID_ANY, wxID_ANY, (wxObjectEventFunction) static_cast < a2dPropertyEditEventFunctionEvt > ( & func ), (wxObject *) NULL ),

//!  @} eventhandlers

//! Event sent to a2dCommandProcessor or a2dEventDistributer
/*!
     - ::wxEVT_DO is sent from a2CommandProcessor or any other commandprocessor when a command is issued.
     - ::wxEVT_UNDO is sent from a2CommandProcessor or any other commandprocessor when a command is issued.  

     - ::wxEVT_MENUSTRINGS is sent from a2dCommandProcessor when menu string need to be updated after a command.

    \ingroup commands events
*/
class A2DGENERALDLLEXP a2dCommandProcessorEvent : public a2dEvent
{

public:

    //! constructor
    /*!
        type should ::wxEVT_DO ::wxEVT_UNDO

    */
    a2dCommandProcessorEvent( wxEventType type, a2dCommand* cmd )
        : a2dEvent( 0, type )
    {
        m_cmd = cmd;
        m_undoLabel = wxT("");
        m_redoLabel = wxT("");
        m_canUndo = false;
        m_canRedo = false;
    }

    //! constructor
    /*!
        type ::wxEVT_MENUSTRINGS

        For ::wxEVT_MENUSTRINGS, you can use the following function, to get the info to set the menu string.
            -wxCommandProcessor::GetUndoMenuLabel()
            -wxCommandProcessor::GetRedoMenuLabel()
            -wxCommandProcessor::CanUndo()
            -wxCommandProcessor::CanRedo()
    */
    a2dCommandProcessorEvent( a2dCommand* cmd,
                          const wxString& undoLabel, bool canUndo,
                          const wxString& redoLabel, bool canRedo
                        )
        : a2dEvent( 0, wxEVT_MENUSTRINGS )
    {
        m_cmd = cmd;
        m_undoLabel = undoLabel;
        m_redoLabel = redoLabel;
        m_canUndo = canUndo;
        m_canRedo = canRedo;
    }

    //! constructor
    a2dCommandProcessorEvent(const a2dCommandProcessorEvent & event)
        : a2dEvent(event)
    {
        m_cmd = event.m_cmd;
        m_undoLabel = event.m_undoLabel;
        m_redoLabel = event.m_redoLabel;
        m_canUndo = event.m_canUndo;
        m_canRedo = event.m_canRedo;
    }

    //! clone the event.
    virtual wxEvent *Clone() const { return new a2dCommandProcessorEvent(*this); }

    //! the command ( if there was one ) that did it.
    a2dCommand* GetCommand() { return m_cmd; }

    //! by default this is a2dCommandProcessor::GetUndoMenuLabel()
    wxString& GetUndoMenuLabel() { return m_undoLabel; }
    //! by default this is a2dCommandProcessor::GetRedoMenuLabel()
    wxString& GetRedoMenuLabel() { return m_redoLabel; }
    //! by default this is a2dCommandProcessor::CanUndo()
    bool CanUndo() { return m_canUndo; }
    //! by default this is a2dCommandProcessor::CanRedo()
    bool CanRedo() { return m_canRedo; }
 
protected:

    //! see GetCommand()
    a2dCommand* m_cmd;

    //! used for wxEVT_MENUSTRINGS event
    wxString m_undoLabel;

    //! used for wxEVT_MENUSTRINGS event
    bool m_canUndo;

    //! used for wxEVT_MENUSTRINGS event
    wxString m_redoLabel; 

    //! used for wxEVT_MENUSTRINGS event
    bool m_canRedo;
};

/*! \addtogroup eventhandlers
*  @{
*/

typedef void (a2dEvtHandler::*a2dObjectCommandProcessorEventFunction)(a2dCommandProcessorEvent&);
typedef void (wxEvtHandler::*wxCommandProcessorEventFunction)(a2dCommandProcessorEvent&);

//! event sent from a2DocumentCommandProcessor when a command is initially done
#define A2D_EVT_DO(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_DO, wxID_ANY, wxID_ANY, (a2dObjectEventFunction)  static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent from a2DocumentCommandProcessor when a command is undone
#define A2D_EVT_UNDO(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_UNDO, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent from a2DocumentCommandProcessor when a command is redone
#define A2D_EVT_REDO(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_REDO, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent to wxCommandProcessorEvents to adjust menu strings (e.g. for current undo/redo command)
#define A2D_EVT_MENUSTRINGS(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENUSTRINGS, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),

//! event sent from a2DocumentCommandProcessor when a command submit/execute is starting
#define A2D_EVT_BEGINBUSY(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_BEGINBUSY, wxID_ANY, wxID_ANY, (a2dObjectEventFunction)  static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent from a2DocumentCommandProcessor when a command submit/execute is ending
#define A2D_EVT_ENDBUSY(func)  A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_ENDBUSY, wxID_ANY, wxID_ANY, (a2dObjectEventFunction)  static_cast< a2dObjectCommandProcessorEventFunction > (& func), (wxObject *) NULL ),

//! event sent from a2DocumentCommandProcessor when a command is initially done
#define EVT_DO(func)  DECLARE_EVENT_TABLE_ENTRY( wxEVT_DO, wxID_ANY, wxID_ANY, (wxObjectEventFunction)  static_cast< wxCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent  from a2DocumentCommandProcessor when a command is undone
#define EVT_UNDO(func)  DECLARE_EVENT_TABLE_ENTRY( wxEVT_UNDO, wxID_ANY, wxID_ANY, (wxObjectEventFunction) static_cast< wxCommandProcessorEventFunction > (& func), (wxObject *) NULL ),
//! event sent  from a2DocumentCommandProcessor to adjust menu strings (e.g. for current undo/redo command)
#define EVT_MENUSTRINGS(func)  DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENUSTRINGS, wxID_ANY, wxID_ANY, (wxObjectEventFunction) static_cast< wxCommandProcessorEventFunction > (& func), (wxObject *) NULL ),

//!  @} eventhandlers

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

//! base command processor 
/*!
    a2dCommand commands submitted to this class, are stored on a stack.
    Because commands can be nested, the command processor actually has not a stack, but a tree of nested
    commands. The tree is implemented by nesting a2dDocviewCommand's.

    One can have a command stack for the whole application, and sub command stacks for documents.
    So undo can be called seperate for all documents, or even parts of documents.

    See a2dCommand for how to organize undo information.    

    \ingroup commands events
*/
class A2DGENERALDLLEXP a2dCommandProcessor : public a2dEvtHandler
{
public:

    //!Constructor. 
    /*!
        \param maxCommands maximum of commands on the command stack, default -1 is unlimited.
    */
    a2dCommandProcessor(int maxCommands = -1);

    //! destructor
    virtual ~a2dCommandProcessor();

    //! next to the base class submit, it sets a2DocumentCommandProcessor for a2dCommand
    /*
        Pass a command to the processor. The processor calls Do(); if
        successful, is appended to the command history unless storeIt is false.

        Internal sents a a2dDocumentCommandEvent with id ::wxEVT_DO 
    */
    virtual bool Submit(a2dCommand *command, bool storeIt = true);

    //! just store the command without executing it
    virtual void Store(a2dCommand *command);

    //! Undo one command or command group
    virtual bool Undo();
    //! Redo one command or command group
    virtual bool Redo();
    //! Are there commands to undo and can they be undone ?
    virtual bool CanUndo() const;
    //! Are there commands to redo and can they be redone ?
    virtual bool CanRedo() const;

    //! Initialises the current command and menu strings.
    virtual void Initialize();

    //! does sent an event to update menu strings after a command 
    /*
        Sets the Undo/Redo menu strings somewhere the application intercepts this event.
        Sents ::wxEVT_MENUSTRINGS to a2dGeneralGlobals->GetEventDistributer(),
        the application does react by setting menu strings.

        In event tables use like:
        <code>
            BEGIN_EVENT_TABLE( classX, baseclassX )
                EVT_MENUSTRINGS( classX::OnSetMenuStrings )
            END_EVENT_TABLE()
        </code>
        
        Assuming you have in classX this:

        <code>
            m_edit_menu = new wxMenu;
            m_edit_menu->Append(wxID_UNDO, _("&Undo"));
            m_edit_menu->Append(wxID_REDO, _("&Redo"));
        </code>

        In OnSetMenuStrings do this:

        <code>
            void classX::OnSetMenuStrings( a2dCommandProcessorEvent& event )
            {
                if ( event.GetEventObject() == m_view->GetDocument()->GetCommandProcessor() )
                {
                    m_edit_menu->SetLabel(wxID_UNDO, event.GetUndoMenuLabel());
                    m_edit_menu->Enable(wxID_UNDO, event.CanUndo());

                    m_edit_menu->SetLabel(wxID_REDO, event.GetRedoMenuLabel());
                    m_edit_menu->Enable(wxID_REDO, event.CanRedo());
                }
            }
        </code>

        \remark overide this function in derived class, if you need other labels etc. 
    */
    virtual void SetMenuStrings();

    //! Gets the current Undo menu label.
    wxString GetUndoMenuLabel() const;

    //! Gets the current Undo menu label.
    wxString GetRedoMenuLabel() const;

    //! command list access
    a2dCommand *GetCurrentCommand() const
    {
        return m_currentCommand;
    }

    //! get the limit on number of commands to store
    int GetMaxCommands() const { return m_maxNoCommands; }

    //! return  top/startgroup 
    a2dCommandGroup* GetRootGroup() const { return m_rootGroup; }

    //! return  current group 
    a2dCommandGroup* GetCurrentGroup() const { return m_currentGroup; }

    //! remove all commands stored
    virtual void ClearCommands();

    //! By default, the accelerators are "\tCtrl+Z" and "\tCtrl+Y"
    const wxString& GetUndoAccelerator() const { return m_undoAccelerator; }
    //! By default, the accelerators are "\tCtrl+Z" and "\tCtrl+Y"
    const wxString& GetRedoAccelerator() const { return m_redoAccelerator; }

    //! By default, the accelerators are "\tCtrl+Z" and "\tCtrl+Y"
    void SetUndoAccelerator(const wxString& accel) { m_undoAccelerator = accel; }
    //! By default, the accelerators are "\tCtrl+Z" and "\tCtrl+Y"
    void SetRedoAccelerator(const wxString& accel) { m_redoAccelerator = accel; }

    //! set a named property to the given object 
    /*! \remark This function should only be used if the id comes as string from the user or a file.
                The id must be in the id list and the type is derived from the found id.
        \param propRefObject object to set the property to.
        \param name the name of the property to add.
        \param value the value to set the property to.
        \param withUndo if true the setting of this property can be undone.
    */
    virtual bool SetOrAddPropertyToObject( a2dPropObject* propRefObject, const wxString& name, const wxString& value = wxT(""), bool withUndo = true );

    //! set a named property to the given object 
    /*!
        \param propRefObject object to set the property to.
        \param property the property (id and value) to add.
        \param withUndo if true the setting of this property can be undone.
    */
    virtual bool SetOrAddPropertyToObject( a2dPropObject* propRefObject, a2dNamedProperty *property, bool withUndo = true );

    //! Start a new command group
    /*! The return value is given to CommandGroupEnd. */
    a2dCommandGroup *CommandGroupBegin( const wxString &name );

    //! End a command group
    /* \param group the return value of the matching CommandGroupBegin */
    void CommandGroupEnd( a2dCommandGroup *group );

    //! when releasing this, release first all command, since they may hold commands referencing this
    //! command processor, so it would never be deleted.
    bool SmrtPtrRelease();

protected:

    //! sents a a2dCommandProcessorEvent event( wxEVT_BEGINBUSY, command )
    //! or a2dCommandProcessorEvent event( wxEVT_ENDBUSY, command )
    //! to this class. This is done before and after executing/submitting a command.
    //! You can intercept this event to set e.g  a busy cursor.   
    //! - A2D_EVT_BEGINBUSY( a2dCentralCanvasCommandProcessor::OnBusyBegin )
    //! - A2D_EVT_ENDBUSY( a2dCentralCanvasCommandProcessor::OnBusyEnd )
    void SentBusyEvent( bool start, a2dCommand *command );

    //! find the currently active command group
    a2dCommandGroup *FindActiveGroup();

    //! Set the current command to the last command in the active group
    void SetCurrentToLastActive();

    // for further flexibility, command processor doesn't call a2dCommand::Do()
    // and Undo() directly but uses these functions which can be overridden in
    // the derived class

    //! sents a a2dCommandProcessorEvent with id ::wxEVT_DO 
    virtual bool DoCommand(a2dCommand& cmd);

    //! sents a a2dCommandProcessorEvent with id ::wxEVT_UNDO 
    virtual bool UndoCommand(a2dCommand& cmd);

    //! sents a a2dCommandProcessorEvent with id ::wxEVT_REDO 
    virtual bool RedoCommand(a2dCommand& cmd);

    //! maximum number of commands to store
    wxUint32      m_maxNoCommands;
    //! this is the root of the command group tree
    a2dSmrtPtr< a2dCommandGroup > m_rootGroup;

    //! this is the parent group of the current command ( which may be a group itself )
    a2dSmrtPtr< a2dCommandGroup > m_currentGroup;

    //! this is the tree-trace to the currently active command
    a2dCommandPtr m_currentCommand;

    //! associated undo accelerator attached to menu 
    wxString      m_undoAccelerator;
    //! associated redo accelerator
    wxString      m_redoAccelerator;

private:
    DECLARE_DYNAMIC_CLASS(a2dCommandProcessor)
};

//! help class which makes it possible to store a smart pointer as a wxObject*
/*!
    If a class X has a member wxObject* m_obj, this pointer can normally not be used for storing a 
    a2dSmrtPtr which is a template class not derived from wxObject.
    This class here is  wxObject derived, and the smart pointer is maintained within. 
    On deletion of this class it will delete the smart pointer, releasing the object pointed to.

    \ingroup general
*/ 
template<class T>
class a2dSmrtPtrWrap: public wxObject
{
public:

    a2dSmrtPtrWrap( T* caller )
    {
        m_smrtP = caller;
    }

    ~a2dSmrtPtrWrap()
    {
    }

    a2dSmrtPtr<T> m_smrtP;
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
    template class A2DGENERALDLLEXP a2dSmrtPtrWrap< a2dCommand >;
#endif

//! used to connect a command to a wxObject
//! The wxObject derived class, holds a smart pointer to a command. The wxObject can be stored as m_callbackUserData in events.
typedef a2dSmrtPtrWrap< a2dCommand >  a2dCommandStore;

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DGENERALDLLEXP std::allocator< wxEventType >;
template class A2DGENERALDLLEXP std::allocator< std::_List_nod< wxEventType, std::allocator< wxEventType > >::_Node >;
template class A2DGENERALDLLEXP std::allocator< std::_List_ptr< wxEventType, std::allocator< wxEventType > >::_Nodeptr >;
template class A2DGENERALDLLEXP std::list< wxEventType >;
template class A2DGENERALDLLEXP a2dlist< wxEventType >;
#endif

//! class used in a2dEventDistributer
/*!
    It is possible that in the a2dEventDistributer an event wxEvtHandler is Unregistered when
    iterating through all registered handlers.
    This class prevents going to already unregistered handlers while iterating in
    a2dEventDistributer::ProcessEvent().
    At the end of the iteration all unregistered are removed.
    So in fact delayed deletion.

    \ingroup eventmanager events

*/
class A2DGENERALDLLEXP a2dDistributedEventReceiver : public a2dObject
{

public:

    enum a2dReceiverHandlerType {
        a2dReceiverwxEvtHandler,
        a2dReceivera2dObject
    };

    //!constructor
    a2dDistributedEventReceiver( wxEvtHandler* handler )
    {
        m_valid = true;
        m_handler = handler;
        m_type = a2dReceiverwxEvtHandler;
    }

    a2dDistributedEventReceiver( a2dObject* handler )
    {
        m_valid = true;
        m_handler = handler;
        m_type = a2dReceivera2dObject;
    }
    
    ~a2dDistributedEventReceiver(){}

    void AddWantedEventType( wxEventType type ) { m_eventTypesWanted.push_back( type ); }
    void RemoveWantedEventType( wxEventType type ) { m_eventTypesWanted.remove( type ); }

    void AddNotWantedEventType( wxEventType type ) { m_eventTypesNotWanted.push_back( type ); }
    void RemoveNotWantedEventType( wxEventType type ) { m_eventTypesNotWanted.remove( type ); }

    bool WantsType( wxEventType type )
    {
        if ( m_eventTypesWanted.empty() && m_eventTypesNotWanted.empty() )
            return true;

        bool wanted = false;
        if ( m_eventTypesWanted.empty() )
            wanted = true;
        else
            forEachIn( a2dlist< wxEventType >, &m_eventTypesWanted )
            {
                if ( *iter == type )
                    wanted = true;
            }

        forEachIn( a2dlist< wxEventType >, &m_eventTypesNotWanted )
        {
            if ( *iter == type )
                wanted = false;
        }
        return wanted;
    }

    //! the wrapped handler
    wxObject* m_handler;
        
    a2dReceiverHandlerType m_type;    

    //! true when not unregistered
    bool m_valid;

protected:

    a2dlist< wxEventType > m_eventTypesWanted;

    a2dlist< wxEventType > m_eventTypesNotWanted;

    virtual a2dObject* Clone( CloneOptions WXUNUSED(options) ) const
    {
        wxASSERT(0);
        return NULL;
    }

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

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

#endif //wxART2D_USE_CVGIO


};
#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DGENERALDLLEXP a2dSmrtPtr<class a2dDistributedEventReceiver>;
template class A2DGENERALDLLEXP std::allocator<class a2dSmrtPtr<class a2dDistributedEventReceiver> >;
template class A2DGENERALDLLEXP std::allocator< std::_List_nod<class a2dSmrtPtr<class a2dDistributedEventReceiver>, std::allocator<class a2dSmrtPtr<class a2dDistributedEventReceiver> > >::_Node >;
template class A2DGENERALDLLEXP std::allocator< std::_List_ptr<class a2dSmrtPtr<class a2dDistributedEventReceiver>, std::allocator<class a2dSmrtPtr<class a2dDistributedEventReceiver> > >::_Nodeptr >;
template class A2DGENERALDLLEXP std::list<a2dSmrtPtr<class a2dDistributedEventReceiver> >;
template class A2DGENERALDLLEXP a2dlist<class a2dSmrtPtr<class a2dDistributedEventReceiver> >;
template class A2DGENERALDLLEXP a2dSmrtPtrList< a2dDistributedEventReceiver >;
#endif
typedef a2dSmrtPtrList< a2dDistributedEventReceiver > wxEventHandlersList;

//! class to spread events sent to it to other class instances that are registrated
/*!
    The events sent to this class or either directly sent to other classes that
    are registrated or in idle time.
    Registrated classes should be derived from wxEvtHandler.

        The sending class calls
\code        
          ProcessEvent( wxEvent& event) or  AddPendingEvent( changed ).
\endcode

        The receiving class can use the standard way of receiving events in wxWindows.
\code
        BEGIN_EVENT_TABLE(wxMyClass, wxMyClassBase)
            EVT_COM_EVENT( wxMyClass::OnComEvent )
        END_EVENT_TABLE()
\endcode

    In the docview classes, the a2dEventDistributer is used to sent events from documents to views
    and the wxCommandProcessorEvents class. 

    \ingroup eventmanager events
*/
class A2DGENERALDLLEXP a2dEventDistributer : public wxEvtHandler
{

public:

    //!constructor
    a2dEventDistributer();

    //!destructor
    ~a2dEventDistributer();

    //!process an event for the object, starting with the first eventhandler in the list.
    /*!
        Only wxEvtHandler instances that are registred and valid are getting the event.
        It is allowed to unregister any wxEvtHandler while the event distribution is in progress.
        This unregistered wxEvtHandler, will be flagged invalid, and therefore no event will be sent to it
        anymore.
        At the end of the event distribution the unregistered wxEvtHandler's are removed.
    */
    bool ProcessEvent( wxEvent& event);

    //! register a class instance
    a2dDistributedEventReceiver* Register( wxEvtHandler* handler );

    //! UnRegister a class instance
    bool Unregister( wxEvtHandler* handler );

    //! register a class instance
    a2dDistributedEventReceiver* Register( a2dObject* handler );

    //! UnRegister a class instance
    bool Unregister( a2dObject* handler );

protected:

    //! list of registrated class instances.
    wxEventHandlersList m_handlers;
};

//! One Global instance of this class exists, in order to get to global needed objects.
/*!  
    a2dEventDistributer is used to distribute events to registred classes instances.
    It is used here to register views ( a2dView's), and a2dDocument communicates
    to its views via the a2dEventDistributer class. Also wxDocviewCommandEvents is registered
    to it, and a2dView's and a2dDocument's use it to notify the a2DocumentCommandProcessor of 
    certain events. e.g. a2dCloseViewEvent etc.

    Error from within the docview frame work and derived applications/libraries,
    use this class to report errors and warning too.
    They are maintained in a list, and in each a2dError, you will find the error code, and the
    message that went with it.

    Default error messages will be reported to wxLogError, if m_showlog is false, they will only be stored.

    From this class several other are derived, and they will share the same static information.
    Like the errors reported, and the user variables etc.

    \ingroup global general
*/
class A2DGENERALDLLEXP a2dGeneralGlobal : public a2dObject
{

    DECLARE_CLASS( a2dGeneralGlobal )

public:

    a2dGeneralGlobal();

    virtual ~a2dGeneralGlobal();

    //! reset the error report to empty.
    /*!
        All erros in the error list are cleared.
    */
    virtual void ResetErrors();

    //! concatenate to the the error report the given error.
    virtual void ReportError( const a2dError& error, const wxString& errorstr = wxEmptyString );

    //! concatenate to the the error report the given error.
#if !wxCHECK_VERSION(2,9,0)
    virtual void ReportErrorF( const a2dError& error, const wxChar* Format, ... );
#else    
    WX_DEFINE_VARARG_FUNC_VOID( ReportErrorF, 2, (const a2dError&, const wxFormatString&), DoPrintfWchar, DoPrintfUtf8)
#endif
    //! concatenate to the error report the given warning.
    virtual void ReportWarning( const a2dError& error, const wxString& errorstr );

    //! concatenate to the error report the given warning.
#if !wxCHECK_VERSION(2,9,0)
    virtual void ReportWarningF( const a2dError& error, const wxChar* Format, ... );
#else    
    WX_DEFINE_VARARG_FUNC_VOID( ReportWarningF, 2, (const a2dError&, const wxFormatString&), DoPrintfWchar, DoPrintfUtf8)
#endif

    //! get the errors found sofar.
    static a2dErrorVector& GetErrors() { return m_errors; }

    //! concatenate all errors found into one string.
    wxString GetErrorsAsString();

    //! all stored errors and warning are sent to log target using wxLogError()
    /*!
        Specific use is when m_showlog is false, but still errors or assembled,
        calling this function will sent to the logging target anyway.
        One can ignore all errors with ResetErrors(). 
    */
    void SendToLogTarget();

    //! code of the last warning or error
    a2dErrorWarningCode GetLastErrorCode() const;

    a2dError GetLastError() const; 

    //! Set logging to wxLog target on or off
    void SetDoLog( bool onOff ) { m_showlog = onOff; }

    //! Is logging to wxLog target on or off?
    bool GetDoLog() { return m_showlog; }

    //! Gets a2dEventDistributer pointer 
    /*!
        Used to distribute events inside the application.
        Event sent to this instance are sent to all registrated classes.
    */
    a2dEventDistributer* GetEventDistributer() const { return m_docviewEventDistributer; }

    //! Normally set automatically when creating new a2dGeneralGlobal
    void SetEventDistributer( a2dEventDistributer* docviewEventDistributer );

    //! Add an error to the list of ignored errors
    void IgnoreError( unsigned int id );

    //! aliases list for setting internal variables
    a2dVariablesHash& GetVariablesHash() { return m_variableList; }

    //! get a variable from the internal aliases list 
    wxString* GetVariableString( const wxString& variablename );

    //! Path(s) for configuration file(s) in an application    
    a2dPathList& GetConfigPathList() { return m_configpath; }

    //! Get a reference to the central list of  dynamic created property id's.
    a2dPropertyIdList& GetPropertyIdList() { return m_dynamicIdList; }

    wxString GetWxArt2DVar( bool withSep = true ) const;

    wxString GetWxArt2DArtVar( bool withSep = true ) const;

protected:

#if wxCHECK_VERSION(2,9,0)
#if !wxUSE_UTF8_LOCALE_ONLY
    virtual void DoPrintfWchar( const a2dError&, const wxChar *format, ...);
#endif
#if wxUSE_UNICODE_UTF8
    virtual void DoPrintfUtf8( const a2dError&, const char *format, ...);
#endif
#endif
  
    //!  Path(s) for configuration file(s) in an application  
    static a2dPathList m_configpath;

    //! logging to wxLog target on or off
    static bool m_showlog;

    //! list of all possible errors
    static a2dErrorVector m_errors;

    //! event distributer 
    static a2dEventDistributer* m_docviewEventDistributer;

    //! list of error id's to be ignored.
    static wxArrayInt m_ignoredErrorIds;

    //! aliaslist containing internal variables
    static a2dVariablesHash m_variableList;

    static a2dPropertyIdList m_dynamicIdList;

private:

    //! create an exact copy of this property
    virtual a2dObject* Clone( CloneOptions options ) const;

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts, a2dObjectList* towrite );
    virtual void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

};

//! initializes the general module
/*!
    The global variable a2dGeneralGlobals is set here.

    \ingroup global
    \ingroup general
*/
class A2DGENERALDLLEXP a2dGeneralModule : public wxModule
{
public:

    a2dGeneralModule() {}

    virtual bool OnInit();
    virtual void OnExit(); 

private:    

    DECLARE_DYNAMIC_CLASS(a2dGeneralModule)
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DGENERALDLLEXP a2dSmrtPtr<a2dGeneralGlobal>;
#endif

//! only instance of a2dGeneralGlobal, to get to settings for dynamic variables and errors.
A2DGENERALDLLEXP_DATA (extern a2dSmrtPtr<a2dGeneralGlobal>) a2dGeneralGlobals;
//A2DGENERALDLLEXP_DATA (extern a2dGeneralGlobal* ) a2dGeneralGlobals;






#define A2D_ARGUMENT_SETTER( TYPE, ARGUMENT_NAME ) \
Args & \
ARGUMENT_NAME( const TYPE& arg) { \
    this->argValue.ARGUMENT_NAME = arg; \
    this->argSet.ARGUMENT_NAME = true; \
    return *this; \
} 

//! Set a string variable inside wxDocview
/*!
    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommand_SetVariable: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetVariable)

public:

    //! Set a string variable inside wxDocview
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DGENERALDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.varname = false;
            argSet.varvalue = false;
        }

        ~Args()
        {
        }

        A2D_ARGUMENT_SETTER( wxString, varname )
        A2D_ARGUMENT_SETTER( wxString, varvalue )

        struct argValuet
        {
            wxString varname; wxString varvalue;
        } argValue;

        struct argSett
        {
            bool varname, varvalue;
        } argSet;
    };

    a2dCommand_SetVariable( const Args& args = Args() )
    {
        m_args.argValue.varname = args.argSet.varname ? args.argValue.varname: wxString(wxEmptyString); //error throw
        m_args.argValue.varvalue = args.argSet.varvalue ? args.argValue.varvalue: wxString(wxEmptyString);
    }

private:

    Args m_args;

    virtual bool Do()
    { 
        a2dGeneralGlobals->GetVariablesHash().SetVariableString( m_args.argValue.varname, m_args.argValue.varvalue );
        return true;
    }
    virtual bool Undo()
    {
        return false;
    }
};

//! Set a environment variable 
/*!
    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommand_SetEnvironmentVariable: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetEnvironmentVariable)

public:

    //! Set a string environment variable 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DGENERALDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.varname = false;
            argSet.varvalue = false;
        }

        ~Args()
        {
        }

        A2D_ARGUMENT_SETTER( wxString, varname )
        A2D_ARGUMENT_SETTER( wxString, varvalue )

        struct argValuet
        {
            wxString varname; wxString varvalue;
        } argValue;

        struct argSett
        {
            bool varname, varvalue;
        } argSet;
    };

    a2dCommand_SetEnvironmentVariable( const Args& args  = Args() )
    {
        m_args.argValue.varname = args.argSet.varname ? args.argValue.varname: wxString(wxEmptyString); //error throw
        m_args.argValue.varvalue = args.argSet.varvalue ? args.argValue.varvalue: wxString(wxEmptyString);
    }

private:

    Args m_args;

    virtual bool Do()
    { 
        if ( wxSetEnv( m_args.argValue.varname, m_args.argValue.varvalue ) )
            return true;

#if wxCHECK_VERSION(2,9,0)
        a2dGeneralGlobals->ReportErrorF( a2dError_SetEnv, _(" SetEnv() Error: Could not set Environment variable %s = %s\n"),
                         m_args.argValue.varname, m_args.argValue.varvalue );
#else
        a2dGeneralGlobals->ReportErrorF( a2dError_SetEnv, _(" SetEnv() Error: Could not set Environment variable %s = %s\n"),
                         m_args.argValue.varname.c_str(), m_args.argValue.varvalue.c_str() );
#endif
        return true;
    }
    virtual bool Undo()
    {
        return false;
    }
};

//! Get internal variable 
/*!
    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommand_GetVariable: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_GetVariable)

public:

    //! Set a string environment variable 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DGENERALDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.varname = false;
            argSet.varvalue = false;
        }

        ~Args()
        {
        }


        A2D_ARGUMENT_SETTER( wxString, varname )
        A2D_ARGUMENT_SETTER( wxString, varvalue )

        struct argValuet
        {
            wxString varname; wxString varvalue;
        } argValue;

        struct argSett
        {
            bool varname, varvalue;
        } argSet;
    };

    a2dCommand_GetVariable( const Args& args  = Args() )
    {
        m_args.argValue.varname = args.argSet.varname ? args.argValue.varname: wxString(wxEmptyString);
        m_args.argValue.varvalue = args.argSet.varvalue ? args.argValue.varvalue: wxString(wxEmptyString);
    }

private:

    Args m_args;

    virtual bool Do()
    { 
        const a2dNamedProperty*  propfound = a2dGeneralGlobals->GetVariablesHash().GetVariable( m_args.argValue.varname );
        if( !propfound )
        {
            a2dGeneralGlobals->ReportError( a2dError_GetVar, _("wrong variable name, variable does not exist") );
            return false;
        }

        m_args.argSet.varvalue = true;
        m_args.argValue.varvalue = propfound->StringValueRepresentation();
        return true;    
    }
    virtual bool Undo()
    {
        return false;
    }
};

//! Get internal variable 
/*!
    \ingroup commands
*/
class A2DGENERALDLLEXP a2dCommand_GetEnvVariable: public a2dCommand
{

    DECLARE_DYNAMIC_CLASS(a2dCommand_GetEnvVariable)

public:

    //! Set a string environment variable 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DGENERALDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.varname = false;
            argSet.varvalue = false;
        }

        ~Args()
        {
        }


        A2D_ARGUMENT_SETTER( wxString, varname )
        A2D_ARGUMENT_SETTER( wxString, varvalue )

        struct argValuet
        {
            wxString varname; wxString varvalue;
        } argValue;

        struct argSett
        {
            bool varname, varvalue;
        } argSet;
    };

    a2dCommand_GetEnvVariable( const Args& args = Args() )
    {
        m_args.argValue.varname = args.argSet.varname ? args.argValue.varname: wxString(wxEmptyString);
        if ( !args.argSet.varname || m_args.argValue.varname.IsEmpty() )
            a2dGeneralGlobals->ReportError( a2dError_GetEnv, _("wrong variable name, variable may not be empty") );
    }

private:

    Args m_args;

    virtual bool Do()
    { 
        wxString envValue;
        if( !wxGetEnv( m_args.argValue.varname, &envValue ) )
        {
            a2dGeneralGlobals->ReportError( a2dError_GetEnv, _("environment variable does not exist") );
            return false;   // Environment name not found
        }

        m_args.argSet.varvalue = true;
        m_args.argValue.varvalue = envValue;
        return true;    
    }
    virtual bool Undo()
    {
        return false;
    }
};


//----------------------------------------------------------------------------
// a2dComEvent
//----------------------------------------------------------------------------
/*
#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
    extern expdecl const wxEventType name;

#define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType();
*/

BEGIN_DECLARE_EVENT_TYPES()
    //! see a2dComEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DGENERALDLLEXP, a2dEVT_COM_EVENT, 1 )
END_DECLARE_EVENT_TYPES()

//! special event for communicating between a2dObject's and GUI objects and Command processors.
/*!
    Used for communicating and distributing events which change e.g. a2dPropObject's
    Often this event is distributed via a2dGeneralGlobals->GetEventDistributer(), so all registrated
    classes in a2dEventDistributer will receive the event.

    The information  that is sent around is stored in a a2dNamedProperty.

    To intercept this event ( when sent to an object ), use the next event table entries:

    - EVT_COM_EVENT in case of base wxEvtHandler
    - A2D_EVT_COM_EVENT in case of base a2dEvtHandler


    event id's for Change events used for specifying which type of information is communicated 
    via a a2dComEvent event.

    The idea is to add static members like this to a class you wnat to sent an event from.
    Like in a2dCanvasObject we have in the header file:

    \code
    const static a2dComEvent::wxEventType sm_changedLayer;
    \endcode

    and in the cpp file do initilize the static member:

    \code
    const a2dComEvent::wxEventType a2dCanvasObject::sm_changedLayer;
    \endcode

    and in the cpp file do sent an event from member function:

    \code
    a2dComEvent changedlayer( this, PROPID_layer, layer, &sm_changedLayer );
    a2dGeneralGlobals->GetEventDistributer()->ProcessEvent( changedlayer );
    \endcode


    \code
    BEGIN_EVENT_TABLE( anyclass, wxWindow )
          EVT_COM_EVENT( anyclass::OnComEvent )
    END_EVENT_TABLE()

    void anyclass::OnComEvent( a2dComEvent& event )
    {
        if ( event.GetEventComId() == &sm_changedLayer )
        {
            DoIt();
        }
    }
    \endcode

    \see a2dGeneralGlobals

    \see a2dEventDistributer

    \see a2dGeneralGlobals

    \see a2dComEvent

    \ingroup canvasobject eventmanager property

    \ingroup eventmanager
    \ingroup events
*/
class A2DGENERALDLLEXP a2dComEvent: public wxEvent
{
    DECLARE_DYNAMIC_CLASS( a2dComEvent )

public:

    //! id for changed properties
    //! a property on a wxProprefObject has accured.
    //! \ingroup events
    static const wxEventType sm_changedProperty;
    //! id for changed a2dObject
    //! \ingroup events
    static const wxEventType sm_changedRefObject;
    //! non info.
    //! \ingroup events
    static const wxEventType sm_non;

    //! for sending just an event id, m_property is not set
    a2dComEvent( wxObject* sender, const wxEventType* id );

    //! sent a property id ( in order to get property on sender object )
    /*!
        \param sender the object which did sent this event.
        \param id id of the property in the sender object
        \param eventid eventid is to further specify the nature of the event.
    */
    a2dComEvent( a2dPropObject* sender, const a2dPropertyId* id, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property
    /*!
        \param sender the object which did sent this event.
        \param property the property to sent
        \param id eventid is to further specify the nature of the event.
        \param ownProp when true the property will be cloned and deleted here
    */
    a2dComEvent( wxObject* sender, a2dNamedProperty* property, const wxEventType* id = &sm_changedProperty, bool ownProp = false );

    //! sent a property by reference
    /*!
        \param sender the object which did sent this event.
        \param property the property to sent
        \param eventid eventid is to further specify the nature of the event.
    */
    a2dComEvent( wxObject* sender, const a2dNamedProperty& property, const wxEventType* eventid = &sm_changedProperty );

    //! sent a property generated from a a2dObject.
    /*!
        Creates a wxRefObjectPtrProperty internal.

        \param sender the object which did sent this event.
        \param refObject the a2dObject
        \param eventid eventid is to further specify the nature of the event.
    */
    a2dComEvent( wxObject* sender, a2dObject* refObject, const wxEventType* eventid = &sm_changedRefObject );

    //! sent a property id ( in order to get property on sender object )
    /*!
        \param sender the object which did sent this event.
        \param id id of the property in the sender object
        \param eventid eventid is to further specify the nature of the event.
    */
   // a2dComEvent( wxObject* sender, const a2dPropertyId& id, const wxEventType* eventid = &sm_changedProperty );

    //! sent a property generated from a a2dObject.
    a2dComEvent( wxObject* sender, const a2dPropertyIdRefObject* id, a2dObject* refObject, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property generated from a bool.
    a2dComEvent( wxObject* sender, const a2dPropertyIdBool* id, bool propertyValue, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property generated from a wxUint16.
    a2dComEvent( wxObject* sender, const a2dPropertyIdUint16* id, wxUint16 propertyValue, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property generated from a wxInt32.
    a2dComEvent( wxObject* sender, const a2dPropertyIdInt32* id, wxInt32 propertyValue, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property generated from a double.
    a2dComEvent( wxObject* sender, const a2dPropertyIdDouble* id, double propertyValue, const wxEventType* eventid = &sm_changedProperty  );

    //! sent a property generated from a wxString.
    a2dComEvent( wxObject* sender, const a2dPropertyIdString* id, const wxString&  propertyValue, const wxEventType* eventid = &sm_changedProperty  );

    a2dComEvent();

    ~a2dComEvent();

    a2dComEvent( const a2dComEvent& other );

    wxEvent* Clone(void) const;

    a2dNamedProperty* GetProperty() { return m_property; }

    const wxEventType* GetEventComId() { return m_comid; }

    const wxEventType* GetEventComIdReturn() { return m_comReturn; }    

    //! if required the event should be sent to this object.
    wxObject* GetHandler() { return m_handler; }

    //! object to which event will be sent if needed.
    /*!
        If done, the following function will be called.

        ret = sentTo->ProcessEvent(wxComEvent& event);
    */
    void SetHandler( wxObject* sentTo ) { m_handler = sentTo; }

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //! this is a list of all smart pointers pointing to this object
    a2dSmrtPtr<a2dComEvent> *m_ownerlist;
    //! this is needed inside the smart pointer template code
    typedef a2dSmrtPtr<a2dComEvent> TOwnerListClass;
    //! Make a Dump of the objects owner list to the Debug console
    /*! This function is usually called from the Debuggers watch window */
    void DumpOwners();
#endif

private:


    //! Call to have a new owner for this object
    /*! This function should only be called by a2dSmrtPtr

        \remark owning mean that the object calling this member needs to call Release at some time,
                in order to actually release/delete the object.

        \return The return value is the object itself, which is now owned on time extra.

        increment refcount by 1 ( use when adding a reference to this object)
    */
    a2dComEvent* SmrtPtrOwn() { m_refcount++; return this; }

    //!To release the object, it is not longer owned by the calling object.
    /*! This function should only be called by a2dSmrtPtr
    */
    bool SmrtPtrRelease()
    {
        m_refcount--;
        wxASSERT_MSG( m_refcount >= 0, wxT("a2dComEvent Own/Release not matched (extra Release calls)") );
        if ( m_refcount <= 0 )
        {
            delete this;
            return true;
        }
        return false;
    }

    friend class a2dSmrtPtrBase;

    //! sent event to this object is set.
    wxObject* m_handler;

    //!how many references to this object do exist
    int m_refcount;

    //! information of the event is in form of a property.
    a2dNamedProperty* m_property;

    //! id of event
    const wxEventType* m_comid;

    //! id of return option
    const wxEventType* m_comReturn;

    //! when true, will delete the property itself.
    bool m_ownProp;
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
    template class A2DGENERALDLLEXP a2dSmrtPtr<class a2dComEvent>;
    template class A2DGENERALDLLEXP std::allocator<class a2dSmrtPtr<class a2dComEvent> >;
    template class A2DGENERALDLLEXP std::allocator< std::_List_nod<class a2dSmrtPtr<class a2dComEvent>, std::allocator<class a2dSmrtPtr<class a2dComEvent> > >::_Node >;
    template class A2DGENERALDLLEXP std::allocator< std::_List_ptr<class a2dSmrtPtr<class a2dComEvent>, std::allocator<class a2dSmrtPtr<class a2dComEvent> > >::_Nodeptr >;
    template class A2DGENERALDLLEXP std::list<class a2dSmrtPtr<class a2dComEvent> >;
    template class A2DGENERALDLLEXP a2dlist<class a2dSmrtPtr<class a2dComEvent> >;
    template class A2DGENERALDLLEXP a2dSmrtPtrList<class a2dComEvent>;
#endif

typedef void ( wxEvtHandler::*a2dComEventFunction ) ( a2dComEvent& );
typedef void ( a2dEvtHandler::*a2dObjectComEventFunction ) ( a2dComEvent& );

#define a2dComEventHandler(func) \
    (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(a2dComEventFunction, &func)
#define a2dObjectComEventHandler(func) \
    (a2dObjectEventFunction)(a2dEventFunction)wxStaticCastEvent(a2dObjectComEventFunction, &func)
    //(wxObjectEventFunction)(a2dEventFunction)wxStaticCastEvent(a2dObjectComEventFunction, &func)
/*! \addtogroup eventhandlers
*  @{
*/

//! static wxEvtHandler for communication event
#define EVT_COM_EVENT(func) wx__DECLARE_EVT0( a2dEVT_COM_EVENT, a2dComEventHandler( func ))
//! static a2dEvtHandler for communication event
#define A2D_EVT_COM_EVENT(func) a2d__DECLARE_EVT0( a2dEVT_COM_EVENT, a2dObjectComEventHandler( func ))
//!  @} eventhandlers



#endif // _COMEVTH__

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