stylebase.h

Go to the documentation of this file.

/*! \file wx/artbase/stylebase.h
 
    \brief Stroke and fill base classes.
 
    Holds style classes, derived from a2dObject. All wxDrawer2D understand the style classes 
    which are set as a2dStroke a2dFill to them.
    Style classes can be added to a2dCanvasObject's as properties, and this is how these object
    can be drawn colours which are customizable by the user.
 
    \author Klaas Holwerda
 
    Copyright: 2000-2004 (c) Klaas Holwerda
 
    Licence: wxWidgets Licence
 
    RCS-ID: $Id: stylebase.h,v 1.57 2009/10/01 19:22:34 titato Exp $
*/


#ifndef __STYLEBASE_H__
#define __STYLEBASE_H__

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

#include <wx/fontenc.h>
#include <wx/encconv.h>
#include <wx/bitmap.h>

#include "a2dprivate.h"

#include "wx/txtstrm.h"
#include "wx/geometry.h"

#include <map>

using namespace std;


#if wxART2D_USE_FREETYPE
#include <ft2build.h>
#ifdef _MSC_VER
// Do not use the define include for MSVC, because of a bug with precompiled
// headers. See (freetype)/doc/INSTALL.ANY for (some) more information
#include <freetype/freetype.h>
#include <freetype/ftglyph.h>
#else // _MSC_VER
// This is the way it should be included.
#include FT_FREETYPE_H
#include FT_GLYPH_H
#endif // _MSC_VER
#endif

#include "wx/general/gen.h"

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

#include "wx/artbase/artglob.h"
#include "wx/artbase/liner.h"
#include "wx/artbase/afmatrix.h"
#include "wx/artbase/bbox.h"

//! Normalisation factor used for freetype fonts
#define FTNORMFONT 1000
//! Normalisation factor used for DC fonts
#define NORMFONT 100

class A2DARTBASEDLLEXP a2dBoundingBox;
class A2DARTBASEDLLEXP a2dAffineMatrix;

class a2dDrawer2D;
class a2dVpath;

//! General colour property id
extern a2dPropertyIdColour PROPID_colour;

//!Filling styles for a2dFill
/*!
    Transparent filling when bitmap/patternfill is monochrome and fill style is
    wxSTIPPLE_MASK_OPAQUE_TRANSPARENT.
    The fill colour will be used for non Transparent parts in the brush bitmap,
    while other parts will be transparent.
    a2dFILL_GRADIENT_FILL_LINEAR gradient filling using lines changing in colour from fill colour1 to fill colour2
    a2dFILL_GRADIENT_FILL_RADIAL, gradient filling using circles changing in colour from fill colour1 to fill colour2
 
    \ingroup  style
*/
enum a2dFillStyle
{
    a2dFILL_TRANSPARENT,      /*!<  No fill is used.*/
    a2dFILL_SOLID,            /*!<  Solid style. */
    a2dFILL_BDIAGONAL_HATCH,  /*!<  Backward diagonal hatch.*/
    a2dFILL_CROSSDIAG_HATCH,  /*!<  Cross-diagonal hatch.*/
    a2dFILL_FDIAGONAL_HATCH,  /*!<  Forward diagonal hatch.*/
    a2dFILL_CROSS_HATCH,      /*!<  Cross hatch.*/
    a2dFILL_HORIZONTAL_HATCH, /*!<  Horizontal hatch.*/
    a2dFILL_VERTICAL_HATCH,   /*!<  Vertical hatch.*/
    a2dFIRST_HATCH = a2dFILL_BDIAGONAL_HATCH,
    a2dLAST_HATCH = a2dFILL_VERTICAL_HATCH,
    a2dFILL_TWOCOL_BDIAGONAL_HATCH,  /*!<  Backward diagonal hatch.*/
    a2dFILL_TWOCOL_CROSSDIAG_HATCH,  /*!<  Cross-diagonal hatch.*/
    a2dFILL_TWOCOL_FDIAGONAL_HATCH,  /*!<  Forward diagonal hatch.*/
    a2dFILL_TWOCOL_CROSS_HATCH,      /*!<  Cross hatch.*/
    a2dFILL_TWOCOL_HORIZONTAL_HATCH, /*!<  Horizontal hatch.*/
    a2dFILL_TWOCOL_VERTICAL_HATCH,   /*!<  Vertical hatch.*/
    a2dFIRST_TWOCOL_HATCH = a2dFILL_TWOCOL_BDIAGONAL_HATCH,
    a2dLAST_TWOCOL_HATCH = a2dFILL_TWOCOL_VERTICAL_HATCH,
    a2dFILL_STIPPLE,          /*!<  Use the stipple bitmap.*/
    a2dFILL_STIPPLE_MASK_OPAQUE, /*!<  Use the stipple bitmap.*/
    a2dFILL_STIPPLE_MASK_OPAQUE_TRANSPARENT, /*!<  Use the stipple bitmap.*/
    a2dFILL_GRADIENT_FILL_XY_LINEAR,  /*!< linear scan from colour 1 to colour two .*/
    a2dFILL_GRADIENT_FILL_XY_RADIAL, /*!< circular scan from colour 1 to colour two .*/
    a2dFILL_GRADIENT_FILL_XY_DROP,  /*!< sort of side scan from colour 1 to colour two .*/
    a2dFILL_INHERIT, /*!<  Use the style of the parent object*/
    a2dFILL_LAYER, /*!<  Use the style of the layer from the layersettings */
    a2dFILL_NULLFILL         /*!<  special NULL fill used for a2dNullFill */
};

//! for a2dFill to define the type of filling.
/*!
    \ingroup style
*/
enum a2dFillType
{
    a2dFILL_NULL, /*!< null type */
    a2dFILL_ONE_COLOUR, /*!< one colour */
    a2dFILL_HATCH_TWO_COLOUR, /*!< two colour hatch*/
    a2dFILL_GRADIENT_FILL_LINEAR, /*!< linear scan from colour one to colour two */
    a2dFILL_GRADIENT_FILL_RADIAL, /*!< circular scan from colour one to colour two */
    a2dFILL_BITMAP, /*!< using a bitmap */
};

