gls_metadata_attributes.h

Go to the documentation of this file.

/*! \file
  \brief  Defines templated metadata classes for DisplayObjects and other uses.

  \par Copyright Information

  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef INCLUDED_GLS_METADATA_ATTRIBUTES_H
#define INCLUDED_GLS_METADATA_ATTRIBUTES_H

#include "display.h"
#include "disti_metadata.h"
#include "dynamic_array.h"
#include "gls_include.h"
#include "list.h"
#include "material.h"
#include "util.h"
#include "vertex.h"

#include <cassert>
#include <climits>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sstream>
#ifdef __VXWORKS__
#    include <ctype.h>
#else
#    include <cctype>
#endif



#ifdef DISTI_HAS_CPP11
#    include <functional>
#endif

namespace disti
{

const DistiAttributeBase::CallbackID  DISTI_INVALID_CALLBACK_ID = ~0u;

// Force the attribute classes to be instanciated
// so that they will be exported from the dll
// NOTE: These are not necessary if the class is instanciated or specialized elsewhere - BB
//template class DistiAttribute<unsigned char>;

// DistiAttribute<bool> Specialization
template<>
inline long DistiAttribute<bool>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<bool>::ValueInt( long val )
{
    *_attribPtr = ( val != 0 );
    CallCallback();
}

template<>
inline std::ostream& DistiAttribute<bool>::WriteValue( std::ostream& outstr )
{
    outstr << *_attribPtr;

    return outstr;
}

// helper function used to remove converting int to bool performance warning on certain compilers
template<class T>
T ConvertToIntOrBool( int value )
{
    return value;
}
template<>
inline bool ConvertToIntOrBool( int value )
{
    return value != 0;
}

template<class T>
T ReadValueAsIntOrBool( std::istream& instr )
{
    std::string value;
    instr >> value;
    T temp;
    if( strcasecmp( value.c_str(), "TRUE" ) == 0 )
    {
        temp = true;
    }
    else if( strcasecmp( value.c_str(), "FALSE" ) == 0 )
    {
        temp = false;
    }
    else
    {
        // Check based on an integer value
        temp = ConvertToIntOrBool<T>( atoi( value.c_str() ) );
    }
    return temp;
}

template<>
inline std::istream& DistiAttribute<bool>::ReadValue( std::istream& instr )
{
    *_attribPtr = ReadValueAsIntOrBool<bool>( instr );
    CallCallback();
    return instr;
}

// DistiAttribute<int> Specialization
template<>
inline long DistiAttribute<int>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<int>::ValueInt( long val )
{
    *_attribPtr = (int)val;
    CallCallback();
}

// DistiAttribute<short> Specialization
template<>
inline long DistiAttribute<short>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<short>::ValueInt( long val )
{
    *_attribPtr = (short)val;
    CallCallback();
}

// DistiAttribute<unsigned short> Specialization
template<>
inline long DistiAttribute<unsigned short>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<unsigned short>::ValueInt( long val )
{
    *_attribPtr = (unsigned short)val;
    CallCallback();
}

// DistiAttribute<unsigned char> Specialization
template<>
inline long DistiAttribute<unsigned char>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<unsigned char>::ValueInt( long val )
{
    *_attribPtr = (unsigned char)val;
    CallCallback();
}

template<>
inline std::ostream& DistiAttribute<unsigned char>::WriteValue( std::ostream& outstr )
{
    // If we don't cast to int, an actual character will be written.  We want a number.
    outstr << (int)*_attribPtr;
    return outstr;
}

template<>
inline std::istream& DistiAttribute<unsigned char>::ReadValue( std::istream& instr )
{
    // If we don't cast to int, an actual character will be read.  We want a number.
    // Also, integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = static_cast<unsigned char>( ReadValueAsIntOrBool<int>( instr ) );
    CallCallback();
    return instr;
}

template<>
inline std::istream& DistiAttribute<int>::ReadValue( std::istream& instr )
{
    // integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = ReadValueAsIntOrBool<int>( instr );
    CallCallback();
    return instr;
}

template<>
inline std::istream& DistiAttribute<unsigned int>::ReadValue( std::istream& instr )
{
    // integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = ReadValueAsIntOrBool<unsigned int>( instr );
    CallCallback();
    return instr;
}

// DistiAttribute<float> Specialization
template<>
inline long DistiAttribute<float>::ValueInt() { return (long)*_attribPtr; }

template<>
inline void DistiAttribute<float>::ValueInt( long val )
{
    *_attribPtr = (float)val;
    CallCallback();
}

/** Special case for transitioning from a bool to an int
  * Reads True or False, or integers.
  * Writes only integers. 
  */
class DistiAttributeUCharOrBool : public DistiAttribute<unsigned char>
{
public:
    GLS_EXPORT DistiAttributeUCharOrBool( CallbackMethodCallerBase* callback, const AttributeName& name, unsigned char* attribPtr );
    GLS_EXPORT DistiAttributeUCharOrBool( CallbackMethodCallerBase* callback, const AttributeName& name, unsigned char value );

    virtual GLS_EXPORT DistiAttributeBase& operator=( const DistiAttributeBase& oldClass );

    virtual GLS_EXPORT long ValueInt();
    virtual GLS_EXPORT void ValueInt( long val );

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** For fixed length float arrays
  */
class DistiAttributeFloatArray : public DistiAttributeBase
{
    float* _array;
    int    _length;

public:
    GLS_EXPORT DistiAttributeFloatArray( CallbackMethodCallerBase* callback, const AttributeName& name, float* floatArray, int length );
    virtual GLS_EXPORT ~DistiAttributeFloatArray();

    virtual GLS_EXPORT bool OkToWrite() const;

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** For fixed length double arrays
  */
class DistiAttributeDoubleArray : public DistiAttributeBase
{
    double* _array;
    int     _length;

public:
    GLS_EXPORT DistiAttributeDoubleArray( CallbackMethodCallerBase* callback, const AttributeName& name, double* doubleArray, int length );
    virtual GLS_EXPORT ~DistiAttributeDoubleArray();

    virtual GLS_EXPORT bool OkToWrite() const;

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** An enumeration for Texture Mode */
static DistiAttributeEnumDefList TextureModeEnumList(
    (char*)"TEXTURE_MAP_MODULATE", TEXTURE_MAP_MODULATE,
    (char*)"TEXTURE_MAP_DECAL", TEXTURE_MAP_DECAL,
    (char*)"TEXTURE_MAP_BLEND", TEXTURE_MAP_BLEND,
    (char*)"TEXTURE_MAP_REPLACE", TEXTURE_MAP_REPLACE,
    NULL );

/** Disti Attribute Texture Mode Enum */
template<class containerClass>
class DistiAttributeTextureModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeTextureModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &TextureModeEnumList;
    }
};

/** An enumeration for Texture Filter */
static DistiAttributeEnumDefList TextureFilterEnumList(
    (char*)"TEXTURE_FILTER_NEAREST", TEXTURE_FILTER_NEAREST,
    (char*)"TEXTURE_FILTER_LINEAR", TEXTURE_FILTER_LINEAR,
    (char*)"TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST", TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST,
    (char*)"TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR", TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR,
    (char*)"TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR", TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR,
    (char*)"TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST", TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST,
    NULL );

/** Disti Attribute Texture Filter Enum */
template<class containerClass>
class DistiAttributeTextureFilterEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeTextureFilterEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &TextureFilterEnumList;
    }
};

