callback_caller.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::CallbackMethodCallerTemplate class and global enumerations.
 
  \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_DISTI_CALLBACK_CALLER_H
#define INCLUDED_DISTI_CALLBACK_CALLER_H
 
#include "callback_caller_base.h"
#include "display.h"
#include "display_frame.h"
#include "events.h"
#include "stdio.h"
 
#ifndef WIN32
/// Redefine _snprintf to snprintf on non Windows platforms.
#    define _snprintf snprintf
#endif
 
namespace disti
{
/** The CallbackMethodCallerTemplate class
  * O must be related to DisplayObject
  */
template<class T, class O = DisplayObject>
class CallbackMethodCallerTemplate : public CallbackMethodCallerBase
{
public:
    typedef int ( T::*MethodType1 )( O*, DisplayEvent* );        ///< Typedef for functions matching base class' Call signature.
    typedef void ( T::*MethodType2 )( DisplayEvent* ev, void* ); ///< Typedef for functions matching base class' CallType2 signature.
    typedef void ( T::*MethodType3 )( void );                    ///< Typedef for functions matching base class' CallType3 signature.
 
protected:
    int   _methodType;   ///< The method type (1, 2, or 3).
    void* _callbackData; ///< Only used for MethodType2.
    T*    _container;    ///< The object which contains the method to call.
    union
    {
        MethodType1 _1;
        MethodType2 _2;
        MethodType3 _3;
    } _method; ///< The function pointer to call back.
 
    CallbackMethodCallerTemplate()
        : _methodType( 0 )
        , _callbackData( NULL )
        , _container( NULL )
    {}
 
public:
    /// Constructs a CallbackMethodCallerTemplate for MethodType1 (Call).
    /// \param method The function pointer to call back.
    /// \param container The object containing the function pointer.
    CallbackMethodCallerTemplate( MethodType1 method, T* container = NULL )
        : _methodType( 1 )
        , _callbackData( NULL )
        , _container( container )
    {
        _method._1 = method;
    }
 
    /// Constructs a CallbackMethodCallerTemplate for MethodType2 (CallType2).
    /// \param method The function pointer to call back.
    /// \param container The object containing the function pointer.
    /// \param callbackData User data to include with callback.
    CallbackMethodCallerTemplate( MethodType2 method, T* container, void* callbackData = NULL )
        : _methodType( 2 )
        , _callbackData( callbackData )
        , _container( container )
    {
        _method._2 = method;
    }
 
    /// Constructs a CallbackMethodCallerTemplate for MethodType3 (CallType3).
    /// \param method The function pointer to call back.
    /// \param container The object containing the function pointer.
    CallbackMethodCallerTemplate( MethodType3 method, T* container )
        : _methodType( 3 )
        , _callbackData( NULL )
        , _container( container )
    {
        _method._3 = method;
    }
 
    virtual CallbackMethodCallerBase* Duplicate() const DISTI_METHOD_OVERRIDE
    {
        CallbackMethodCallerTemplate* newOne = new CallbackMethodCallerTemplate();
        newOne->_callbackData                = _callbackData;
        newOne->_method                      = _method;
        newOne->_methodType                  = _methodType;
        newOne->_container                   = _container;
        return newOne;
    }
 
    virtual void SetContainer( DisplayObject* container ) DISTI_METHOD_OVERRIDE
    {
        _container = dynamic_cast<T*>( container );
    }
 
    int Call( DisplayObject* target, DisplayEvent* ev ) DISTI_METHOD_OVERRIDE
    {
        O* targetObject = dynamic_cast<O*>( target );
        if( _method._1 && _methodType == 1 && targetObject )
        {
            T* obj = _container;
 
            // When an object is cloned, it will attempt to set the _container to itself. (See GLS-10164)
            // This can be correct for some callbacks created via user code, but not for ones created in the editor.
            // These are always the parent component, so check to see if the parent's type matches what we expect.
            // If this is the case, we assume that we were cloned and this is our real container.
            if( !obj )
            {
                if( ComponentBase* const targetComp = dynamic_cast<ComponentBase*>( targetObject ) )
                {
                    obj = dynamic_cast<T*>( targetComp->ParentDisplayFrame() );
                }
                else
                {
                    obj = dynamic_cast<T*>( targetObject->DisplayObject::Parent() );
                }
 
                if( obj )
                {
                    _container = obj;
                }
            }
 
            if( obj )
            {
                return ( obj->*( _method._1 ) )( targetObject, ev );
            }
        }
        return 0;
    }
 
    void CallType2( DisplayEvent* ev, void* callbackData = NULL ) DISTI_METHOD_OVERRIDE
    {
        if( _method._2 && _methodType == 2 && _container )
        {
            if( callbackData == NULL )
                callbackData = _callbackData;
 
            ( _container->*( _method._2 ) )( ev, callbackData );
        }
    }
 
