algos.h

Go to the documentation of this file.

/*! \file wx/canvas/algos.h
    \brief a2dWalker based algorithms

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

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

#ifndef __WXALGOS_H__
#define __WXALGOS_H__

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

#include <map>
#include <set>

using namespace std;

#include "wx/canvas/canglob.h"

//! Debug handler for output the hierarchy found in a a2dDocument
/*!

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dDumpWalker: public a2dWalkerIOHandler
{
public:

    a2dDumpWalker();

    ~a2dDumpWalker();

    void Initialize();

    //! Start traversing at object, returns true.
    bool Start( a2dObject* object );

    //! called from within a2dCanvasDocument
    bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );
};

//! perform a function on each a2dCanvasObject in the document
/*!

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_CallMemberFunc: public a2dWalkerIOHandler
{
public:

    a2dWalker_CallMemberFunc();

    ~a2dWalker_CallMemberFunc();

    typedef void (a2dCanvasObject::*a2dCanvasObjectFunc) ();

    //! object to start the algorithm 
    /*!
        all object nested down here will have the function called.
    */
    bool Start( a2dObject* object, a2dCanvasObjectFunc func );

    //! called from within a2dCanvasDocument
    bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

        
    a2dCanvasObjectFunc m_func;
};

//! perform a function on each a2dCanvasObject in the document
/*!

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_CallMemberFuncW: public a2dWalkerIOHandler
{
public:

    a2dWalker_CallMemberFuncW();

    ~a2dWalker_CallMemberFuncW();

    typedef void (a2dCanvasObject::*a2dCanvasObjectFuncW) ( a2dWalkerIOHandler* );

    //! object to start the algorithm 
    /*!
        all object nested down here will have the function called.
        return true
    */
    bool Start( a2dObject* object, a2dCanvasObjectFuncW func );

    //! called from within a2dCanvasDocument
    bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

        
    a2dCanvasObjectFuncW m_func;
};

//! set layers available in a2dCanvasView as found in document
/*!

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_SetAvailable: public a2dWalkerIOHandler
{
public:

    a2dWalker_SetAvailable( a2dLayers* layerSetup );

    a2dWalker_SetAvailable( a2dCanvasView* view );

    ~a2dWalker_SetAvailable();

    //! object to start the algorithm 
    /*!
        all object nested down here will be check on layers available
        returns true
    */
    bool Start( a2dObject* object );

    //! called from within a2dCanvasDocument
    bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

protected:

    //! visible onthis view
    a2dCanvasView* m_view;

    //! availability set for this layer setup
    a2dLayers* m_layerSetup;
};