/*!
    To set fill on a2dDrawer2D and a2dCanvasObject classes.

    When style is set a2dFILL_TRANSPARENT, the rest of the fill data is preserved until style is changed. 

    \ingroup property style
*/
class A2DARTBASEDLLEXP a2dFill : public wxObject
{

#ifdef CLASS_MEM_MANAGEMENT
    //! memory manager for speed up to replace system calls allocation and deallocation
    static a2dMemManager sm_memManager;
public:
    //! overloaded operator new for this class and all it's derived classes
    void* operator new( size_t bytes )
    {
        return sm_memManager.Allocate( bytes );
    }

    //! overloaded operator delete for this class and all it's derived classes
    /*!
    This function doesn't free to OS-system memory block by pointer 'space'.
    It adds memory block by pointer 'space' to internal lists.
    It is speed up.
    */
    void operator delete( void *space, size_t bytes )
    {
        sm_memManager.Deallocate( space, bytes );
    }
#endif //CLASS_MEM_MANAGEMENT

public:

    //!constructor
    a2dFill( void );

    a2dFill( const a2dFill& fill );

    a2dFill( const wxBrush& brush );

    a2dFill( const wxColour& col, a2dFillStyle style = a2dFILL_SOLID );

    a2dFill( const wxColour& col, const wxColour& col2, a2dFillStyle style );

    a2dFill( const wxBitmap& stipple, a2dFillStyle style = a2dFILL_STIPPLE );

    a2dFill( const wxBitmap& stipple, const wxColour& col, const wxColour& col2, a2dFillStyle style = a2dFILL_STIPPLE );

    a2dFill( const wxFileName& filename, a2dFillStyle style = a2dFILL_STIPPLE );

    a2dFill( const wxFileName& filename, const wxColour& col, const wxColour& col2, a2dFillStyle style = a2dFILL_STIPPLE );
    
    a2dFill( const wxColour& col, const wxColour& col2,  
        double x1, double y1, double x2, double y2 );

    a2dFill( const wxColour& col, const wxColour& col2,  
        double xfc, double yfc, double xe, double ye, double radius );

    bool operator==(const a2dFill& a)
    {
        return m_refData == a.m_refData;
    }

    bool operator!=(const a2dFill& a)
    {
        return m_refData != a.m_refData;
    }

    friend inline bool operator==(const a2dFill& a, const a2dFill& b)
    {
        return a.m_refData == b.m_refData;
    }

    friend inline bool operator!=(const a2dFill& a, const a2dFill& b)
    {
        return a.m_refData != b.m_refData;
    }

    a2dFill& UnShare();

    wxObjectRefData* CreateRefData() const;

    wxObjectRefData* CloneRefData(const wxObjectRefData * data) const;

    //!destructor
    virtual ~a2dFill( void );

    a2dFillType GetType( void ) const; 

    a2dFillStyle GetStyle() const; 

    void SetStyle( a2dFillStyle style ); 

    a2dFillType GetTypeForStyle( a2dFillStyle style ) const;

    void SetStipple( const wxBitmap& stipple );

    const wxBitmap& GetStipple() const;

    //! return colour
    wxColour GetColour() const; 

    //! return colour 2
    wxColour GetColour2() const;

    //! set colour  used for gradient and wxSTIPPLE_MASK_OPAQUE filling.
    void SetColour( const wxColour& col );

    //! set colour 2 used for gradient and wxSTIPPLE_MASK_OPAQUE filling.
    void SetColour2( const wxColour& col );

    void SetAlpha( wxUint8 val );
    wxUint8 GetAlpha() const;

    //!Get start for gradient fill colour change
    a2dPoint2D GetStart() const;

    //!Get stop for gradient fill colour change
    a2dPoint2D GetStop() const;

    //! time stamp gradient fill
    wxUint32 GetStamp() const;

    //!Get start for gradient fill colour change
    a2dPoint2D GetCenter() const;

    //!Get start for gradient fill colour change
    a2dPoint2D GetFocal() const;

    //!Get stop for gradient fill colour change
    double GetRadius() const;

    //! used to define fills that are not yielding (either need to be deleted, 
    //! or indicate that there is no fill defined for an object.
    //! This is can be used on any fill. This method, is handy since one can still clone
    //! such fills.
    bool IsNoFill() const { return m_refData == NULL; }

    //! from now one this object defines as if no stroke is defined of the object having this stroke.
    a2dFill* SetNoFill() { UnRef(); return this; }

    //! is set true, filling is on else filling is transparent.
    //! This is to quickly switch to filling or not, without changing style.
    void SetFilling( bool OnOff );

    //! if true, filling is on else filling is transparent.
    bool GetFilling() const;