    void CallType3() DISTI_METHOD_OVERRIDE
    {
        if( _method._3 && _methodType == 3 && _container )
        {
            ( _container->*( _method._3 ) )();
        }
    }
};
 
/** A CallbackMethodCallerBase that notifies when properties are changed, and also optionally calls a void callback
  * Version only supports method type 3
  */
template<class T>
class CallbackAttributeNotifier : public CallbackMethodCallerBase
{
public:
    typedef void ( T::*MethodType )( void ); ///< Typedef for function pointer
 
public:
    /// Construct a CallbackAttributeNotifier.
    /// \param container The object containing the callback method.
    /// \param attributeName The attribute name to attach the callback to.
    /// \param method The function to call back.
    CallbackAttributeNotifier( T* container, const AttributeName& attributeName, MethodType method = NULL )
        : _container( container )
        , _attributeName( attributeName )
        , _method( method )
    {
    }
 
    virtual CallbackMethodCallerBase* Duplicate() const DISTI_METHOD_OVERRIDE
    {
        CallbackAttributeNotifier* newOne = new CallbackAttributeNotifier( _container, _attributeName, _method );
        return newOne;
    }
 
    virtual void SetContainer( DisplayObject* container ) DISTI_METHOD_OVERRIDE
    {
        _container = dynamic_cast<T*>( container );
    }
 
    // Not supported by this class.
    int Call( DisplayObject* /*target*/, DisplayEvent* /*ev*/ ) DISTI_METHOD_OVERRIDE { return 0; }
 
    // Not supported by this class.
    void CallType2( DisplayEvent* /*ev*/, void* /*callbackData*/ = NULL ) DISTI_METHOD_OVERRIDE {}
 
    void CallType3() DISTI_METHOD_OVERRIDE
    {
        if( _container )
        {
            _container->NotifyAttributeChanged( _attributeName );
 
            if( _method )
            {
                ( _container->*( _method ) )();
            }
        }
    }
 
protected:
    T*            _container;     ///< The object which contains the method to call.
    AttributeName _attributeName; ///< The associated property name for the callback.
    MethodType    _method;        ///< The function pointer to call back.
};
 
/** helper for class for emitting attribute changed events in generated code 
  * this class does two things:  
  *     1) It calls NotifyAttributeChanged if the attribute changed
  *     2) It emits an event if EmitEvent() was set to true and if the Container type is DisplayObject.  It can't emit events for top
  *        level display frames since they don't have a handle() method.
  */
template<class T>
class AttributeChangedEventEmitter
{
public:
    /** ctor
      * \param container container that has attribute
      * \param val current value of attribute.  Lifetime must extend pass the life of this class
      * \param attribName name of attribute.  Lifetime must extend pass the life of this class
      * \param emitEvent whether or not to emit an event.  The container must be a DisplayObject, and the event will be passed to the object's handle() method.
      */
    AttributeChangedEventEmitter( AttributeChangedNotifier* container, T& val, const AttributeName& attribName, bool emitEvent = false )
        : _container( container )
        , _prevVal( val )
        , _curVal( val )
        , _attribName( attribName )
        , _emitEvent( emitEvent )
    {
    }
 
    /** dtor - emit attribute changed event if container is a DisplayObject and the value has changed */
    ~AttributeChangedEventEmitter()
    {
        if( NULL != _container )
        {
            EmitAttributeChangedEventProperty();
        }
    }
 
protected:
    AttributeChangedNotifier* _container;  /**< container */
    T                         _prevVal;    /**< previous value for attribute */
    T&                        _curVal;     /**< ref to current value for attribute */
    const AttributeName&      _attribName; /**< attribute name */
    bool                      _emitEvent;  ///< whether or not to emit an event
 
    /// Emits an "AttributeChanged" ObjectEvent, and calls NotifyAttributeChanged to tell subscribers that this property changed.
    void EmitAttributeChangedEventProperty()
    {
        std::stringstream strmNew;
        std::stringstream strmOld;
 
        std::string strNew;
        std::string strOld;
 
        strmNew << _curVal;
        strmOld << _prevVal;
        strNew = strmNew.str();
        strOld = strmOld.str();
 
        if( strNew.compare( strOld ) != 0 )
        {
            _container->NotifyAttributeChanged( _attribName );
 
            if( _emitEvent )
            {
                if( DisplayObject* displayObj = dynamic_cast<DisplayObject*>( _container ) )
                {
                    std::string str = std::string( _attribName ) + " " + strNew;
                    ObjectEvent newEvent( displayObj, "AttributeChanged", str.c_str() );
                    displayObj->handle( &newEvent );
                }
            }
        }
    }
 
private:
    // disallow
    AttributeChangedEventEmitter( const AttributeChangedEventEmitter& src );
    AttributeChangedEventEmitter& operator=( const AttributeChangedEventEmitter& rhs );
};
 
} // namespace disti
 
#endif