//! Remove from a2dPropObject in a hierarchy, certain properties.
/*!
    Property Id's stored in a list, are searched for in the hierarchy of a document.
    a2dObject::Walker() etc. is used to walk through the hierarchy.
    Every a2dPropObject passed, is inspected for containing one of the the properties of the list.
    The found properties will be removed.

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_RemoveProperty: public a2dWalkerIOHandler
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_RemoveProperty( bool all = true );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_RemoveProperty( const a2dPropertyId* id , bool all = true );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_RemoveProperty( const a2dPropertyIdList& idList , bool all = true );

    ~a2dWalker_RemoveProperty();

    //! add a a2dPropertyId to the list
    void AddPropertyId( const a2dPropertyId* id );

    //! start removing properties from the object given, and down.
    //! returns true if some property was removed.
    bool Start( a2dObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! to remove all or only one property on each object found.
    bool m_all;

    //! properties to search for
    a2dPropertyIdList m_propertyList;
};

//! Remove from property in a hierarchy of a canvas document.
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_RemovePropertyCandoc: public a2dWalkerIOHandler
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_RemovePropertyCandoc( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL, bool all = true );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_RemovePropertyCandoc( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL, bool all = true );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_RemovePropertyCandoc( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL, bool all = true );

    ~a2dWalker_RemovePropertyCandoc();

    //! add a a2dPropertyId to the list
    void AddPropertyId( const a2dPropertyId* id );

    //! start removing properties from the object given, and down.
    //! returns true if some property was removed.
    bool Start( a2dCanvasObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! if set when a property  is removed make the canvas object pending.
    void SetMakePending( bool makePending ) { m_makePending = makePending; }

    //! to remove all or only one property on each object found.
    bool m_all;

    //! properties to search for
    a2dPropertyIdList m_propertyList;
    
    //! mask required in object
    a2dCanvasObjectFlagsMask m_mask;
    
    //! how deep to recurse into document
    int m_depth; 

    //! set object pending when property is removed.
    bool m_makePending;
};

//! document walking to select a2dCanvasObject by filtering against several constraints.
/*!
    This is often used as base class for other algorithms.
    Its task is to select object that adhere to the filter properties set for this class. 

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_FilterCanvasObjects: public a2dWalkerIOHandler
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_FilterCanvasObjects( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_FilterCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_FilterCanvasObjects( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    ~a2dWalker_FilterCanvasObjects();

    //! add a a2dPropertyId to the list
    void AddPropertyId( const a2dPropertyId* id );

    //! used from constructors
    void Initialize();

    //! start iteration here
    //! returns m_result, which value depends on derived class, and defaults to false.
    bool Start( a2dCanvasObject* object );

    //! add to classname to set of classes to be filtered.
    void AddClassName( wxString className );

    //! remove this classname from set.
    void RemoveClassName( wxString className );

    //! when set, object filtered on classname are written to target ( file or layer )
    //! Else non filtered on classname objects are written to the target.
    void SetAllowClassList( bool allow ) { m_allowClassList = allow; }

    //! when set, object filtered on classname are written to target ( file or layer )
    //! Else non filtered on classname objects are written to the target.
    bool GetAllowClassList() { return m_allowClassList; }

    //! if not empty, objects must have this name
    void SetObjectName( const wxString& objectname = wxT("") ) { m_objectname = objectname; }

    //! if not 0, objects must have this UniqueSerializationId
    void SetUniqueSerializationId( wxInt64 id ) { m_id = id; }

    //! if valid, objects must fit in this boundingbox 
    void SetBoundingBox( const a2dBoundingBox& bbox ) { m_bbox = bbox; }

    //! how far we go into nested a2dObject's
    void SetRecursionDepth( int depth = INT_MAX ) { m_depth = depth; }

    //! if set, layer which the object is on must be visible
    void SetCheckLayerVisible( bool check ) { m_layervisible = check; }

    //! if set, layer which the object is on must be selectable
    void SetCheckLayerSelectable( bool check ) { m_layerselectable = check; }

    //! if set, the start object will be skipped 
    void SetSkipStart( bool skip ) { m_skipStartObject = skip; }

    //! if not empty, object must have the properties in this list
    a2dPropertyIdList m_propertyList;

    //! object must fit this mask.
    a2dCanvasObjectFlagsMask m_mask;
    
    //! list of classnames to be filtered
    set<wxString> m_classnameMap;

    //! name for object is not empty
    wxString m_objectname;

    //! wanted id
    wxInt64 m_id;

    //! wanted depth
    int m_depth;

    //! object must be in this box if it the box is valid
    a2dBoundingBox m_bbox;      

    //!if set, the layer must be visible
    bool m_layervisible;

    //!if set, the layer must be selectable
    bool m_layerselectable;

    //! the start object itself is not checked
    bool m_skipStartObject;

    //! to negate list of classnames to be filtered
    bool m_allowClassList;

protected:

    //! convert canvasobject to a list of polygons.
    //! But only for simple primitive objects.
    //! first a2dCanvasObject::GetAsCanvasVpaths() is used to convert to vector paths,
    //! and next the vector path is translated into polygons.
    a2dCanvasObjectList* ConvertToPolygons( a2dCanvasObject* canvasobject, bool transform );

    //! convert canvasobject to a list of Vpath.
    //! But only for simple primitive objects.
    //! first a2dCanvasObject::GetAsCanvasVpaths() is used to convert to vector paths,
    a2dCanvasObjectList* ConvertToVpath( a2dCanvasObject* canvasobject, bool transform );

    //! return true if object fits the filter
    bool ObjectOke( a2dCanvasObject* obj );

    //! return true of object fits the classname filter
    bool ClassOfObjectOke( a2dCanvasObject* obj );

};

//! collect a2dCanvasObject's in a hierarchy of a a2dCanvasDocument
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_CollectCanvasObjects: public a2dWalker_FilterCanvasObjects
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_CollectCanvasObjects( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_CollectCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_CollectCanvasObjects( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    ~a2dWalker_CollectCanvasObjects();

    void Initialize();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! objects found
    a2dCanvasObjectList m_found;
};

//! find a2dCanvasObjects in a hierarchy of a a2dCanvasDocument
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_FindCanvasObject: public a2dWalkerIOHandler
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_FindCanvasObject( a2dCanvasObject* toSearch );

    ~a2dWalker_FindCanvasObject();

    bool Start( a2dCanvasObject* object );

    void Initialize();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! object found
    a2dCanvasObjectPtr m_search;
};

//! set a2dCanvasObjects flags in a hierarchy of a a2dCanvasDocument
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_SetSpecificFlagsCanvasObjects: public a2dWalker_FilterCanvasObjects
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_SetSpecificFlagsCanvasObjects( a2dCanvasObjectFlagsMask which, const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    ~a2dWalker_SetSpecificFlagsCanvasObjects();

    void Initialize();

    //! start removing properties from the object given, and down.
    bool Start( a2dCanvasObject* object, bool setTo );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! mask for which flags to set
    a2dCanvasObjectFlagsMask m_which;

    //! clear or set the flags
    bool m_setOrClear;
};

//! set a2dCanvasObjects property in a hierarchy of a a2dCanvasDocument
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_SetPropertyToObject: public a2dWalkerIOHandler
{
public:

    //! constructor with a2dPropertyId to set
    a2dWalker_SetPropertyToObject( a2dNamedProperty* prop );

    ~a2dWalker_SetPropertyToObject();

    void Initialize();

    //! called from within a2dDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! id of property to set
    a2dNamedProperty* m_property;

};

//----------------------------------------------------------------------------
// a2dWalker_SetProperty
//----------------------------------------------------------------------------

//! set a2dObjects property in a hierarchy of a a2dDocument
/*!
    \ingroup docalgo
*/
template< class basetype, class a2dpropertyidtyped, class proptype = a2dPropObject >
class a2dWalker_SetProperty: public a2dWalkerIOHandler
{
public:

    //! constructor with no a2dPropertyIdTyped<basetype, proptype> added yet. For that use AddPropertyId()
    a2dWalker_SetProperty( basetype valueToSet, bool all = true );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_SetProperty( const a2dpropertyidtyped* id, basetype valueToSet , bool all = true );

    //! destructor
    ~a2dWalker_SetProperty();

    //! add a a2dPropertyId to the list
    void AddPropertyId( const a2dpropertyidtyped* id );

    //! start removing properties from the object given, and down.
    bool Start( a2dObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! to remove all or only one property on each object found.
    bool m_all;

    //! value to set 
    basetype m_valueToSet;

    //! properties to search for
    a2dPropertyIdList m_propertyList;
};

typedef a2dWalker_SetProperty< bool, a2dPropertyIdBool > a2dWalker_SetBoolProperty;

typedef a2dWalker_SetProperty< wxInt16, a2dPropertyIdInt16> a2dWalker_SetInt16Property;
typedef a2dWalker_SetProperty< wxUint16, a2dPropertyIdUint16> a2dWalker_SetUint16Property;
typedef a2dWalker_SetProperty< wxInt32, a2dPropertyIdInt32> a2dWalker_SetInt32Property;
typedef a2dWalker_SetProperty< wxUint32, a2dPropertyIdUint32> a2dWalker_SetUint32Property;

typedef a2dWalker_SetProperty< double, a2dPropertyIdDouble> a2dWalker_SetDoubleProperty;
typedef a2dWalker_SetProperty< float, a2dPropertyIdFloat> a2dWalker_SetFloatProperty;
typedef a2dWalker_SetProperty< wxString, a2dPropertyIdString> a2dWalker_SetStringProperty;

template< class basetype, class a2dpropertyidtyped, class proptype >
a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::a2dWalker_SetProperty( basetype valueToSet, bool all )
{
    m_valueToSet = valueToSet;
    m_all = all;
}

template< class basetype, class a2dpropertyidtyped, class proptype >
a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::a2dWalker_SetProperty( const a2dpropertyidtyped* id, basetype valueToSet, bool all )
{
    m_valueToSet = valueToSet;
    m_propertyList.push_back( (a2dPropertyId*) id );
    m_all = all;
}

template< class basetype, class a2dpropertyidtyped, class proptype >
a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::~a2dWalker_SetProperty()
{
}

template< class basetype, class a2dpropertyidtyped, class proptype >
void a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::AddPropertyId( const a2dpropertyidtyped* id )
{
    m_propertyList.push_back( (a2dPropertyId*) id );
}


template< class basetype, class a2dpropertyidtyped, class proptype >
bool a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::Start( a2dObject* object )
{
    object->Walker( NULL, *this );
    return true;
}

template< class basetype, class a2dpropertyidtyped, class proptype >
bool a2dWalker_SetProperty< basetype,a2dpropertyidtyped, proptype >::WalkTask( wxObject* WXUNUSED(parent), wxObject* object, a2dWalkEvent event )
{
    if ( event == a2dWalker_a2dPropObjectStart )
    {
        SetStopWalking( true );
        if ( wxDynamicCast( object, proptype ) )
        {
            a2dPropObject* propobj = wxDynamicCast( object, proptype );
            forEachIn( a2dPropertyIdList, &m_propertyList )
            {
                a2dpropertyidtyped *id = (a2dpropertyidtyped*) *iter;
                id->SetPropertyToObject( propobj, m_valueToSet );
            }
        }
    }
    if ( event == a2dWalker_a2dPropObjectEnd )
        SetStopWalking( false );

    return true;
}

//! set the a2dCanvasObject's view dependent 
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_SetViewDependent: public a2dWalkerIOHandler
{
public:

    //! constructor 
    /*!
        \param aView view for adding next properties on this object and maybe its children.
        \param viewdependent if true then to add property 'PROPID_viewDependent' to objects 
                             that are depend on 'aView' view when it comes to size. 
                             Else to remove this property. 
        \param viewspecific  if true then to add property 'PROPID_viewSpecific' to objects 
                             that are only visible on 'aView' view.
                             Else to remove this property to make visible on all views. 
        \param onlyinternalarea Remove scale in matrix for children objects.
    */    
    a2dWalker_SetViewDependent( a2dCanvasView* aView, bool viewdependent, bool viewspecific = false, bool onlyinternalarea = false  );

    //! destructor
    ~a2dWalker_SetViewDependent();

    bool Start( a2dCanvasObject* object );

    void Initialize();

    //! called from within a2dDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! which view to set view dependent
    a2dCanvasView* m_aView;
    //! on/off for view dependent updating 
    bool m_viewdependent;
    //! set only visible for this view
    bool m_viewspecific;
    //! transform without scale for children
    bool m_onlyinternalarea;
};

//! set the a2dCanvasObject's a2dCanvasDocument root recursive 
/*!
    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_SetCanvasDocument: public a2dWalkerIOHandler
{
public:

    //! 
    /*!
        \param root set the a2dCanvasDocument of object to this root
    */    
    a2dWalker_SetCanvasDocument( a2dCanvasDocument* root );