    DECLARE_DYNAMIC_CLASS( a2dFill )

#if wxART2D_USE_CVGIO
    virtual void Load( wxObject* parent, a2dIOHandlerXmlSerIn& parser );
    virtual void Save( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO

};

//! stroke styles for a2dStroke
/*!
    \ingroup style
*/
enum a2dStrokeStyle
{
    a2dSTROKE_TRANSPARENT, /*!<  No stroke is used.*/
    a2dSTROKE_SOLID, /*!<  Solid style. */
    a2dSTROKE_DOT, /*!< Dotted style.*/
    a2dSTROKE_LONG_DASH, /*!<  Long dashed style.*/
    a2dSTROKE_SHORT_DASH, /*!<  Short dashed style.*/
    a2dSTROKE_DOT_DASH, /*!<  Dot and dash style.*/
    a2dSTROKE_USER_DASH, /*!<  Use the user dashes*/
    a2dSTROKE_BDIAGONAL_HATCH, /*!<  Backward diagonal hatch.*/
    a2dSTROKE_CROSSDIAG_HATCH, /*!<  Cross-diagonal hatch.*/
    a2dSTROKE_FDIAGONAL_HATCH, /*!<  Forward diagonal hatch.*/
    a2dSTROKE_CROSS_HATCH, /*!<  Cross hatch.*/
    a2dSTROKE_HORIZONTAL_HATCH, /*!<  Horizontal hatch.*/
    a2dSTROKE_VERTICAL_HATCH, /*!<  Vertical hatch.*/
    a2dSTROKE_STIPPLE, /*!<  Use the stipple bitmap.*/
    a2dSTROKE_STIPPLE_MASK_OPAQUE, /*!<  Use the stipple bitmap.*/
    a2dSTROKE_STIPPLE_MASK_OPAQUE_TRANSPARENT, /*!<  Use the stipple bitmap.*/
    a2dSTROKE_OBJECTS, /*!<  Use a a2dCanvasObject. */
    a2dSTROKE_INHERIT, /*!<  Use the style of the parent object*/
    a2dSTROKE_LAYER, /*!<  Use the style of the layer from the layersettings */
    a2dSTROKE_NULLSTROKE       /*!<  special NULL fill used for a2dNullStroke */
};

//! stroke types
//! TODO ( only Xwindows ) a2dPatternStroke(const wxBitmap& stipple, double width);
//! TODO ( only Xwindows ) a2dPatternStroke(const wxBitmap& stipple, int width);
enum a2dStrokeType
{
    a2dSTROKE_NULL,
    a2dSTROKE_OBJECT,
    a2dSTROKE_NORMAL, /*!< not using a bitmap or gradient */
    a2dSTROKE_ONE_COLOUR, /*!< one colour */
    //a2dSTROKE_GRADIENT_FILL_LINEAR, /*!< linear scan from colour one to colour two */
    //a2dSTROKE_GRADIENT_FILL_RADIAL, /*!< circular scan from colour one to colour two */
    a2dSTROKE_BITMAP, /*!< using a bitmap */
};

typedef float a2dDash;

#if !wxCHECK_VERSION(2,9,0)
typedef int wxPenJoin;
typedef int wxPenCap;
typedef int wxPolygonFillMode;
typedef int wxRasterOperationMode;

// NOTE: these values cannot be combined together!
enum wxBrushStyle
{
    wxBRUSHSTYLE_INVALID = -1,

    wxBRUSHSTYLE_SOLID = wxSOLID,
    wxBRUSHSTYLE_TRANSPARENT = wxTRANSPARENT,
    wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE = wxSTIPPLE_MASK_OPAQUE,
    wxBRUSHSTYLE_STIPPLE_MASK = wxSTIPPLE_MASK,
    wxBRUSHSTYLE_STIPPLE = wxSTIPPLE,
    wxBRUSHSTYLE_BDIAGONAL_HATCH = wxBDIAGONAL_HATCH,
    wxBRUSHSTYLE_CROSSDIAG_HATCH = wxCROSSDIAG_HATCH,
    wxBRUSHSTYLE_FDIAGONAL_HATCH = wxFDIAGONAL_HATCH,
    wxBRUSHSTYLE_CROSS_HATCH = wxCROSS_HATCH,
    wxBRUSHSTYLE_HORIZONTAL_HATCH = wxHORIZONTAL_HATCH,
    wxBRUSHSTYLE_VERTICAL_HATCH = wxVERTICAL_HATCH,
    wxBRUSHSTYLE_FIRST_HATCH = wxFIRST_HATCH,
    wxBRUSHSTYLE_LAST_HATCH = wxLAST_HATCH
};

#endif

//! Base class for all types of strokes, understood by a2dDrawer2D classes.
/*!
Any shape that needs to be stroked gets a a2dStroke derived class set for it.
The derived classes define the way the stroking is done.
The a2dCanvasView class needs to understand the different styles of stroking.

The stroke can be set to be of pixel type,
which means it is a fixed size in pixels.
Depending on the constructor used a pixel or non pixel stroke will be created.

    \ingroup property style
*/
class A2DARTBASEDLLEXP a2dStroke : public wxObject
{
#ifdef CLASS_MEM_MANAGEMENT

    //! memory manager for speed up to replace system calls allocation and deallocation
    static a2dMemManager sm_memManager;
public:
    //! overloaded operator new for this class and it all derived classes
    void* operator new( size_t bytes )
    {
        return sm_memManager.Allocate( bytes );
    }

    //! overloaded operator delete for this class and it all derived classes
    /*!
    This function doesn't free to OS-system memory block by pointer 'space'.
    It adds memory block by pointer 'space' to internal lists.
    It is speed up.
    */
    void operator delete( void *space, size_t bytes )
    {
        sm_memManager.Deallocate( space, bytes );
    }
#endif //CLASS_MEM_MANAGEMENT

public:

    //!constructor
    a2dStroke( void ); 

    a2dStroke( const wxColour& col, a2dStrokeStyle style = a2dSTROKE_SOLID );

    a2dStroke( const wxColour& col, double width, a2dStrokeStyle style = a2dSTROKE_SOLID );

    //!width defined in world coordinates.
    a2dStroke( const wxColour& col, int width, a2dStrokeStyle style = a2dSTROKE_SOLID );

    a2dStroke( const wxBitmap& stipple, a2dStrokeStyle style = a2dSTROKE_STIPPLE );

    a2dStroke( const wxBitmap& stipple, const wxColour& col, const wxColour& col2, a2dStrokeStyle style = a2dSTROKE_STIPPLE );

    a2dStroke( const wxFileName& filename, a2dStrokeStyle style = a2dSTROKE_STIPPLE );

    a2dStroke( const wxFileName& filename, const wxColour& col, const wxColour& col2, a2dStrokeStyle style = a2dSTROKE_STIPPLE );

    //!constructor
    a2dStroke( const a2dStroke& stroke );

    //!width gets defined in pixels.
    a2dStroke( const wxPen& stroke );

    //!destructor
    virtual ~a2dStroke( void );

    a2dStroke& UnShare();

    bool operator==(const a2dStroke& a)
    {
        return m_refData == a.m_refData;
    }