/** An enumeration for Polygon Mode */
static DistiAttributeEnumDefList PolyModeEnumList(
    (char*)"POLY_MODE_UNDEFINED", POLY_MODE_UNDEFINED,
    (char*)"POLY_MODE_POINTS", POLY_MODE_POINTS,
    (char*)"POLY_MODE_OUTLINE", POLY_MODE_OUTLINE,
    (char*)"POLY_MODE_FILLED", POLY_MODE_FILLED,
    (char*)"POLY_MODE_FILL_AND_OUTLINE", POLY_MODE_FILL_AND_OUTLINE,
    NULL );

/** Disti Attribute Poly Mode Enum */
template<class containerClass>
class DistiAttributePolyModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributePolyModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &PolyModeEnumList;
    }
};

/** An enumeration for Polygon End Mode */
static DistiAttributeEnumDefList PolyEndEnumList(
    (char*)"POLY_OPEN", POLY_OPEN,
    (char*)"POLY_CLOSED", POLY_CLOSED,
    NULL );

/** Disti Attribute Poly End Enum */
template<class containerClass>
class DistiAttributePolyEndEnum : public DistiAttributeEnum<containerClass, int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributePolyEndEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &PolyEndEnumList;
    }
};

/** An enumeration for Shading enum */
static DistiAttributeEnumDefList ShadingEnumList(
    (char*)"FLAT", SHADING_FLAT,
    (char*)"GOURAUD", SHADING_GOURAUD,
    NULL );

/** Disti Attribute Shading Enum */
template<class containerClass>
class DistiAttributeShadingEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeShadingEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &ShadingEnumList;
    }
};

/** An enumeration for ColorMaterialMode enum */
template<class containerClass>
class DistiAttributeColorMaterialModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeColorMaterialModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        static DistiAttributeEnumDefList ColorMaterialModeEnum(
            (char*)"NO_COLOR_MATERIAL", NO_COLOR_MATERIAL,
            (char*)"DIFFUSE_COLOR_MATERIAL", DIFFUSE_COLOR_MATERIAL,
            (char*)"AMBIENT_COLOR_MATERIAL", AMBIENT_COLOR_MATERIAL,
            (char*)"DIFFUSE_AND_AMBIENT_COLOR_MATERIAL", DIFFUSE_AND_AMBIENT_COLOR_MATERIAL,
            (char*)"EMISSION_COLOR_MATERIAL", EMISSION_COLOR_MATERIAL,
            (char*)"SPECULAR_COLOR_MATERIAL", SPECULAR_COLOR_MATERIAL,
            NULL );

        _pairList = &ColorMaterialModeEnum;
    }

    virtual GLS_EXPORT bool OkToWrite() const { return false; }
};

/** An enumeration for Protection */
template<class containerClass>
class DistiAttributeProtectionEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeProtectionEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        static DistiAttributeEnumDefList ProtectionEnumList(
            (char*)"PUBLIC", PUBLIC,
            (char*)"PRIVATE", PRIVATE,
            (char*)"PROTECTED", PROTECTED,
            NULL );
        _pairList = &ProtectionEnumList;
    }
};

/** An enumeration for Alpha Mode */
static DistiAttributeEnumDefList AlphaModeEnumList(
    (char*)"ALPHA_MODE_UNDEFINED", ALPHA_MODE_UNDEFINED,
    (char*)"ALPHA_MODE_OPAQUE", ALPHA_MODE_OPAQUE,
    (char*)"ALPHA_MODE_2_LEVEL", ALPHA_MODE_2_LEVEL,
    (char*)"ALPHA_MODE_256_LEVEL", ALPHA_MODE_256_LEVEL,
    NULL );

/** Disti Attribute Alpha Mode Enum */
template<class containerClass>
class DistiAttributeAlphaModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass;
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;
    using BaseClass::_pairList;

    typedef void ( containerClass::*SetMethodType )( const int );
    typedef int ( containerClass::*GetMethodType )();

    DistiAttributeAlphaModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &AlphaModeEnumList;
    }
};

/** An attribute for a char* string
  */
class DistiAttributeString : public DistiAttributeBase
{
    char* _local;

protected:
    char** _attribPtr;

public:
    // This constructor makes the bold assumption that it can modify the contents
    // of the supplied char*, by realocating the memory.
    GLS_EXPORT DistiAttributeString( CallbackMethodCallerBase* callback, const AttributeName& name, char** attribPtr );

    // Creates local storage, and will resize as needed
    GLS_EXPORT DistiAttributeString( CallbackMethodCallerBase* callback, const AttributeName& name, char* initialValue );
    virtual GLS_EXPORT ~DistiAttributeString();

    // Be careful with this
    GLS_EXPORT char*        LocalStorageString();
    virtual GLS_EXPORT bool OkToWrite() const;

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Derived from DistiAttributeString, the only difference is that it 
  * reads and writes encoded strings instead of clear strings.
  */
class DistiAttributeEncodedString : public DistiAttributeString
{
public:
    GLS_EXPORT DistiAttributeEncodedString( CallbackMethodCallerBase* callback, const AttributeName& name, char** attribPtr );

    // Creates local storage, and will resize as needed
    GLS_EXPORT DistiAttributeEncodedString( CallbackMethodCallerBase* callback, const AttributeName& name, char* initialValue );

    // Normally ValueString just returns the value of WriteValue, but for encoded strings
    // this is probably not what we want, so have ValueString work with the unencoded string
    virtual GLS_EXPORT std::string ValueString();
    virtual GLS_EXPORT void        ValueString( const std::string& s );

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Derived from DistiAttributeStdString, the only difference is that it 
  * reads and writes encoded strings instead of clear strings.
  */
class DistiAttributeEncodedStdString : public DistiAttribute<std::string>
{
public:
    GLS_EXPORT DistiAttributeEncodedStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string* attribPtr );

    // Creates local storage, and will resize as needed
    GLS_EXPORT DistiAttributeEncodedStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string initialValue );

    GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;

    // Normally ValueString just returns the value of WriteValue, but for encoded strings
    // this is probably not what we want, so have ValueString work with the unencoded string
    GLS_EXPORT std::string ValueString() DISTI_METHOD_OVERRIDE;
    GLS_EXPORT void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE;

    GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
/** For fixed length char array */
class DistiAttributeFixedString : public DistiAttributeBase
{
    char* _string;
    int   _length;

public:
    GLS_EXPORT DistiAttributeFixedString( CallbackMethodCallerBase* callback, const AttributeName& name, char* string, int length );
    virtual GLS_EXPORT ~DistiAttributeFixedString();

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Attribute for std::string */
class DistiAttributeStdString : public DistiAttribute<std::string>
{
    std::string _localStorageString;

public:
    // This constructor has the storage external
    GLS_EXPORT DistiAttributeStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string* attribPtr );

    // Creates local storage, and will resize as needed
    GLS_EXPORT DistiAttributeStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string initialValue );
    virtual GLS_EXPORT ~DistiAttributeStdString();

    // Be carefull with this
    GLS_EXPORT std::string* LocalStorageString();

    virtual GLS_EXPORT bool OkToWrite() const;

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Attribute for Location */
class DistiAttributeLocation : public DistiAttribute<Vertex>
{
public:
    GLS_EXPORT DistiAttributeLocation( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex* attribPtr );
    virtual GLS_EXPORT ~DistiAttributeLocation();

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Attribute for a dictionary of attributes */
class DistiAttributeDictionaryAttribute : public DistiAttributeBase
{
protected:
    DistiAttribDict* _dict;

public:
    GLS_EXPORT DistiAttributeDictionaryAttribute( const AttributeName& name, DistiAttribDict* dict );

    virtual GLS_EXPORT bool OkToWrite() const;

    virtual void       Add( DistiAttributeBase* attr ) { _dict->Add( attr ); }
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

/** Attribute for a dictionary of attributes that cares for its siblings */
class DistiAttributeDictionaryAttributeSibling : public DistiAttributeBase
{
protected:
    DistiAttribDict*    _dict;
    DistiAttributeBase* _sibling;
    bool                _hasRead;

public:
    GLS_EXPORT DistiAttributeDictionaryAttributeSibling( const AttributeName& name, DistiAttribDict* dict, DistiAttributeBase* sibling );

    virtual GLS_EXPORT bool OkToWrite() const;

    virtual void       Add( DistiAttributeBase* attr ) { _dict->Add( attr ); }
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr );
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
/** \class DistiAttributeStdMap
  * An attribute for a std::map
  */
template<class Map_t>
class DistiAttributeStdMap : public DistiAttributeBase
{
    Map_t* _attribPtr;

public:
    //------------------------------------------------------------------------
    DistiAttributeStdMap(
        CallbackMethodCallerBase* callback, const AttributeName& name, Map_t* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }
    //------------------------------------------------------------------------
    DistiAttributeStdMap( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Map_t() )
    {
    }
    //------------------------------------------------------------------------
    virtual ~DistiAttributeStdMap()
    {
        if( _localStorage )
            delete _attribPtr;
        _attribPtr = NULL;
    }
    //------------------------------------------------------------------------
    virtual bool OkToWrite() const
    {
        return _attribPtr != 0 && _attribPtr->size();
    }
    //------------------------------------------------------------------------
    static std::string GetEmptyValue() { return "$$DISTI_EMPTY$$"; }
    //------------------------------------------------------------------------
    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        outstr << "\n"
               << DistiAttribDict::SpacingString() << "{\n";
        DistiAttribDict::SpacingInc();

        if( _attribPtr )
        {
            typename Map_t::iterator i;
            for( i = _attribPtr->begin(); i != _attribPtr->end(); ++i )
            {
                std::ostringstream str;
                str << i->second;
                const std::string second = str.str();

                outstr << DistiAttribDict::SpacingString() << i->first << " "
                       << ( second.empty() ? GetEmptyValue() : second ) << '\n';
            }
        }

        DistiAttribDict::SpacingDec();
        outstr << DistiAttribDict::SpacingString() << "}\n";