    ~a2dWalker_SetCanvasDocument();

    //! start setting the root object from here
    bool Start( a2dCanvasObject* object );

    //! called from within a2dDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! document to set
    a2dCanvasDocument* m_root;
};

//! make the child which fit the mask/filter into a tree structure to a certain level
/*!
    Normally a document structure can have multiple references to the same object.    
    Like branches on a tree which touch eachother. This walker makes all branches unique.

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_MakeTree: public a2dWalker_FilterCanvasObjects
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_MakeTree( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_MakeTree( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_MakeTree( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    ~a2dWalker_MakeTree();

    //! start here
    bool Start( a2dCanvasObject* object );

    void Initialize();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

private:
   
    //! detection for start of first level childs
    bool m_firstLevelChild;
};

//! remove hierarchy in grouped objects
/*!
    in a2dCanvasObject with children, the children are moved one level.
    Same for a2dCanvasObjectReference and a2dCanvasObjectArrayReference its m_object.

    m_depth > 1 will result in smashing all children in an object also nest.
    m_depth = 1 will result in on level of hierarchy removed.

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_RemoveHierarchy: public a2dWalker_FilterCanvasObjects
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_RemoveHierarchy( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_RemoveHierarchy( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_RemoveHierarchy( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    ~a2dWalker_RemoveHierarchy();

    //! start here
    bool Start( a2dCanvasObject* object );

    void Initialize();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

private:

    //! set objects selected after removing hierarchy
    bool m_selected;

    //! detection for start of first level childs
    bool m_firstLevelChild;

    //! to hold parents passed
    a2dSmrtPtrList<a2dObject> m_parentList;
};


//! base algorithm class to work on a2dCanvasObjects in groups of layers
/*!
    groupA and groupB are filled with layer numbers.

    a2dCanvasObjects with the flag a2dCanvasOFlags::m_ignoreLayer set, will be ignored here.

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_LayerGroup: public a2dWalker_FilterCanvasObjects
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_LayerGroup( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_LayerGroup( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_LayerGroup( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! destructor
    ~a2dWalker_LayerGroup();

    //! used from constructor
    void Initialize();

    //! start at this object 
    bool Start( a2dCanvasObject* object );

    //! objects on layers in group A will be used as first operand
    void SetGroupA( const a2dLayerGroup& groupA ) { m_groupA = groupA; }

    //! objects on layers in group B will be used as first operand
    void SetGroupB( const a2dLayerGroup& groupB ) { m_groupB = groupB; }

    //! set the layer where the result will be placed
    void SetTarget( wxUint16 targetlayer);

    //! set selectedOnlyA in group operations
    void SetSelectedOnlyA( bool selectedOnlyA ) { m_selectedOnlyA = selectedOnlyA; }  
    
    //! get selectedOnlyA in group operations
    bool GetSelectedOnlyA() { return m_selectedOnlyA; }
    
    //! set selectedOnlyB in group operations
    void SetSelectedOnlyB( bool selectedOnlyB ) { m_selectedOnlyB = selectedOnlyB; }   

    //! get selectedOnlyB in group operations
    bool GetSelectedOnlyB() { return m_selectedOnlyB; }   

protected:

    //! group A layers operand
    a2dLayerGroup m_groupA;

    //! group B layers operand
    a2dLayerGroup m_groupB;

    //! result into this layer
    wxUint16 m_target;

    //! work only on selected object in group A
    bool m_selectedOnlyA;
    //! work only on selected object in group B
    bool m_selectedOnlyB;

};

//! algorithm to  delete a2dCanvasObjects on layers or to move, copy to other layers
/*!
    groupA and groupB are filled with layer numbers.
    Next one calls a valid operation, which is can be:
    - moveLayers
    - copyLayers
    - deleteLayers

    a2dCanvasObjects with the flag a2dCanvasOFlags::m_ignoreLayer set, will be ignored here.

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_LayerCanvasObjects: public a2dWalker_LayerGroup
{
public:

    typedef long Operation;

    //! move layers to target
    static const long moveLayers;
    //! copy layers to target
    static const long copyLayers;
    //! delete layers 
    static const long deleteLayers;
    //! convert segments in polygon/polyline objects in group A to Arcs where possible
    static const long ConvertToArcs;
    //!  convert to simple polygons and polylines preserve arcs
    static const long ConvertToPolygonPolylinesWithArcs;
    //!  convert to simple polygons and polylines
    static const long ConvertToPolygonPolylinesWithoutArcs;
    //! convert segments in polygon/polyline with width objects in group A to Arcs where possible
    static const long ConvertPolygonToArcs;   
    //! convert segments in polyline objects in group A to Arcs where possible
    static const long ConvertPolylineToArcs;   
    //! convert shapes to vector paths
    static const long ConvertToVPaths; 
    //! convert shapes to seperate lines and arcs
    static const long ConvertLinesArcs; 
    //! convert shapes to polylines even if polygons
    static const long ConvertToPolylines; 
    //! remove redundant segment
    static const long RemoveRedundant;
    //! calculate area of objects
    static const long areaLayers;

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_LayerCanvasObjects( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_LayerCanvasObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_LayerCanvasObjects( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! destructor
    ~a2dWalker_LayerCanvasObjects();

    //! used from constructor
    void Initialize();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

    //! set type of operation
    void SetOperation( Operation operation ) { m_operation = operation; }

    //! Polygon/polyline to Arc Minimum radius to test
    void SetRadiusMin( double radiusMin ) { m_radiusMin = radiusMin; }
    //! Polygon/polyline to Arc Maximum radius to test
    void SetRadiusMax( double radiusMax ) { m_radiusMax = radiusMax; }
    //! Polygon/polyline to Arc Maximum abberation
    void SetAberPolyToArc( double aber ) { m_AberPolyToArc = aber; }

    //! if after polygon conversion to arcs end up as one arc segment  forming a circle,
    //! add a circle object to target and not a polygon.
    void SetDetectCircle( bool detectCircle ) { m_detectCircle = detectCircle; }  

    //! see SetDetectCircle
    bool GetDetectCircle() { return m_detectCircle; }
    
    //! in areaLayers returns calculated area sofar.
    double GetCalculatedArea() { return m_calculatedArea; }

protected:

    void AddArea( a2dCanvasObject* getAsPolyObject );

    //! Polygon/polyline to Arc Minimum radius to test
    double m_radiusMin;
    //! Polygon/polyline to Arc Maximum radius to test
    double m_radiusMax;
    //! Polygon/polyline to Arc Maximum abberation
    double m_AberPolyToArc;

    bool m_detectCircle;

    double m_calculatedArea;

    //! id for operation
    Operation m_operation;
};

//! detection of small objects.
/*! Detect objects, which are smaller than a certain size.
The report is generated as a string containing the CVG output, which can be written to a file. 
*/
class A2DCANVASDLLEXP a2dWalker_DetectSmall: public a2dWalker_LayerGroup
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_DetectSmall( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_DetectSmall( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_DetectSmall( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! destructor
    ~a2dWalker_DetectSmall();

    //! used from constructor
    void Initialize();

    //! set what is seen as small.
    void SetSmall( double smallest ) { m_small = smallest; }

    //! set asString
    void SetAsString( bool asString ) { m_asString = asString; }  
    
    //! get asString
    bool GetAsString() { return m_asString; }

    bool Start( a2dCanvasObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

#if wxUSE_STD_IOSTREAM
    const wxString& GetString() const 
    { 
        static wxString aap = wxString( m_strstream.str().c_str(), wxConvUTF8 );
        return aap; 
    }
#else
    const wxString GetString() const { return m_strstream.GetString(); }
#endif

protected:

    a2dIOHandlerCVGOut m_CVGwriter;
    a2dDocumentStringOutputStream m_strstream;
    bool m_asString;
    double m_small;
};

//! detection of small objects.
/*! Detect objects, which are smaller than a certain size.
The report is generated as a string containing the CVG output, which can be written to a file. 
*/
class A2DCANVASDLLEXP a2dWalker_DetectSmallSegments: public a2dWalker_LayerGroup
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_DetectSmallSegments( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_DetectSmallSegments( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_DetectSmallSegments( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! destructor
    ~a2dWalker_DetectSmallSegments();

    //! used from constructor
    void Initialize();

    //! set what is seen as small.
    void SetSmall( double smallest ) { m_small = smallest; }

    //! set asString
    void SetAsString( bool asString ) { m_asString = asString; }  
    
    //! get asString
    bool GetAsString() { return m_asString; }

    bool Start( a2dCanvasObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

#if wxUSE_STD_IOSTREAM
    const wxString& GetString() const 
    { 
        static wxString aap = wxString( m_strstream.str().c_str(), wxConvUTF8 );
        return aap; 
    }
#else
    const wxString GetString() const { return m_strstream.GetString(); }
#endif

protected:

    a2dIOHandlerCVGOut m_CVGwriter;
    a2dDocumentStringOutputStream m_strstream;
    bool m_asString;
    double m_small;
};

//! find the a2dcanvasObject, and set the corridor flag on the path to it.
/*!
    Corridors are used as event tubes in a a2dCanvasDocument, in order to redirect events directly
    to a specific object, but maintaining its position/matrixes correctly as in the document.

     \see a2dIterC::SetCorridorPath
     \see a2dCanvasView::ClearCorridorPath

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalker_FindAndSetCorridorPath: public a2dWalker_FindCanvasObject
{
public:

    //! constructor 
    /*! \see a2dIterC::SetCorridorPath
        \see a2dCanvasView::FindAndSetCorridorPath
        This function is not used directly, but via a2dCanvasView::FindAndSetCorridorPath

        \param findObject (child) object to be searched for.
        \return true if findObject was found
    */
    a2dWalker_FindAndSetCorridorPath( a2dCanvasObject* findObject );

    //! destructor
    ~a2dWalker_FindAndSetCorridorPath();

    //! called from within a2dDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );
};

//! filter to string or file
/*! 
    First filter is ObjectOke(), and next
    objects with classnames which are part of the m_classnameMap ( or NOT if m_allowClassList is set ), 
    are filtered.

*/
class A2DCANVASDLLEXP a2dWalker_AllowedObjects: public a2dWalker_LayerGroup
{
public:

    //! constructor with no a2dPropertyId added yet. For that use AddPropertyId()
    a2dWalker_AllowedObjects( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with a2dPropertyId added to the propertyIsList to search for.
    a2dWalker_AllowedObjects( const a2dPropertyId* id , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! constructor with the propertyIdList to search for as input
    a2dWalker_AllowedObjects( const a2dPropertyIdList& idList , a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL );

    //! destructor
    ~a2dWalker_AllowedObjects();

    //! used from constructor
    void Initialize();

    //! set asString
    void SetAsString( bool asString ) { m_asString = asString; }  
    
    //! get asString
    bool GetAsString() { return m_asString; }

    //! set if result must be stored
    void SetStore( bool store ) { m_store = store; }  
    
    //! get store
    bool GetStore() { return m_store; }

    bool Start( a2dCanvasObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( wxObject* parent, wxObject* object, a2dWalkEvent event );

#if wxUSE_STD_IOSTREAM
    const wxString& GetString() const 
    { 
        static wxString aap = wxString( m_strstream.str().c_str(), wxConvUTF8 );
        return aap; 
    }
#else
    const wxString GetString() const { return m_strstream.GetString(); }
#endif

protected:

    a2dIOHandlerCVGOut m_CVGwriter;
    a2dDocumentStringOutputStream m_strstream;
    bool m_asString;
    bool m_store;
};

//! Walker taking iterative context into account.
/*!

    \ingroup docalgo
*/
class A2DCANVASDLLEXP a2dWalkerIOHandlerWithContext: public a2dWalkerIOHandler
{
public:

    //! constructor
    a2dWalkerIOHandlerWithContext( a2dIterC& ic );

    //! destructor
    ~a2dWalkerIOHandlerWithContext();

    //! init
    void Initialize();

    //! Start traversing at object, returns true.
    bool Start( a2dCanvasObject* object );

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( a2dIterC& ic, wxObject* parent, wxObject* object, a2dWalkEvent event ) = 0;

    a2dIterC* m_context;
};


//! set a2dCanvasObjects check flag when in view
/*!
    \ingroup docalgo
*/
class a2dWalker_RenderLayers: public a2dWalkerIOHandlerWithContext
{
public:

    //! constructor
    a2dWalker_RenderLayers( a2dIterC& ic );

    //! destructor
    ~a2dWalker_RenderLayers();

    //! called from within a2dCanvasDocument
    virtual bool WalkTask( a2dIterC& ic, wxObject* parent, wxObject* object, a2dWalkEvent event );

    void Render( a2dIterC& ic, a2dCanvasObject* canobj, OVERLAP clipparent );
};


#endif

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