    bool operator!=(const a2dStroke& a)
    {
        return m_refData != a.m_refData;
    }

    friend inline bool operator==(const a2dStroke& a, const a2dStroke& b)
    {
        return a.m_refData == b.m_refData;
    }

    friend inline bool operator!=(const a2dStroke& a, const a2dStroke& b)
    {
        return a.m_refData != b.m_refData;
    }

    wxObjectRefData* CreateRefData() const;

    wxObjectRefData* CloneRefData(const wxObjectRefData * data) const;

    virtual a2dStrokeType GetType( void ) const;

    void SetStipple( const wxBitmap& stipple );

    const wxBitmap& GetStipple() const;

    //! return colour 1
    wxColour GetColour() const;

    //! set colour  used for gradient and wxSTROKE_MASK_OPAQUE filling.
    void SetColour( const wxColour& col );

    //! return colour 2
    wxColour GetColour2() const;

    //! set colour 2 used for gradient and wxSTROKE_MASK_OPAQUE filling.
    void SetColour2( const wxColour& col );

    void SetJoin( wxPenJoin join_style );

    void SetCap( wxPenCap cap_style );

    wxPenCap GetCap() const;

    wxPenJoin GetJoin() const;

    //!Set width of stroke in world coordinates.
    void SetWidth( float width );

    //!Get width of stroke in world or device coordinates.
    //!(depending on pixel or non pixel stroke).
    float GetWidth() const;
    float GetExtend() const;

    //!set pixelstoke flag, stroke width is defined in pixels else in worldcoordinates
    void SetPixelStroke( bool pixelstroke );

    //!if the width is pixels or not.
    bool GetPixelStroke() const;

    void SetAlpha( wxUint8 val );

    wxUint8 GetAlpha() const;

    a2dStrokeStyle GetStyle() const; 

    void SetStyle( a2dStrokeStyle style ); 

    //! used to define strokes that are not yielding (either need to be deleted, 
    //! or indicate that there is no stroke defined for an object.
    //! This is can be used on any stroke. This method, is handy since one can still clone
    //! such strokes.
    bool IsNoStroke() const { return m_refData == NULL; }

    //! from now one this object defines as if no stroke is defined of the object having this stroke.
    a2dStroke* SetNoStroke() { UnRef(); return this; }

    a2dStrokeType GetTypeForStyle( a2dStrokeStyle style ) const;

    DECLARE_DYNAMIC_CLASS( a2dStroke )

#if wxART2D_USE_CVGIO
    virtual void Load( wxObject* parent, a2dIOHandlerXmlSerIn& parser );
    virtual void Save( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO

};

//----------------------------------------------------------------------------
// a2dFont
//----------------------------------------------------------------------------

enum a2dFontType
{
    a2dFONT_NULL,
    a2dFONT_WXDC,
    a2dFONT_FREETYPE,
    a2dFONT_STROKED,
};

#if defined(__WXMSW__) 
#define __USE_WINAPI__
#endif

class a2dVertexList;
//! A list of pointers to vertexlists. Ends with NULL.
typedef a2dVertexList** a2dStrokeGlyph;

#if !wxART2D_USE_FREETYPE
// in case freetype is not used, define replacement types.
typedef void* FT_Glyph;
typedef void* FT_Vector;
typedef void* FT_Face;
typedef unsigned int FT_UInt;
#endif // wxART2D_USE_FREETYPE

//! wxChar hashing function, used in hash maps.
/*!
    \ingroup textrelated
*/
class A2DARTBASEDLLEXP a2dCharHash
{
public:
    a2dCharHash() { }
    unsigned long operator()( const wxChar& k ) const
        { return ( unsigned long ) k; }
    a2dCharHash& operator=( const a2dCharHash& ) { return * this; }
};
//! wxChar equality class, used in hash maps.
/*!
     \class a2dCharEqual stylebase.h artbase/stylebase.h
    \ingroup textrelated
*/
class A2DARTBASEDLLEXP a2dCharEqual
{
public:
    a2dCharEqual() { }
    bool operator()( const wxChar& a, const wxChar& b ) const
        { return ( a == b ); }
    a2dCharEqual& operator=( const a2dCharEqual& ) { return * this; }
};

//! holes one glyph from a freetype font.
struct A2DARTBASEDLLEXP a2dGlyph
{
    FT_UInt  m_index;
    FT_Glyph m_glyph;
    a2dGlyph()
    {
        m_index = ( FT_UInt ) - 1; m_glyph = NULL;
    }
    ~a2dGlyph()
    {
#if wxART2D_USE_FREETYPE
        if( m_glyph )
            FT_Done_Glyph( m_glyph );
#endif
    }
};

/*! \class FT_GlyphHash stylebase.h artbase/stylebase.h
    \brief A hash map, used for storage of freetype glyphs.
    \ingroup textrelated
*/
WX_DECLARE_HASH_MAP_WITH_DECL( wxChar, a2dGlyph, a2dCharHash, a2dCharEqual, a2dGlyphHash, class A2DARTBASEDLLEXP );


/*! \class DcWidthHash stylebase.h artbase/stylebase.h
    \brief A hash map, used for storage of character widths of a font
    \ingroup textrelated
*/
WX_DECLARE_HASH_MAP_WITH_DECL( wxChar, double, a2dCharHash, a2dCharEqual, DcWidthHash, class A2DARTBASEDLLEXP );

/*! \class DcKerningHash stylebase.h artbase/stylebase.h
    \brief A hash map, used for storage of kerning between characters of a font
    \ingroup textrelated
*/
WX_DECLARE_HASH_MAP_WITH_DECL( wxString, double, wxStringHash, wxStringEqual, DcKerningHash, class A2DARTBASEDLLEXP );

enum a2dFontAlignment
{
    // wxCENTRE
    wxMINX = wxLEFT,
    wxMAXX = wxRIGHT,
    wxMINY = wxBOTTOM,
    wxMAXY = wxTOP,
    wxBBOX = 0x100,
    a2dDEFAULT_ALIGNMENT = wxTOP | wxLEFT | wxBBOX
};

#define UNKNOWN_YAXIS 2

class a2dFont;

//! Font info class, used as a single element for enumerating fonts.
/*!
    The a2dFontInfo class is used as a font description class. Fonts can be generated from
    this. It is also used for saving and loading a font.
 
    This class consists of six items
    - type  currently "Device Font", "Freetype Font" or "Stroke Font", but more might be added in the future.
    - fontname: names like "Arial", "Courier New", etc.
    - style: Font type dependant, e.g. "Bold Italic" or "Pixel Stroke".
    - size: size in world coordinates.
    - extra: This is used for extra information, e.g. the filename of the font.
 
    When a font description in string form is needed call CreateString(). (or the other way with
    ParseString() ).
 
    This will create a string in the form of "[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]",  where 
    FAMILY-LIST is a comma separated list of families optionally terminated by a comma, 
    STYLE_OPTIONS is a whitespace separated list of words where each WORD describes one of 
    style, variant, weight, or stretch, and 
    SIZE is an decimal number (size in points). Any one of the options may be absent. 
    If FAMILY-LIST is absent, then the family_name field of the resulting font description will be 
    initialized to NULL. If STYLE-OPTIONS is missing, then all style options will be set to the 
    default values. If SIZE is missing, the size in the resulting font description will be set to 0.
    
    The string representation is compatible with the pango font descriptions.
 
    e.g.
    
    Freetype font,Arial Bold 10.0
    
    or just
    
    Arial Bold 10.0
    
    \ingroup style textrelated
*/
class A2DARTBASEDLLEXP a2dFontInfo
{
public:
    //! Constructor
    a2dFontInfo() {}
    //! Constructor
    a2dFontInfo( const wxString& type, const wxString& name, const wxString& style = wxT( "" ),
                 double size = 1.0, const wxString& extra = wxT( "" ) );
    //! Constructor
    a2dFontInfo( const wxString& type, const wxString& name,
                 const wxString& style, const wxString& extra = wxT( "" ) );
    //! Constructor
    a2dFontInfo( const wxString& info );