        return outstr;
    }
    //------------------------------------------------------------------------
    virtual std::istream& ReadValue( std::istream& instr )
    {
        instr.ignore( INT_MAX, '{' );

        if( instr.good() )
        {
            std::stringstream fontStream;
            instr.get( *fontStream.rdbuf(), '}' );
            if( instr.good() )
            {
                instr.ignore( 1 );
                while( fontStream.good() )
                {
                    // Get rid of all the leading white space before reading the key
#ifdef _WIN32
                    std::stringstream::char_type c;
#else
                    // std::stringstream::char_type c; causes a parse error before `;' on Linux
                    char c;
#endif
                    do
                    {
                        fontStream.get( c );
                    } while( fontStream.good() && isspace( c ) );

                    if( fontStream.good() )
                    {
                        fontStream.putback( c );

#if _WIN32 && _MSC_VER < 1300 // if _MSC_VER < vc70
                        Map_t::key_type      key;
                        Map_t::referent_type value;
#else
                        typename Map_t::key_type    key;
                        typename Map_t::mapped_type value;
#endif
                        std::string strVal;
                        fontStream >> key;
                        std::getline( fontStream >> std::ws, strVal );

                        if( strVal != GetEmptyValue() )
                        {
                            std::istringstream str( strVal );
                            str >> value;
                        }

                        ( *_attribPtr )[ key ] = value;
                    }
                }
            }
        }
        return instr;
    }
}; // end DistiAttributeStdMap

/** \class DistiAttributeVertexArray
  * An attribute for either a Vector or Vertex 
  */
template<class T> // Either Vector or Vertex
class DistiAttributeVertexArray : public DistiAttributeBase
{
protected:
    T**           _attribPtr;
    typedef T*    Tptr;
    unsigned int* _numVertices;
    unsigned int  _numElements;
    bool          _fixedArray;
    bool          _compatabilityMode;

public:
    void SetCompatabilityMode( bool mode ) { _compatabilityMode = mode; }
    // For variable length arrays
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, T** attribPtr, unsigned int* numVertices )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _numVertices( numVertices )
        , _numElements( 0 )
        , _fixedArray( false )
    {
        _compatabilityMode = true;
    }
    // For fixed arrays
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr, unsigned int numElements )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Tptr( attribPtr ) )
        , _numVertices( NULL )
        , _numElements( numElements )
        , _fixedArray( true )
    {
        _compatabilityMode = true;
    }

    virtual ~DistiAttributeVertexArray()
    {
        if( ( _fixedArray || _localStorage ) && _attribPtr )
            delete _attribPtr;
        _attribPtr = NULL;
    }

    virtual bool OkToWrite() const
    {
        return ( *_attribPtr != NULL );
    }

    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        if( *_attribPtr != NULL )
        {
            unsigned int numVerts = _numElements;
            if( !_fixedArray )
            {
                outstr << *_numVertices;
                numVerts = *_numVertices;
            }
            DistiAttribDict::SpacingInc();
            for( unsigned int i = 0; i < numVerts; i++ )
            {
                outstr << '\n';
                outstr << ( *_attribPtr )[ i ];
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
    virtual std::istream& ReadValue( std::istream& instr )
    {
        unsigned int numVerts = _numElements;

        if( !_fixedArray )
        {
            instr >> numVerts;
            *_numVertices = numVerts;

            // Remove old storage if any
            if( *_attribPtr != NULL )
                delete[] * _attribPtr;

            // Create new storage
            if( numVerts > 0 )
                *_attribPtr = new T[ numVerts ];
            else
                *_attribPtr = NULL;
        }

        if( !_compatabilityMode )
        {
            char buf[ 1024 ];
            // Get newline character
            instr.getline( buf, 1024 );
        }

        for( unsigned int i = 0; i < numVerts; i++ )
        {
            if( !_compatabilityMode )
            {
                char buf[ 1024 ];
                instr.getline( buf, 1024 );
#ifdef GLS_DEBUG
                int count =
#endif
                    std::sscanf( buf, "%f %f %f",
                        &( ( *_attribPtr )[ i ].x ),
                        &( ( *_attribPtr )[ i ].y ),
                        &( ( *_attribPtr )[ i ].z ) );
#ifdef GLS_DEBUG
                assert( 3 == count );
#endif
            }
            else
            {
                instr >> ( *_attribPtr )[ i ];
            }
        }
        CallCallback();
        return instr;
    }

    virtual bool operator==( const DistiAttributeBase& rArg )
    {
        DistiAttributeVertexArray<T>* r = dynamic_cast<DistiAttributeVertexArray<T>*>( const_cast<DistiAttributeBase*>( &rArg ) );
        if( !r )
        {
            return DistiAttributeBase::operator==( rArg );
        }

        if( !( _name == r->_name ) || _numElements != r->_numElements )
            return false;

        for( unsigned int i = 0u; i < _numElements; ++i )
        {
            T leftVert  = ( *_attribPtr )[ i ];
            T rightVert = ( *r->_attribPtr )[ i ];
            if( !disti::Equal( leftVert.x, rightVert.x ) || !disti::Equal( leftVert.y, rightVert.y ) || !disti::Equal( leftVert.z, rightVert.z ) )
            {
                return false;
            }
        }

        return true;
    }
};

/** An attribute for either a Vector or Vertex */
template<>
class DistiAttributeVertexArray<Vertex> : public DistiAttributeBase
{
protected:
    Vertex**        _attribPtr;
    typedef Vertex* Tptr;
    unsigned int*   _numVertices;
    unsigned int    _numElements;
    bool            _fixedArray;
    bool            _compatabilityMode;

public:
    void SetCompatabilityMode( bool mode ) { _compatabilityMode = mode; }
    // For variable length arrays
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex** attribPtr, unsigned int* numVertices )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _numVertices( numVertices )
        , _numElements( 0 )
        , _fixedArray( false )
    {
        _compatabilityMode = true;
    }
    // For fixed arrays
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex* attribPtr, unsigned int numElements )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Tptr( attribPtr ) )
        , _numVertices( NULL )
        , _numElements( numElements )
        , _fixedArray( true )
    {
        _compatabilityMode = true;
    }

    virtual ~DistiAttributeVertexArray()
    {
        if( ( _fixedArray || _localStorage ) && _attribPtr )
            delete _attribPtr;
        _attribPtr = NULL;
    }

    virtual bool OkToWrite() const
    {
        return ( *_attribPtr != NULL );
    }

    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        if( *_attribPtr != NULL )
        {
            unsigned int numVerts = _numElements;
            if( !_fixedArray )
            {
                outstr << *_numVertices;
                numVerts = *_numVertices;
            }
            DistiAttribDict::SpacingInc();
            for( unsigned int i = 0; i < numVerts; i++ )
            {
                outstr << '\n';
                outstr << ( *_attribPtr )[ i ];
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
    virtual std::istream& ReadValue( std::istream& instr )
    {
        unsigned int numVerts = _numElements;

        if( !_fixedArray )
        {
            instr >> numVerts;
            *_numVertices = numVerts;

            // Remove old storage if any
            if( *_attribPtr != NULL )
                delete[] * _attribPtr;

            // Create new storage
            *_attribPtr = new Vertex[ numVerts ];
        }

        if( !_compatabilityMode )
        {
            char buf[ 1024 ];
            // Get newline character
            instr.getline( buf, 1024 );
        }

        for( unsigned int i = 0; i < numVerts; i++ )
        {
            if( !_compatabilityMode )
            {
                char buf[ 1024 ];
                instr.getline( buf, 1024 );
                int r, g, b, a;
#ifdef GLS_DEBUG
                int count =
#endif
                    std::sscanf( buf, "%f %f %f %d %d %d %d",
                        &( ( *_attribPtr )[ i ].x ),
                        &( ( *_attribPtr )[ i ].y ),
                        &( ( *_attribPtr )[ i ].z ),
                        &r, &g, &b, &a );
#ifdef GLS_DEBUG
                assert( 7 == count );
#endif

                ( *_attribPtr )[ i ].color.RGBA( (unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a );
            }
            else
            {
                instr >> ( *_attribPtr )[ i ];
            }
        }
        CallCallback();
        return instr;
    }

    virtual bool operator==( const DistiAttributeBase& rArg )
    {
        DistiAttributeVertexArray<Vertex>* r = dynamic_cast<DistiAttributeVertexArray<Vertex>*>( const_cast<DistiAttributeBase*>( &rArg ) );
        if( !r )
        {
            return DistiAttributeBase::operator==( rArg );
        }

        if( !( _name == r->_name ) || _numElements != r->_numElements )
            return false;

        for( unsigned int i = 0u; i < _numElements; ++i )
        {
            Vertex leftVert  = ( *_attribPtr )[ i ];
            Vertex rightVert = ( *r->_attribPtr )[ i ];
            if( !disti::Equal( leftVert.x, rightVert.x ) || !disti::Equal( leftVert.y, rightVert.y ) || !disti::Equal( leftVert.z, rightVert.z ) || leftVert.color != rightVert.color )
            {
                return false;
            }
        }

        return true;
    }
};

/** This is used specifically for changing from TexturePoints as Vertexs to TexturePoints as Vectors.
  * It uses file version information to decide when expect what.
  */
class DistiAttributeTexturePointArray : public DistiAttributeVertexArray<Vector>
{
public:
    // For fixed arrays
    DistiAttributeTexturePointArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vector* attribPtr, unsigned int numElements )
        : DistiAttributeVertexArray<Vector>( callback, name, attribPtr, numElements )
    {
    }

    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        unsigned int numVerts = _numElements;

        for( unsigned int i = 0; i < numVerts; i++ )
        {
            outstr << '\n';
            outstr << ( *_attribPtr )[ i ];
        }
        return outstr;
    }

    virtual std::istream& ReadValue( std::istream& instr )
    {
        unsigned int numVerts = _numElements;

        for( unsigned int i = 0; i < numVerts; i++ )
        {
            // Get the whole line and then stream it into the Vector.
            // Before version 3.0, GL Studio files had full Vertex data
            // including color information stored after the location.
            // Reading whole lines comsumes this color information which is
            // then discarded.
            std::string line;
            std::getline( instr, line );
            // There must have been a leading newline, so read the first line again
            if( i == 0 && line.length() == 0 )
                std::getline( instr, line );

            std::stringstream strm( line );
            strm >> ( *_attribPtr )[ i ];
        }
        CallCallback();
        return instr;
    }
};

