callback_caller.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::CallbackMethodCallerTemplate class and global enumerations.

  \par Copyright Information

  Copyright (c) 2015 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 _CALLBACK_CALLER_H
#define _CALLBACK_CALLER_H

#include "display.h"
#include "events.h"
#include "display_frame.h"
#include "callback_caller_base.h"
#include "stdio.h"

#ifndef WIN32
#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 void (T::*MethodType2)(DisplayEvent* ev, void*);
    typedef void (T::*MethodType3)(void);
  protected:
    int   _methodType;
    union {
      MethodType1 _1;
      MethodType2 _2;
      MethodType3 _3;
    } _method;
    void* _callbackData; // Only used for MethodType2.
    //DisplayFrame* _frame;
    //DisplayObject* _object;
    T* _container; // The object which contains the method to call
    CallbackMethodCallerTemplate() :
       _methodType(0),
       _callbackData(NULL),
       _container(NULL){}
        
  public:

    CallbackMethodCallerTemplate(MethodType1 method, T* container = NULL) : 
        _methodType(1),
        _callbackData(NULL), 
        _container(container)
        {
            _method._1 = method;
        }
    CallbackMethodCallerTemplate(MethodType2 method, T* container, void* callbackData = NULL) : 
        _methodType(2),
        _callbackData(callbackData), 
        _container(container) 
        {
            _method._2 = method;
        }
    CallbackMethodCallerTemplate(MethodType3 method, T* container) : 
        _methodType(3),
        _callbackData(NULL),
        _container(container) 
        {
            _method._3 = method;
        }

    virtual CallbackMethodCallerBase* Duplicate() const
    { 
        CallbackMethodCallerTemplate* newOne = new CallbackMethodCallerTemplate();
        newOne->_callbackData = _callbackData;
        newOne->_method       = _method;
        newOne->_methodType   = _methodType;
        newOne->_container    = _container;
        return newOne;
    }

    virtual void SetContainer(DisplayObject* container)
    {
        _container = dynamic_cast<T*>(container);
    }

    // Call for MethodType1
    int Call(DisplayObject* target, DisplayEvent* ev)
    {
      O* targetObject = dynamic_cast<O*>(target);
      if (_method._1 && _methodType == 1 && targetObject)
      {
        T* obj = _container;

        // Try to extrach the frame from the object if needed
        if (!obj)
            obj = dynamic_cast<T*>(targetObject->DisplayObject::Parent());

        if (obj) 
          return (obj->*(_method._1))(targetObject, ev);
      }
      return 0;
    }
    // Call for MethodType2
    // Allows the caller to override callbackData with a non NULL value
    void CallType2(DisplayEvent* ev, void* callbackData = NULL)
    {
      if (_method._2 && _methodType == 2 && _container)
      {
        if (callbackData == NULL)
            callbackData = _callbackData;

        (_container->*(_method._2))(ev, callbackData);
      }
    }
    // This calls the MethodType3 method
    void CallType3()
    {
      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 );

public:
    CallbackAttributeNotifier( T* container, const AttributeName& attributeName, MethodType method = NULL )
        : _container( container )
        , _attributeName( attributeName )
        , _method( method )
    {
    }

    virtual CallbackMethodCallerBase* Duplicate() const
    {
        CallbackAttributeNotifier* newOne = new CallbackAttributeNotifier( _container, _attributeName, _method );
        return newOne;
    }

    virtual void SetContainer( DisplayObject* container )
    {
        _container = dynamic_cast<T*>( container );
    }

    // Call for MethodType1
    int Call( DisplayObject* /*target*/, DisplayEvent* /*ev*/ ) { return 0; }
    // Call for MethodType2
    void CallType2( DisplayEvent* /*ev*/, void* callbackData = NULL ) {}

    // This calls the MethodType3 method
    void CallType3()
    {
        if( _container )
        {
            _container->NotifyAttributeChanged( _attributeName );

            if( _method )
            {
                ( _container->*( _method ) )();
            }
        }
    }

protected:
    T*            _container; // The object which contains the method to call
    AttributeName _attributeName;
    MethodType    _method;
};


/** 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 */

    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