    //! Assignment operator.
    a2dFontInfo& operator=( const a2dFontInfo& other );

    //! Comparison operator.
    bool operator == ( const a2dFontInfo& other ) const;

    //! Create this enumerated font
    /*! This function will allways return a valid font. NULL will never be returned
    */
    a2dFont CreateFont( double size );

    //! Get type of font, e.g. Freetype or Stroke.
    inline const wxString& GetType() const { return m_type; }
    //! Set type of font, e.g. Freetype or Stroke.
    inline void SetType( const wxString& type ) { m_type = type; }

    //! Get name of font, e.g. Arial.
    inline const wxString& GetName() const { return m_name; }
    //! Set name of font, e.g. Arial.
    inline void SetName( const wxString& name ) { m_name = name; }

    //! Get style of font, e.g. Bold.
    inline const wxString& GetStyle() const { return m_style; }
    //! Set style of font, e.g. Bold.
    inline void SetStyle( const wxString& style ) { m_style = style; }

    //! Get size of the font.
    inline double GetSize() const { return m_size; }
    //! Set size of the font.
    inline void SetSize( double size ) { m_size = size; }

    //! Assemble a string containing this class in a readable format.
    wxString CreateString() const;

    //! Fill this class from a string.
    void ParseString( wxString string );

    //! Get the extra information ( e.g. the filename of the font )
    inline const wxString& GetExtra() const { return m_extra; }

    //! Set the extra information ( e.g. the filename of the font )
    inline void SetExtra( const wxString& extra ) { m_extra = extra; }

protected:
    //! Font type.
    wxString m_type;
    //! Font name.
    wxString m_name;
    //! Font style.
    wxString m_style;
    //! Font Size.
    double m_size;
    //! Extra information (e.g. the filename of the font).
    wxString m_extra;
};

/*! \class a2dFontInfoList stylebase.h artbase/stylebase.h
    \brief A list used for enumerating fonts.
    \sa a2dFontInfo
    \ingroup textrelated
*/
WX_DECLARE_LIST_WITH_DECL( a2dFontInfo, a2dFontInfoList, class A2DARTBASEDLLEXP );

//----------------------------------------------------------------------------
// a2dFont
//----------------------------------------------------------------------------

//! Defines a font to be set to a2dDrawer2D or stored in a2dCanvsObject etc.
/*!
    There are 3 types of fonts as in a2dFontType. The a2dDrawer2D classes know how to draw strings with these fonts.

    \ingroup style textrelated
*/
class A2DARTBASEDLLEXP a2dFont : public wxObject
{
public:

    a2dFontType GetType( void ) const; 

    //! Constructor.
    a2dFont();

    //! Copy constructor.
    a2dFont( const a2dFont& other );

    //! Constructor.
    /*! This constructor tries to locate the font file, belonging to the wxFont class, which
        is then used for drawing. At present only a Windows version is implemented.
        \param font Font format. The size of the font is not used and should be set using the next parameter.
        \param size Size in world coordinates.
        \param encoding endocing of font
    */
    a2dFont( const wxFont& font, double size, a2dFontType type = a2dFONT_WXDC, wxFontEncoding encoding = wxFONTENCODING_DEFAULT  );