/** \class DistiAttributeNeverWrite
  * Allows for the normal template to be used to load a value but never write it out
  * This is used for compatability mostly.
  */
template<class T>
class DistiAttributeNeverWrite : public DistiAttribute<T>
{
public:
    DistiAttributeNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttribute<T>( callback, name, attribPtr )
    {
    }
    DistiAttributeNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, const T& initialValue )
        : DistiAttribute<T>( callback, name, initialValue )
    {
    }

    virtual bool OkToWrite() const { return false; }
};

/** \class DistiAttributeAlias
  * Give an alternate name to an existing attribute.
  * This is used for compatability mostly. i.e. GlsTextBox "String" as an alias of "Text".
  */
class DistiAttributeAlias : public DistiAttributeBase
{
public:
    DistiAttributeAlias( CallbackMethodCallerBase* callback, const AttributeName& name, const AttributeName& originalName, DistiAttribDict* dict )
        : DistiAttributeBase( callback, name, false )
        , _originalAttribName( originalName )
        , _dictionary( dict )
    {
    }

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT bool ValueChanged() DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void ResetValueChanged() DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT std::string ValueString() DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT long ValueInt() DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void ValueInt( long val ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT double ValueFloat() DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void ValueFloat( double val ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT bool operator==( const DistiAttributeBase& r ) DISTI_METHOD_OVERRIDE;

    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT CallbackID RegisterObserver( AttributeObserver* callback ) DISTI_METHOD_OVERRIDE;
    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void UnregisterObserver( CallbackID id ) DISTI_METHOD_OVERRIDE;
    /** \see DistiAttributeBase */
    virtual DISTI_EXPORT void NotifyObservers() DISTI_METHOD_OVERRIDE;

protected:
    AttributeName    _originalAttribName;
    DistiAttribDict* _dictionary;
};

/** \class DistiAttributeDynamicArray
  * An attribute for a dynamic array
  * T must be related to DynamicArray
  */
template<class T, bool showIndex /* In the output */>
class DistiAttributeDynamicArray : public DistiAttributeBase
{
    T* _attribPtr;

public:
    DistiAttributeDynamicArray( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }

    // Create a new DynamicArray using local storage
    DistiAttributeDynamicArray( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new T() )
    {
    }

    ~DistiAttributeDynamicArray()
    {
        if( _localStorage )
            delete _attribPtr;
        _attribPtr = NULL;
    }

    bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( _attribPtr != NULL && _attribPtr->Capacity() );
    }

    std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( _attribPtr != NULL )
        {
            unsigned numEntries = _attribPtr->Count();
            outstr << numEntries;

            DistiAttribDict::SpacingInc();

            for( unsigned i = 0; i < numEntries; i++ )
            {
                outstr << '\n';

                if( showIndex )
                {
                    outstr << DistiAttribDict::SpacingString() << i << "    ";
                }
                outstr.width( 1 );
                outstr << DistiAttribDict::SpacingString() << ( *_attribPtr )[ i ] << " ";
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }

    std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        unsigned numEntries = 0;
        instr >> numEntries;

        _attribPtr->Count( numEntries ); // Set count of objects in
        for( unsigned i = 0; i < numEntries; i++ )
        {
            // We read the entry number, which may differ from the index if values are skipped.
            unsigned entry = i;
            if( showIndex )
            {
                instr >> entry;
            }
            instr >> ( *_attribPtr )[ entry ];
        }
        CallCallback();
        return instr;
    }
};

/** \class DistiAttributeStdVector
  * An attribute for a std::vector
  * T must be related to std::vector
  */
template<class T, bool showIndex /* In the output */>
class DistiAttributeStdVector : public DistiAttributeBase
{
private:
    T* _attribPtr;

    DistiAttributeStdVector( const DistiAttributeStdVector& other );

public:
    DistiAttributeStdVector( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }

    // Create a new std::vector
    DistiAttributeStdVector( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new T() )
    {
    }

    virtual ~DistiAttributeStdVector()
    {
        if( _localStorage )
        {
            delete _attribPtr;
        }
        _attribPtr = NULL;
    }

    virtual bool OkToWrite() const
    {
        return ( _attribPtr != NULL && _attribPtr->size() );
    }

    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        if( _attribPtr != NULL )
        {
            const std::size_t numEntries = _attribPtr->size();
            outstr << numEntries;

            DistiAttribDict::SpacingInc();

            for( std::size_t i = 0; i < numEntries; i++ )
            {
                outstr << '\n';

                if( showIndex )
                {
                    outstr << DistiAttribDict::SpacingString() << i << "    ";
                }
                outstr.width( 1 );
                outstr << DistiAttribDict::SpacingString() << ( *_attribPtr )[ i ] << " ";
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }

    virtual std::istream& ReadValue( std::istream& instr )
    {
        if( _attribPtr != NULL )
        {
            int numEntries;
            instr >> numEntries;

            _attribPtr->resize( numEntries ); // Set count of objects in
            int entry;
            for( int i = 0; i < numEntries; i++ )
            {
                entry = i;
                if( showIndex )
                {
                    instr >> entry;
                }
                instr >> ( *_attribPtr )[ entry ];
            }
            CallCallback();
        }

        return instr;
    }
};

/** An attribute for a DynamicArray of homogeneous items
  * T must have ReadValue and WriteValue methods
  * Replacement for DistiAttributeHomogeneousAttributeArray
  */
template<class T>
class DistiAttributeHomogeneousItemArray : public DistiAttributeBase
{
public:
    typedef T* ( *CreateItemCb )();

protected:
    DynamicArray<T*>* _array;
    CreateItemCb      _createCb;

public:
    // Constructor requires a dynamic array of T*.
    DistiAttributeHomogeneousItemArray( const AttributeName& name, DynamicArray<T*>* array, CreateItemCb createCb )
        : DistiAttributeBase( NULL, name, false )
        , _array( array )
        , _createCb( createCb )
    {
    }
    virtual ~DistiAttributeHomogeneousItemArray() {}

