gls_switch.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsSwitch class.
 
  \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 _GLS_SWITCH_H
#define _GLS_SWITCH_H
 
#include "gls_cpp_lang_support.h"
#include "glsutil.h"
#include "group.h"
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GlsSwitch ) || defined( GLSGEN_IMPORT_GlsSwitch ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GlsSwitch ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GlsSwitch_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsSwitch_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsSwitch_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_switch"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
enum
{
    GLS_GLSSWITCH_INITIAL_DETENT_VAL = GLS_LAST_INITIALIZER + 1,
    GLS_GLSSWITCH_WHICH_OBJECT_BACKGROUND,
    GLS_GLSSWITCH_FIRST_DETENT_SNAPBACK, // for normal or snapback behavior
    GLS_GLSSWITCH_LAST_DETENT_SNAPBACK,  // for normal or snapback behavior
    GLS_GLSSWITCH_EMIT_DETENT_VAL_EVENT,
    GLS_GLSSWITCH_EMIT_LIMIT_EVENT,
    GLS_GLSSWITCH_EMIT_RELEASE_EVENT
};
 
/** Runtime implementation of a switch */
class GlsSwitch : public Group
{
private:
    GlsSwitch& operator=( const GlsSwitch& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsSwitch( const GlsSwitch& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
public:
    friend class GlsSwitchEditor;
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef Group _BaseClass; ///< Deprecated typedef for the base class.
    typedef Group BaseClass;  ///< Typedef for the base class.
 
    int  _detentVal;             ///< CurrentPosition
    bool _firstDetentSnapback;   ///< If true, the position will snap from the first detent back to the second detent when released.
    bool _lastDetentSnapback;    ///< If true, the position will snap from the last detent back to the second to last detent when released.
    int  _whichObjectBackground; ///< the geometry index (plus 1) to serve as the switch background. 0 is no background object.
    bool _emitDetentValEvent;    ///< If true, events will be emitted whenever the detent value changes.
 
    /// Set if a DetentVal event should be emitted.
    /// \param value The new emit event flag to set.
    inline void EmitDetentValEvent( const bool& value );
 
    /// \return Whether or not a DetentVal event should be emitted.
    inline bool EmitDetentValEvent() { return _emitDetentValEvent; }
 
    /// Set if a Limit event should be emitted.
    /// \param value The new emit event flag to set.
    inline void EmitLimitEvent( const bool& value );
 
    /// \return Whether or not a Limit event should be emitted.
    inline bool EmitLimitEvent() { return _emitLimitEvent; }
 
    /// Set if a Release event should be emitted.
    /// \param value The new emit event flag to set.
    inline void EmitReleaseEvent( const bool& value );
 
    /// \return Whether or not a Release event should be emitted.
    inline bool EmitReleaseEvent() { return _emitReleaseEvent; }
 
    /// \return The number of detents on this switch.
    GLSGEN_GlsSwitch_EXPORT int NumDetents();
 
    /// \returns The geometry associated with the detent.
    /// \param detent The index of the detent whose geometry is to be returned.
    GLSGEN_GlsSwitch_EXPORT DisplayObject* DetentGeometry( int detent ) const;
 
    /// \return The geometry specified as the background, NULL is returned if none.
    GLSGEN_GlsSwitch_EXPORT DisplayObject* BackgroundGeometry() const;
 
    /// Create a new GlsSwitch.
    /// \param generateInstance Whether or not to generate an instance name for this object.
    GLSGEN_GlsSwitch_EXPORT GlsSwitch( bool generateInstance = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GlsSwitch_EXPORT GlsSwitch( const GlsSwitch& that, const bool generateNames );
 
    /** Destroy a GlsSwitch object */
    virtual GLSGEN_GlsSwitch_EXPORT ~GlsSwitch();
 
    /// \return A pointer to a new GlsSwitch object.
    static GLSGEN_GlsSwitch_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GlsSwitch_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsSwitch_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsSwitch_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsSwitch_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsSwitch_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GlsSwitch_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsSwitch_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    /// \return Whether or not this switch is horizontal or vertical relative to the y axis.
    InputOrientationEnum InputType();
 
    GLSGEN_GlsSwitch_EXPORT DisplayObject* handle( DisplayEvent* ev ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsSwitch_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
    GLSGEN_GlsSwitch_EXPORT bool IsVisibleInScene( const DisplayObject* obj = NULL ) const DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // Switch specific operations
    //////////////////////////////////////////////////
 
    /** Sets current detent of the switch
      * \param val New detent of the switch
      */
    virtual GLSGEN_GlsSwitch_EXPORT void DetentVal( const int& val );
 
    /** Returns the current detent of the switch
      * \return Current switch detent
      */
    virtual GLSGEN_GlsSwitch_EXPORT int DetentVal();
 
    /** Sets current background geometry index value of the switch
      * \param val New switch background geometry index value
      */
    virtual GLSGEN_GlsSwitch_EXPORT void WhichObjectBackground( const int& val );
 
    /** Returns the current background geometry index value of the switch
      * \return Current switch background geometry index value
      */
    virtual GLSGEN_GlsSwitch_EXPORT int WhichObjectBackground() const;
 
    /** Returns the current background geometry index value of the switch
     * \deprecated this method is not const correct, use const version instead
     * \return Current switch background geometry index value
     */
    DISTI_DEPRECATED( "Use the const version instead." )
    virtual int WhichObjectBackground() DISTI_FINAL
    {
        return const_cast<const GlsSwitch*>( this )->WhichObjectBackground();
    }
 
protected:
    bool _emitLimitEvent;   ///< If true, an event will be emitted when the switch hits its maximum or minimum state.
    bool _emitReleaseEvent; ///< If true, an event will be emitted when the switch is released.
 
    Vector _mouseDownOCoords; ///< Stores the object coordinates of the last mouse down on this object.
 
    bool         _mouseWasDown;  ///< Whether or not the mouse is down on this object.
    unsigned int _currentCursor; ///< The current cursor used for interaction.  Any other cursors are ignored while interacting.
 
    /// Uses event data to calculate a new switch position based on the DCS of the object.
    /// \note This is not intended to be called directly.
    /// \param self This object.
    /// \param ev The input event.
    /// \param inputType The input type of this switch.
    /// \param numPositions The number of positions in this switch.
    /// \param scale Additional scale to be applied.
    /// \return The new position of the switch.
    int CalcSwitchPosDCS( DisplayObject* self, DisplayEvent* ev,
        InputOrientationEnum inputType, int numPositions,
        float scale = 1.0f );
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GlsSwitch_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
};
 
} // namespace disti
 
#endif