    //! Constructor
    /*!
        Creates a font object (see font encoding overview, in the wxWidgets documentation, for the meaning of the last parameter).
        \param size Size in world coordinates.
        \param family Font family, a generic way of referring to fonts without specifying actual facename. One of:
            - wxDEFAULT  Chooses a default font.  
            - wxDECORATIVE  A decorative font.  
            - wxROMAN  A formal, serif font.  
            - wxSCRIPT  A handwriting font.  
            - wxSWISS  A sans-serif font.  
            - wxMODERN  A fixed pitch font.  
        \param style One of wxNORMAL, wxSLANT and wxITALIC.
        \param weight One of wxNORMAL, wxLIGHT and wxBOLD.
        \param underline The value can be true or false. At present this has an effect on Windows and Motif 2.x only.
        \param faceName An optional string specifying the actual typeface to be used. If the empty string, a default typeface will chosen based on the family.
        \param encoding An encoding which may be one of 
            - wxFONTENCODING_SYSTEM  Default system encoding.
            - wxFONTENCODING_DEFAULT  Default application encoding.
            - wxFONTENCODING_ISO8859_1...15  ISO8859 encodings.  
            - wxFONTENCODING_KOI8  The standard Russian encoding for Internet.  
            - wxFONTENCODING_CP1250...1252  Windows encodings similar to ISO8859 (but not identical).  

            If the specified encoding isn't available, no font is created. 
            
            wxFONTENCODING_DEFAULT is the encoding set by calls to SetDefaultEncoding and which 
            may be set to, say, KOI8 to create all fonts by default with KOI8 encoding. Initially, 
            the default application encoding is the same as default system encoding.          
        \remark 
            - If the desired font does not exist, the closest match will be chosen.
            - Under Windows, only scalable TrueType fonts are used.
    */
    a2dFont( double size, int family, int style = wxNORMAL, int weight = wxNORMAL,
               const bool underline = false, const wxString& faceName = wxT( "" ),
               wxFontEncoding encoding = wxFONTENCODING_DEFAULT );

    //! constructor of Freetype font based on filename of fontfile.
    a2dFont( const wxString& filename, double size = 0.0, wxFontEncoding encoding = wxFONTENCODING_DEFAULT, int weight = wxNORMAL );

    //! constructor of stroked font based on filename of fontfile. See a2dFontStrokeData
    a2dFont( const wxString& filename, double size, bool monoSpaced, double weight = 0.0 );

    //! Destructor.
    virtual ~a2dFont();

    //! return true if the same font (same reference)
    bool operator==(const a2dFont& a)
    {
        return m_refData == a.m_refData;
    }

    //! return true if not the same font (same reference)
    bool operator!=(const a2dFont& a)
    {
        return m_refData != a.m_refData;
    }

    //! return true if the same font (same reference)
    friend inline bool operator==(const a2dFont& a, const a2dFont& b)
    {
        return a.m_refData == b.m_refData;
    }

    //! return true if not the same font (same reference)
    friend inline bool operator!=(const a2dFont& a, const a2dFont& b)
    {
        return a.m_refData != b.m_refData;
    }

    //! Check font validity.
    /*! \return True if this object is a valid font, false otherwise.
    */
    bool Ok() const;

    //! Get fontinfo of the font
    const a2dFontInfo& GetFontInfo() const;

    //! Set the font size.
    /*! \param size Font size in world coordinates. */
    void SetSize( double size );

    //! Get the font size.
    /*! \return The font size in world coordinates */
    double GetSize() const;

    //! Get the line height.
    /*! The line height is calculated from the text bounding box.
        \return The line height in world coordinates.
    */
    double GetLineHeight() const;

    //! Get descent
    /*! The descent is the distance from the basline to the bottom of the bounding box.
        \return The descent in world coordinates.
    */
    double GetDescent() const;

    //! Get width of a single character
    double GetWidth( wxChar c );

    //! Get kerning space between two characters.
    /*! Kerning is a method, which moves characters closer together/further apart, to
        improve the look of the font. Eg. the letter combination LT will be moved closer together.
        The return value is negative or positive, to respectively move characters closer together, or further
        apart.
    */
    double GetKerning( wxChar WXUNUSED( c1 ), wxChar WXUNUSED( c2 ) ) const; 

    //! Get stroke width.
    /*!
        \return The stroke width in world coordinates. In case of a pixel font, 0.0 is returned.
        \sa GetWeight()
    */
    double GetStrokeWidth() const;

    //! Get the glyph of a single character.
    /*! \return The glyph of the character, in a coordinate space, normalized to the font size.
    */
    a2dStrokeGlyph GetGlyphStroke( wxChar c ) const;

    const a2dGlyph* GetGlyphFreetype( wxChar c ) const;

#if wxART2D_USE_FREETYPE && defined(__USE_WINAPI__)
    //! Get the freetype equivalent of the font
    a2dFont GetFreetypeFont();
#endif

    //! wxFont in case of a2dFONT_WXDC
    wxFont& GetFont( void );

    //! Get the dimensions in world coordinates of the string.
    /*! \param string The text string to measure (should be a single line of text).
        \param alignment Alignment of the text (eg. wxLEFT)
        \param yaxisdirection Direction of the y-axis. 0: Down, 1: Up, 2: Unknown.
        \param w Total width in world coordinates.
        \param h Total height in world coordinates.
        \param descent The dimension from the baseline of the font to the bottom of the descender in
         world coordinates.
        \param externalLeading Any extra vertical space added to the font by the font designer in
            world coordinates (usually is zero).
        \return A bounding box, with the anchor point positioned at (0, 0).
    */
    a2dBoundingBox GetTextExtent( const wxString& string, int yaxisdirection,
                                  int alignment = wxLEFT | wxTOP | wxBBOX,  double* w = NULL,
                                  double* h = NULL, double* descent = NULL,
                                  double* externalLeading = NULL ) const;

    //! Get the dimensions in world coordinates of the string.
    /*! \param string The text string to measure (should be a single line of text).
        \param w Total width in world coordinates.
        \param h Total height in world coordinates.
        \param descent The dimension from the baseline of the font to the bottom of the descender in
         world coordinates.
        \param externalLeading Any extra vertical space added to the font by the font designer in
            world coordinates (usually is zero).
    */
    void GetTextExtent( const wxString& string, double& w, double& h,
                                double& descent, double& externalLeading ) const;

    //! Get the dimensions in world coordinates of the string.
    /*! \param string The text string to measure (should be a single line of text).
        \param w Total width in world coordinates.
        \param h Total height in world coordinates.
    */
    void GetTextExtentWH( const wxString& string, double& w, double& h ) const;

    bool GetPartialTextExtents  ( const wxString &  text,  wxArrayInt &  widths  )   const; 