    virtual bool OkToWrite() const { return _array && _array->Count(); }

    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        outstr << "\n"
               << DistiAttribDict::SpacingString() << "{\n";
        DistiAttribDict::SpacingInc();
        for( unsigned int i = 0; i < _array->Count(); i++ )
        {
            if( ( *_array )[ i ] )
            {
                outstr << DistiAttribDict::SpacingString();
                outstr << "Item: "; // Everything in the list is called Item
                ( ( *_array )[ i ] )->WriteValue( outstr );
                outstr << "\n";
            }
        }
        DistiAttribDict::SpacingDec();
        outstr << DistiAttribDict::SpacingString() << "}\n";
        return outstr;
    }
    virtual std::istream& ReadValue( std::istream& instr )
    {
        // Scan through the token including the ':'
        std::string buf;

        while( DistiAttribDict::ScanToken( instr, buf ) )
        {
            if( !buf.length() )
                continue;

            if( buf == "Item" )
            {
                // Eat the space between the : and the data
                instr.get();
                // Dynamically create it, and add it to the end of the list
                if( T* const createdItem = dynamic_cast<T*>( _createCb() ) )
                {
                    _array->PushBack( createdItem );
                    _array->Back()->ReadValue( instr );
                }
            }
        }
        return instr;
    }
};
/** The attribute used in generated code for accessing class properties
  * It can have a get method, set method, and an attribute pointer, or almost
  * any combination of the three.
  * T must have a default constructor, even if it doesn't initialize.
  * SetArgT is the argument type for the SetMethodType.  
  *  Specify this if the argument for the Set call is not "const &T".
  * GetReturnT is the return type for the GetMethodType.  
  *  Specify this if the return type for the Get call is not T
  * The get and set methods are called when the attribute interface is used for access.
  * If the methods are not provided, the attribute stream operators are used instead.
  * If the property does not have a method or attribute pointer, it will not be able to read/write its value.
  */
template<class containerT, class T, class SetArgT = const T&, class GetReturnT = T>
class DistiAttributeProperty : public DistiAttribute<T>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttribute<T> _BaseClass;
    typedef DistiAttribute<T> BaseClass;
    typedef void ( containerT::*SetMethodType )( SetArgT );
    typedef GetReturnT ( containerT::*GetMethodType )();
    typedef GetReturnT ( containerT::*GetMethodConstType )() const;

    float _precision;
    //T*            _attribPtr;
    containerT*   _container;
    SetMethodType _setMethod;
    GetMethodType _getMethod;

    // NULLs are OK
    DistiAttributeProperty( const AttributeName& name, containerT* frame, T* attribPtr, SetMethodType setMethod, GetMethodType getMethod )
        : BaseClass( NULL, name, attribPtr )
        , _precision( 0 )
        , _container( frame )
        , _setMethod( setMethod )
        , _getMethod( getMethod )
    {
        // Automatically use some precision for floats
        if( typeid( T ) == typeid( float ) || typeid( T ) == typeid( double ) || typeid( T ) == typeid( long double ) )
        {
            _precision = 10;
        }
    }

    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( this->_attribPtr || _getMethod );
    }

    // The DistiAttribute<> classes override the DistiAttributeBase implementation for these methods.  Here, we revert back to the DistiAttributeBase implementation

    virtual std::string ValueString() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueString(); }
    virtual void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueString( s ); }

    virtual long ValueInt() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueInt(); }
    virtual void ValueInt( long val ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueInt( val ); }

    virtual double ValueFloat() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueFloat(); }
    virtual void   ValueFloat( double val ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueFloat( val ); }

    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( _precision > 0 )
            outstr.precision( int( _precision ) );

        if( _getMethod && _container )
        {
            // Save the current _attribPtr
            T* tempAttribPtr = this->_attribPtr;

            // Get the value from the method.
            T temp( ( _container->*_getMethod )() );

            // Temporarily change the _attribPtr
            this->_attribPtr = &temp;

            // Call the base class to format the _attribPtr
            BaseClass::WriteValue( outstr );

            // Put the _attribPtr back to where it belongs
            this->_attribPtr = tempAttribPtr;
        }
        else if( this->_attribPtr )
        {
            BaseClass::WriteValue( outstr );
        }

        return outstr;
    }

    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        if( _setMethod && _container )
        {
            // Save the current _attribPtr
            T* tempAttribPtr = this->_attribPtr;
            T  temp;

            // Set _attribPtr to the temp variable;
            this->_attribPtr = &temp;

            // Call the base class to format the input
            BaseClass::ReadValue( instr );

            // Call the method
            ( _container->*_setMethod )( temp );

            this->_attribPtr = tempAttribPtr;
        }
        else if( this->_attribPtr )
        {
            BaseClass::ReadValue( instr );
        }

        return instr;
    }

    virtual T Value() DISTI_METHOD_OVERRIDE
    {
        if( _getMethod && _container )
        {
            // Get the value from the method
            return ( _container->*_getMethod )();
        }
        else if( this->_attribPtr )
        {
            return BaseClass::Value();
        }
        else
        {
            return T();
        }
    }

    virtual void Value( const T& val ) DISTI_METHOD_OVERRIDE // this has to match the base class's prototype so we override it, ie can't use SetArgT here
    {
        if( _setMethod && _container )
        {
            ( _container->*_setMethod )( val );
        }
        else if( this->_attribPtr )
        {
            BaseClass::Value( val );
        }
    }
};

/** Overloaded helper function to create a DistiAttributeProperty where the setter param is of type Type and the getter is non-const. (See other varians below.)
  * \tparam Type The type of the property (int, float, GlsColor, etc.)
  * \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
  * \param attrName The attribute name for this property.
  * \param obj The display object instance associated with this property.
  * \param setMethod The setter method for the property (can be NULL)
  * \param getMethod The getter method for the property (can be NULL)
  * \return The DistiAttributeProperty instance, which is owned by the caller.
  * \code
  *    Attributes().Add( CreateDistiAttributeProperty<int>( MetaTextureIndex, this, &DisplayObject::TextureIndex, &DisplayObject::TextureIndex ) );
  * \endcode
  */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                    attrName,
    Class* const                                                            obj,
    const typename DistiAttributeProperty<Class, Type, Type>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, Type, Type>::GetMethodType getMethod = NULL )
{
    return new DistiAttributeProperty<Class, Type, Type>( attrName, obj, NULL, setMethod, getMethod );
}

/** Overloaded helper function to create a DistiAttributeProperty where the getter is const. */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                         attrName,
    Class* const                                                                 obj,
    const typename DistiAttributeProperty<Class, Type, Type>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Type, Type>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type, Type>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type>::GetMethodType>( getMethod ) );
}