    //! Get the glyph of a single character as a vpath.
    /*!  The position, indicated by x and y, is the lowerleft bbox corner of the glyph.
        \param c The character.
        \param glyph A vectorpath, to which the glyph is added.
        \param affine Position etc., where the glyph is constructed.
        \return A boolean, indicating if the glyph was succesfully added.
    */
    bool GetVpath( wxChar c, a2dVpath& glyph, const a2dAffineMatrix& affine = a2dIDENTITY_MATRIX );

    //! Render a text string into a vector path
    /*!  The position, indicated by x and y, is the lowerleft bbox corner of the text.
        \param text The string to render.
        \param vpath The vectorpath, to which the string is rendered
        \param x Position, where the string is constructed.
        \param y Position, where the string is constructed.
        \param alignment how to position text relative top position
        \param yaxis up or down text
        \param affine Position etc., where the text is constructed.
    */
    void GetVpath( const wxString& text, a2dVpath& vpath, double x = 0, double y = 0, int alignment = wxLEFT | wxTOP | wxBBOX, bool yaxis = true, const a2dAffineMatrix& affine = a2dIDENTITY_MATRIX );

    // Documented in base class
    bool AlwaysWriteSerializationId() const { return true; }

    //! Append fonts of this type to the list
    /*! Using a2dFont::GetInfoList(list), will enumerate all fonts, of all types
    */
    static void GetInfoList( a2dFontInfoList& list );

    //! Create the font from a fontinfo description.
    /*! The a2dFont::CreateFont will allways return a valid font. The derived fonts should
        return NULL.
        
        This routine will first try to find the exact font, as described in the fontinfo. If it does
        not find this font, it will try to create any font of any font type, that matches part of the 
        string. eg. if a user asks for a dc-font called "Arial Black" and this is not installed on the
        system, this routine might return as a replacement a freetype-font called "Arial".

        \param info font info for creating font
        \param force This param does not have a function in a2dFont, but it should be used in
            its descendants. When force is false, only the exact match should be made. When true, the
            routine should try to match any likely candidate.
    */
    static a2dFont CreateFont( const a2dFontInfo& info, bool force = false );

    //! Create a string description of the font.
    /*! \return A string of the format type-name-style-size-alignment(-extra)
    */
    wxString CreateString(); 

    //! create a unique string presenting a a2dFONT_FREETYPE type font (see constructor for parameters)
    static wxString CreateString( const wxString& filename, double size, wxFontEncoding encoding, int weight );
    //! create a unique string presenting a a2dFONT_STROKED type font (see constructor for parameters)
    static wxString CreateString( const wxString& filename, double size, bool monoSpaced, double weight );
    //! create a unique string presenting a a2dFONT_WXDC type font (see constructor for parameters)
    static wxString CreateString( a2dFontType type, const wxFont& font, double size, wxFontEncoding encoding );

    //! Set the font filename and load the font.
    /*! \param filename The filename of the font. This may either be a full path, or just the
        fontname. In the latter case, the fontpath of a2dGlobals will be used to search the font.
        \sa a2dGlobal
    */
    void SetFilename( const wxString& filename );
    //! Get the font filename.
    /*! \param filenameonly The returned filename will be stripped of drive-letters and directories.
        \return The filename of the font.
    */
    wxString GetFilename( bool filenameonly = false ) const;

    //! Get the weight of the font.
    /*! \return The weight (in this case stroke width) in percentages of the font size. There are two exceptions.
        0: Draws the font with a pen of 1 pixel wide. -1: Draws the font with a normalized pen, as the font-designer intended it.
    */
    double GetWeight() const;

    //! Set the weight of the font.
    /*! \param weight The weight (in this case stroke width) in percentages of the font size. There are two exceptions.
        0: Draws the font with a pen of 1 pixel wide. -1: Draws the font with a normalized pen, as the font-designer intended it.
    */
    void SetWeight( double weight );

    //! Set the weight of the font, from a string.
    /*! \param weight One of: "Normalized Pen", "Pixel pen" or a string starting with the width in percentages, ending with %.
    */
    void SetWeight( const wxString& weight );

    wxObjectRefData* CreateRefData() const;

    wxObjectRefData* CloneRefData(const wxObjectRefData * data) const;

#if wxART2D_USE_CVGIO
private:
    // Not implemented anymore, please use ...
    virtual void Load( wxObject* WXUNUSED( parent ), a2dIOHandlerXmlSerIn& WXUNUSED( parser ), a2dXmlSer_flag WXUNUSED( xmlparts ) ) {}
    virtual void Save( wxObject* WXUNUSED( parent ), a2dIOHandlerXmlSerOut &WXUNUSED( out ), a2dXmlSer_flag WXUNUSED( xmlparts ) , a2dObjectList* WXUNUSED( towrite ) ) {}
#endif //wxART2D_USE_CVGIO

public:
private:
    DECLARE_ABSTRACT_CLASS( a2dFont )

    static void ClearFontCache() { ms_fontCache.clear(); }

    static map< wxString, a2dFont > ms_fontCache;
};


/******************************************************************************
    predefined style properties
*******************************************************************************/

//! several predefined style properties
/*! stock style objects
    \defgroup stockobjects predefined StyleProperties  
 
    \ingroup property style
*/

//! global a2dFill stock object for WHITE filling
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFill* )    a2dWHITE_FILL;

//! global a2dFill stock object for BLACK filling
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFill* )    a2dBLACK_FILL;

//! global a2dFill stock object for TRANSPARENT filling
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFill* )    a2dTRANSPARENT_FILL;

//! global a2dFill stock object for INHERTED from parent object filling
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFill* )    a2dINHERIT_FILL;

//! global a2dFill stock object for drawing fill of selected objects
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFill* )    a2dSELECT_FILL;

//! global a2dFill stock object for defining NO filling  
/*! If an a2dCanvasObject's fill is set to a2dNullFILL, it will use the layer
fill, if there is one. If you want to make sure, that no fill is used,
use a2dTRANSPARENT_FILL
\ingroup stockobjects */
A2DARTBASEDLLEXP_DATA(extern const a2dFill* )    a2dNullFILL;

//! global a2dStroke stock object for BLACK stroking
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dStroke* )    a2dBLACK_STROKE;

//! global a2dStroke stock object for WHITE stroking
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dStroke* )    a2dWHITE_STROKE;

//! global a2dStroke stock object for TRANSPARENT stroking
/*! \see wxNullStroke \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dStroke* )    a2dTRANSPARENT_STROKE;

//! global a2dStroke stock object for INHERTED from parent object stroking
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dStroke* )    a2dINHERIT_STROKE;

//! global a2dStroke stock object for NO stroking  
/*! If an a2dCanvasObject's stroke is set to a2dNullSTROKE, it will use the layer
stroke, if there is one. If you want to make sure, that no stroke is used,
use a2dTRANSPARENT_STROKE
\ingroup stockobjects */
A2DARTBASEDLLEXP_DATA(extern const a2dStroke*)    a2dNullSTROKE;

//! global a2dStroke stock object for SELECTED object stroking
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dStroke*)    a2dLAYER_SELECT_STROKE;

//! global a2dFont stock object for NO font
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFont* )    a2dNullFONT;

//! global a2dFont stock object for default font
/*! \ingroup stockobjects */
A2DARTBASEDLLEXP_DATA( extern const a2dFont* )    a2dDEFAULT_CANVASFONT;

//! to initialize stock style ( a2dStroke a2dFill ) objects.
/*!
  \sa  a2dCanvasModule
 
  \ingroup stockobjects 
 
*/
extern A2DARTBASEDLLEXP void a2dCanvasInitializeStockObjects ();

//! to delete stock style ( a2dStroke a2dFill ) objects.
/*!
    \sa  a2dCanvasModule
 
    \ingroup stockobjects 
*/
extern A2DARTBASEDLLEXP void a2dCanvasDeleteStockObjects ();

//!initiates Freetype library
class A2DARTBASEDLLEXP a2dFreetypeModule : public wxModule
{
public:

    a2dFreetypeModule();

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

private:

    DECLARE_DYNAMIC_CLASS( a2dFreetypeModule )
};


class A2DGENERALDLLEXP a2dFillProperty;
typedef a2dPropertyIdTyped< a2dFill, a2dFillProperty>  a2dPropertyIdFill;


//! property to hold a a2dFill type variable to be associated with a a2dPropObject
/*!
    \ingroup property
*/
class A2DGENERALDLLEXP a2dFillProperty: public a2dNamedProperty
{
public:

    a2dFillProperty();

    a2dFillProperty( const a2dPropertyIdFill* id, const a2dFill& value );

    a2dFillProperty( const a2dFillProperty* ori );

    a2dFillProperty(const a2dFillProperty &other );

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

    virtual void Assign( const a2dNamedProperty &other );

    virtual ~a2dFillProperty();

    //! Construct a new property object from a string
    //! If this is not appropriate, this may return NULL
    static a2dFillProperty *CreatePropertyFromString( const a2dPropertyIdFill* id, const wxString &value );

    void SetValue( const a2dFill& value );

    const a2dFill& GetValue() const { return m_value; }

    virtual wxString StringRepresentation() const;

    virtual wxString StringValueRepresentation() 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

    DECLARE_DYNAMIC_CLASS(a2dFillProperty)

protected:

    a2dFill m_value;
};

class A2DGENERALDLLEXP a2dStrokeProperty;
typedef a2dPropertyIdTyped< a2dStroke, a2dStrokeProperty>  a2dPropertyIdStroke;


//! property to hold a a2dStroke type variable to be associated with a a2dPropObject
/*!
    \ingroup property
*/
class A2DGENERALDLLEXP a2dStrokeProperty: public a2dNamedProperty
{
public:

    a2dStrokeProperty();

    a2dStrokeProperty( const a2dPropertyIdStroke* id, const a2dStroke& value );

    a2dStrokeProperty( const a2dStrokeProperty* ori );

    a2dStrokeProperty(const a2dStrokeProperty &other );

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

    virtual void Assign( const a2dNamedProperty &other );

    virtual ~a2dStrokeProperty();

    //! Construct a new property object from a string
    //! If this is not appropriate, this may return NULL
    static a2dStrokeProperty *CreatePropertyFromString( const a2dPropertyIdStroke* id, const wxString &value );

    void SetValue( const a2dStroke& value );

    const a2dStroke& GetValue() const { return m_value; }

    virtual wxString StringRepresentation() const;

    virtual wxString StringValueRepresentation() 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

    DECLARE_DYNAMIC_CLASS(a2dStrokeProperty)

protected:

    a2dStroke m_value;
};

class A2DGENERALDLLEXP a2dFontProperty;
typedef a2dPropertyIdTyped< a2dFont, a2dFontProperty>  a2dPropertyIdFont;


//! property to hold a a2dFont type variable to be associated with a a2dPropObject
/*!
    \ingroup property
*/
class A2DGENERALDLLEXP a2dFontProperty: public a2dNamedProperty
{
public:

    a2dFontProperty();

    a2dFontProperty( const a2dPropertyIdFont* id, const a2dFont& value );

    a2dFontProperty( const a2dFontProperty* ori );

    a2dFontProperty(const a2dFontProperty &other );

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

    virtual void Assign( const a2dNamedProperty &other );

    virtual ~a2dFontProperty();

    //! Construct a new property object from a string
    //! If this is not appropriate, this may return NULL
    static a2dFontProperty *CreatePropertyFromString( const a2dPropertyIdFont* id, const wxString &value );

    void SetValue( const a2dFont& value );

    const a2dFont& GetValue() const { return m_value; }

    virtual wxString StringRepresentation() const;

    virtual wxString StringValueRepresentation() 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

    DECLARE_DYNAMIC_CLASS(a2dFontProperty)

protected:

    a2dFont m_value;
};

#endif /* __STYLEBASE_H__ */

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