/** Overloaded helper function to create a DistiAttributeProperty where there is no setter method and the getter is const. */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                   attrName,
    Class* const                                                           obj,
    const typename DistiAttributeProperty<Class, Type>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type>( attrName, obj, NULL, NULL,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type>::GetMethodType>( getMethod ) );
}

/** Overloaded helper function to create a DistiAttributeProperty where there is no setter method and the getter is non-const. */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                              attrName,
    Class* const                                                      obj,
    const typename DistiAttributeProperty<Class, Type>::GetMethodType getMethod )
{
    return new DistiAttributeProperty<Class, Type>( attrName, obj, NULL, NULL, getMethod );
}

/** Overloaded helper function to create a DistiAttributeProperty where the setter param is of type const Type& and the getter is non-const. */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, const Type&>* CreateDistiAttributeProperty(
    const AttributeName&                                                           attrName,
    Class* const                                                                   obj,
    const typename DistiAttributeProperty<Class, Type, const Type&>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodType getMethod = NULL )
{
    return new DistiAttributeProperty<Class, Type, const Type&>( attrName, obj, NULL, setMethod, getMethod );
}

/** Overloaded helper function to create a DistiAttributeProperty where the setter param is of type const Type& and the getter is const. */
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, const Type&>* CreateDistiAttributeProperty(
    const AttributeName&                                                                attrName,
    Class* const                                                                        obj,
    const typename DistiAttributeProperty<Class, Type, const Type&>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type, const Type&>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodType>( getMethod ) );
}

/** Overloaded helper function to create a DistiAttributeProperty where the getter and setter are different base types (e.g. int vs bool) */
template<typename GetReturnT, typename SetArgT, class Class>
DistiAttributeProperty<Class, GetReturnT, SetArgT>* CreateDistiAttributeProperty(
    const AttributeName&                                                             attrName,
    Class* const                                                                     obj,
    const typename DistiAttributeProperty<Class, GetReturnT, SetArgT>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, GetReturnT, SetArgT>::GetMethodType getMethod )
{
    return new DistiAttributeProperty<Class, GetReturnT, SetArgT>( attrName, obj, NULL, setMethod, getMethod );
}

/** Overloaded helper function for properties that formerly used DistiAttributeLocation, which wraps properties that are stored in c++ as a Vertex but used in the Resources as a Vector */
template<class Class>
DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>* CreateDistiAttributePropertyVertexToVector(
    const AttributeName&                                                                                   attrName,
    Class* const                                                                                           obj,
    const typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::GetMethodType>( getMethod ) );
}

/** An empty attribute used where a reference to an attribute
  * must be returned, but needs to be blank 
  */
class DistiEmptyAttribute : public DistiAttributeBase
{
public:
    DistiEmptyAttribute()
        : DistiAttributeBase( NULL, AttributeName( "EmptyAttribute" ), false )
    {
    }

    /** Write nothing */
    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        return outstr;
    }
    /** Read nothing */
    virtual std::istream& ReadValue( std::istream& instr )
    {
        return instr;
    }
};

/** \class DistiAttributeEnumDirect
  * A Disti Attribute which reads and writes enumerations directly, bypassing method calls.
  */
template<class enumType>
class DistiAttributeEnumDirect : public DistiAttributeBase
{
protected:
    enumType* _attribPtr;

public:
    DistiAttributeEnumDefList* _pairList;

    DistiAttributeEnumDirect( CallbackMethodCallerBase* callback, const AttributeName& name, enumType* attribPtr, DistiAttributeEnumDefList* pairList )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _pairList( pairList )
    {
    }
    DistiAttributeEnumDirect( CallbackMethodCallerBase* callback, const AttributeName& name, const enumType& value, DistiAttributeEnumDefList* pairList )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new enumType( value ) )
        , _pairList( pairList )
    {
    }

    virtual ~DistiAttributeEnumDirect()
    {
        if( _localStorage && _attribPtr )
            delete _attribPtr;
        //delete _pairList; // This must point to persistant
    }

    virtual long ValueInt() { return (long)*_attribPtr; };
    virtual void ValueInt( long val ) { *_attribPtr = (enumType)val; };

    virtual DistiAttributeBase& operator=( const DistiAttributeBase& oldClass )
    {
        DistiAttributeEnumDirect* ptr = dynamic_cast<DistiAttributeEnumDirect*>( const_cast<DistiAttributeBase*>( &oldClass ) );
        if( ptr )
        {
            *_attribPtr = ( enumType ) * ( ptr->_attribPtr );
            CallCallback();
        }
        else
        {
            return DistiAttributeBase::operator=( oldClass );
        }
        return *this;
    }
    virtual std::ostream& WriteValue( std::ostream& outstr )
    {
        bool foundIt = false;
#ifndef __VXWORKS__
        typename DistiAttributeEnumDefList::iterator item = _pairList->begin();
        while( item != _pairList->end() )
        {
            if( ( *item )->_enum == *_attribPtr )
            {
                outstr << ( *item )->_string;
                foundIt = true;
                break;
            }
            ++item;
        }
        if( !foundIt )
        {
            //Didn't find it so just write the number
            outstr << (int)*_attribPtr;
        }
#endif

        return outstr;
    }
    virtual std::istream& ReadValue( std::istream& instr )
    {
#ifndef __VXWORKS__
        char value[ 64 ];
        instr >> value;

        bool                                         foundIt = false;
        typename DistiAttributeEnumDefList::iterator item    = _pairList->begin();

        // First look by enumeration
        while( item != _pairList->end() )
        {
            if( strcmp( ( *item )->_string, value ) == 0 )
            {
                *_attribPtr = ( enumType )( *item )->_enum;
                CallCallback();

                foundIt = true;
                break;
            }
            ++item;
        }

        // If not found, assume that the numerical value is specified.
        if( !foundIt )
        {
            *_attribPtr = (enumType)atoi( value );
            CallCallback();
        }
#endif

        return instr;
    }
};

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject callback.
/// \param instance The DisplayObject instance.
/// \param Class The current class name, derived from DisplayObject.
/// \param Method The class's method name for the callback.
/// \code{.cpp}
///    // Given a class ScrollList that inherits from DisplayObject...
///    ScrollList::ScrollList()
///    {
///        DISTI_REGISTER_METHOD_CALLBACK( this, &ScrollList::EventCallback );
///    }
///
///    int ScrollList::EventCallback( Group* self, DisplayEvent* ev )
///    {
///         // ... event handler code ...
///    }
/// \endcode
////////////////////////////////////////////////////////////////////////////////
#define DISTI_REGISTER_METHOD_CALLBACK( instance, Class, Method )                                             \
    {                                                                                                         \
        typedef CallbackMethodCallerTemplate<Class, Class> Caller;                                            \
        typedef typename Caller::MethodType1               MethodType;                                        \
        const MethodType                                   callback = reinterpret_cast<MethodType>( Method ); \
        ThisClass::CallbackCaller( new Caller( callback, instance ) );                                        \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject method caller for
/// MethodType 1.
/// \param object The DisplayObject instance.
/// \param method The method that should be called.
/// \param parent The parent to the object
////////////////////////////////////////////////////////////////////////////////
#define DISTI_SET_OBJECT_CALLBACK1( object, method, parent )            \
    ( object )->CallbackCaller(                                         \
        new CallbackMethodCallerTemplate<DisplayObject, DisplayObject>( \
            ( disti::CallbackMethodCallerTemplate<DisplayObject, DisplayObject>::MethodType1 )( method ), ( parent ) ) );

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type \a Type.
///                      Can be NULL if no member variable is desired.
/// \sa DISTI_ADD_ATTRIBUTE_CALLBACK
/// \sa DISTI_ADD_ATTRIBUTE_SET_GET
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE( Type, name, memberVarAddr )                                        \
    {                                                                                           \
        static const AttributeName           attr( name );                                      \
        CallbackAttributeNotifier<ThisClass> cb( this, attr );                                  \
        this->Attributes().Add( new DistiAttribute<Type>( &cb, ( attr ), ( memberVarAddr ) ) ); \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute that has a
/// callback function.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type \a Type.
///                      Can be NULL if no member variable is desired.
/// \param callbackFunction A member function pointer to the function called when this
///                 attribute is changed.
/// \sa DISTI_ADD_ATTRIBUTE
/// \sa DISTI_ADD_ATTRIBUTE_SET_GET
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_CALLBACK( Type, name, memberVarAddr, callbackFunction )                          \
    {                                                                                                        \
        typedef void ( ThisClass::*Method )(); /* Member function pointer */                                 \
        static const AttributeName           attr( name );                                                   \
        CallbackAttributeNotifier<ThisClass> cb( this, attr, reinterpret_cast<Method>( callbackFunction ) ); \
        this->Attributes().Add( new DistiAttribute<Type>( &cb, ( attr ), ( memberVarAddr ) ) );              \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute that has a
/// setter and a getter function.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param setter A member function pointer to the setter function (can be NULL)
/// \param getter A member function pointer to the getter function (can be NULL)
/// \sa DISTI_ADD_ATTRIBUTE
/// \sa DISTI_ADD_ATTRIBUTE_CALLBACK
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_SET_GET( Type, name, setter, getter )                                   \
    {                                                                                               \
        static const AttributeName attr( name );                                                    \
        this->Attributes().Add( CreateDistiAttributeProperty<Type>( attr, this, setter, getter ) ); \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a string as a DisplayObject attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type std::string.
///                      Can be NULL if no member variable is desired.
/// \sa DISTI_ADD_ATTRIBUTE_STRING_CALLBACK
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_STRING( name, memberVarAddr )                                         \
    {                                                                                             \
        static const AttributeName           attr( name );                                        \
        CallbackAttributeNotifier<ThisClass> cb( this, attr );                                    \
        this->Attributes().Add( new DistiAttributeEncodedStdString( &cb, attr, memberVarAddr ) ); \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a string as a DisplayObject attribute
/// with a callback
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type std::string.
///                      Can be NULL if no member variable is desired.
/// \param callbackFunction The function that gets called when the attribute changes.
/// \sa DISTI_ADD_ATTRIBUTE_STRING
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_STRING_CALLBACK( name, memberVarAddr, callbackFunction )                         \
    {                                                                                                        \
        typedef void ( ThisClass::*Method )(); /* Member function pointer */                                 \
        static const AttributeName           attr( name );                                                   \
        CallbackAttributeNotifier<ThisClass> cb( this, attr, reinterpret_cast<Method>( callbackFunction ) ); \
        this->Attributes().Add( new DistiAttributeEncodedStdString( &cb, attr, memberVarAddr ) );            \
    }

////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup an alias to an existing DisplayObject attribute.
/// \param name The unique string name identifying the attribute.
/// \param origName The unique string idenfifying the attribute to create the alias from.
/// \param obj The object containing the origName attribute.
/// \sa DISTI_ADD_ATTRIBUTE
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_ALIAS( aliasName, origName, obj )                                        \
    {                                                                                                \
        static const AttributeName aliasAttr( aliasName );                                           \
        static const AttributeName origAttr( origName );                                             \
        DistiAttribDict&           attributes = ( obj )->Attributes();                               \
        this->Attributes().Add( new DistiAttributeAlias( NULL, aliasAttr, origAttr, &attributes ) ); \
    }

#ifdef DISTI_HAS_CPP11

class AttributeFnCallback : public AttributeObserver
{
public:
    AttributeFnCallback( WeakReferenceable* object, std::function<void()> func )
        : _func( std::move( func ) )
        , _object( object )
    {
        GLS_VERIFY( NULL != object );
    }

    void Call( DistiAttributeBase& ev )
    {
        if( IsValid() )
        {
            _func();
        }
    }

    virtual bool IsValid() const
    {
        return !_object.IsNull() && _func;
    }

protected:
    std::function<void()>      _func;
    WeakRef<WeakReferenceable> _object;
};

inline AttributeObserver* CreateAttributeFnCallback(
    WeakReferenceable* const     obj,
    const std::function<void()>& func )
{
    return new AttributeFnCallback( obj, func );
}


inline DistiAttributeBase::CallbackID Connect( DisplayObject* obj, const std::string& resource, WeakReferenceable* funcOwner, std::function<void()> func )
{
    auto& res = obj->Resource( resource.c_str() );
    if( dynamic_cast<disti::DistiEmptyAttribute*>( &res ) )
    {
        std::cout << "Unknown attribute name: " << resource << std::endl;
        return DISTI_INVALID_CALLBACK_ID;
    }

    return res.RegisterObserver( CreateAttributeFnCallback( funcOwner, std::move( func ) ) );
}
#endif

template<class Class>
DistiAttributeBase::CallbackID Connect( DisplayObject* obj, const std::string& resource, Class* const methodInstance, const typename AttributeMethodCallback<Class>::Callback method )
{
    DistiAttributeBase& res = obj->Resource( resource.c_str() );
    if( dynamic_cast<disti::DistiEmptyAttribute*>( &res ) )
    {
        std::cout << "Unknown attribute name: " << resource << std::endl;
        return DISTI_INVALID_CALLBACK_ID;
    }
    return res.RegisterObserver( CreateAttributeMethodCallback( methodInstance, method ) );
}

inline void Disconnect( DisplayObject* obj, const std::string& resource, DistiAttributeBase::CallbackID id )
{
    DistiAttributeBase& res = obj->Resource( resource.c_str() );
    if( !dynamic_cast<disti::DistiEmptyAttribute*>( &res ) && id != DISTI_INVALID_CALLBACK_ID )
    {
        res.UnregisterObserver( id );
    }
}

} // namespace disti

#endif