Fl_RSO_Window.H

Go to the documentation of this file.

/*! \file Fl_RSO_Window.H
  
  \par Copyright Information

  Copyright (c) 2012 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 POSSIBLITY
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 FL_RSO_WINDOW_H
#define FL_RSO_WINDOW_H


#include <FL/Fl_Gl_Window.H>
#include "rso_interface_1.h"
#include "component_base.h"
#include "group.h"
#include "glpolygon.h"
#include "DDD_RSOAsset.h"
#include "DDD_PerformanceMonitor.h"
#include "DDD_XMLConfigMgr.h"
#include "events.h"

/** \brief Fl_Gl_Group. Parent FLTK group containing a Fl_RSO_Window; passes certain events to Fl_Gl_Window. */
class DDD_EXPORT Fl_Gl_Group : public Fl_Group
{
public:

    /** Constructor
      * \param x  X value for this group.
      * \param y  Y value for this group.
      * \param w  Width value for this group.
      * \param h  Height Value for this group.
      * \param l  Label to use for this group.
      */
    Fl_Gl_Group(int x, int y, int w, int h, const char *l=0);

    /** Handle events for this group
      * \param evId  The event id for the event that needs to be handled.
      */
    virtual int handle(int evId);
};


/** \brief Fl_RSO_Window. FLTK/OpenGL window that displays RSO Assets. */
class DDD_EXPORT Fl_RSO_Window : public Fl_Gl_Window
{

public:

    /** Destructor */
    virtual ~Fl_RSO_Window();

    /** Constructor
      * \param W  Width for the new window
      * \param H  Height for the new window
      * \param l  Label for the new window
      */
    Fl_RSO_Window(int W, int H, const char *l=0);

    /** Constructor
      * \param X  X position for the new window
      * \param Y  Y position for the new window
      * \param W  Width for the new window
      * \param H  Height for the new window
      * \param l  Label for the new window
      */
    Fl_RSO_Window(int X, int Y, int W, int H, const char *l=0);

    /** Initializes all members to their default settings
      * 
      */
    virtual void Clear();
    
    /** Recreates the canvas size based on the input width and height
      * \param width  Value for the canvas width
      * \param height Value for the canvas height
      */
    virtual void InitializeCanvas(float width, float height);

    /** Iserts a component pointer into to the top of _object to be drawn first
      * \param component  Pointer to the component that's being added
      */
    void AddComponent(disti::ComponentBase *component);

    /* Sets the viewable region percentage
     * \param scale  Value to use for the vew scale
     */
    virtual void SetViewScale(float scale);

    /* Sets the viewable region to fit to the canvas size
     *
     */
    virtual void SetViewFit();
    
    /* Sets the center of the view in logical coordinates
     * \param center  Vector position to use as the new vew center
     */
    virtual void SetViewCenter(disti::Vector center);   

    /* Finds the first object collided with based on input X/Y values. The
     * algorithm does a simple 2D collision check of all members of _objects
     * based on reverse draw order (ie. objects drawn last will be collided
     * with first).
     * Sets _currentlySelectedAsset and _currentlySelectedRSO
     * \param x  Logical x pick value
     * \param y  Logical y pick value
     */
    void Pick2DByExtents(float x, float y);

    /* The callback for the live viewer window
     * \param eventID  event id for the event to handle
     */
    virtual int handle(int eventID);

    //
    // Handle code
    //

    /* Helper function that handles keyboard input
     * \param  key  Key event that needs to be handled as reported by FLTK
     * \return  True if the input was handled False otherwise
     */
    virtual bool HandleKeyboardInput(int key);
    
    /* Helper function that handles mouse move events
     * \param  currentEventWinLoc  Location of the event that needs to be handled in window coordinates
     * \param  previousLogicalCoords  Location of the last handled event in logical coordinates
     * \param  currentLogicalCoords  Location of the current event that needs to be handled in logical coordinates
     */
    virtual void HandleMouseMove(disti::Vector currentEventWinLoc, disti::Vector previousLogicalCoords, disti::Vector currentLogicalCoords);
    
    /* Helper function that handles mouse push events
     * \param  currentEventWinLoc  Location of the event that needs to be handled in window coordinates 
     * \param  currentLogicalCoords  Location of the current event that needs to be handled in logical coordinates
     * \return True if the event was handled and False otherwise
     */
    virtual bool HandleMousePush(disti::Vector currentEventWinLoc, disti::Vector currentLogicalCoords);

    /* Helper function that handles mouse drag events
     * \param  currentEventWinLoc  Location of the event that needs to be handled in window coordinates
     * \param  previousLogicalCoords  Location of the last handled event in logical coordinates
     * \param  currentLogicalCoords  Location of the current event that needs to be handled in logical coordinates
     */
    virtual void HandleMouseDrag(disti::Vector currentEventWinLoc, disti::Vector previousLogicalCoords, disti::Vector currentLogicalCoords);

    /* Sets the currently selected object
     * \param newObject  Pointer to the object that just got selected
     */
    void SetCurrentlySelectedAsset(disti::DDD_AssetBase* newAsset);
    
    /* Helper function used to get the currently selected asset
     * \return  Pointer to the currently selected asset
     */
    disti::DDD_AssetBase* GetCurrentlySelectedAsset() { return _currentlySelectedAsset; }

    /* Helper function used to get the currently selected RSO
     * NOTE:  It's possible for _currentlySelectedAsset to be set and _currentlySelectedRSO to be NULL
     *        if the currently selected asset is not an RSO.  (This should only happen in the Producer)
     * \return  Pointer to the currently selected RSO
     */
    disti::DDD_AssetBase* GetCurrentlySelectedRSO() { return _currentlySelectedRSO; }

    /* Helper function used to get the current list of objects
     * \return  Pointer to the current group of objects
     */
    disti::Group* GetObjects() { return &_objects; }

    /*  Helper function used to get the current view scale
     * \return  Veiw scale value
     */
    float Scale() { return _viewScale; }

    /* Zoom in by 2, setting the new center point
     * \param newCenter  The new center point    
     */
    virtual void ZoomIn(const disti::Vector &newCenter);
    
    /* Zoom out by 2, setting the new center point
     * \param newCenter  The new center point
     */
    virtual void ZoomOut(const disti::Vector &newCenter);

    /* Zoom in by 2, no recenter
     * 
     */
    virtual void ZoomIn();
    
    /* Zoom out by 2, no recenter
     *
     */
    virtual void ZoomOut();

    /* Helper function to the set configuration target
     * \param target  Target to use for this window
     */
    void SetTarget(disti::XMLConfigTarget *target) { _target = target; }

    /* Helper function to get the frame interval value
     * \return  The frame interval value (in microseconds)
     */
    int FrameInterval() { return _frameInterval; };

    /* Helper function to set the frame interval
     * \param microseconds  Number of microseconds to use as the frame interval
     */
    void FrameInterval(int microseconds) { _frameInterval = microseconds; }

    /* Helper function used to set the redraw flag
     *
     */
    virtual void SetRedraw();

    /*  Helper function used to control when the frame is drawn
     *
     */
    virtual bool FrameAnimate();

    /* Helper function that waits for an event to happen
     * \return True if a window is being shown False otherwise
     */
    virtual bool UpdateAnimate();

    /* Helper function used to sync the multivew on all RSO Assets
     *
     */
    virtual void SyncAllRSOAssetMultiViews();

protected:

    /** Setup the OpenGL Context for drawing 
      * \return Returns true if states will need to be restored
      */
    bool SetupOpenGLState();

    /** Setup the OpenGL Context for drawing 
      * \return Returns true if states will need to be restored
      */
    void RestoreOpenGLState(bool saveVal);

    /** Draw the Canvas. */
    void DrawCanvas();

    /** Draw performance statistics */
    void DrawStats();

    /** Draw the objects
      * \param previewMode When true, all objects are drawn.  
      *                    When false only objects on the canvas are drawn.
      */
    void DrawObjects(bool previewMode);

    /* Helper function used to populate a mouse event object
     * \param eventButton  Event button value as reported by FLTK
     * \param eventSybtype Event subtime as reported by FLTK (i.e. FL_PUSH FL_RELEASE)
     * \param logicalX  Value for x in logical coordinates
     * \param logicalY  Value for y in logical coordinates
     * \param logicalZ  Value for z in logical coordinates
     * \param mev  MouseEvent reference to populate
     */
    void GenerateMouseEvent(int eventButton, int eventSubtype, float logicalX, float logicalY, disti::MouseEvent *mev);

    /* Helper function used to render components to the screen
     *
     */
    virtual void draw();

    /*  Helper function used to resize the window
     * \param x  X value for the location of the window in screen coordinates
     * \param y  Y value for the location of the window in screen coordinates
     * \param w  New window width value in screen coordinates
     * \param h  New window height value in screen coordinates
     */
    virtual void resize(int,int,int,int);

    //
    // Sync Multiview's screen position up to rso asset's position
    //

    /* Helper function used to sync the multiview
     * \param rsoAsset
     * \return True if the multivew was succesfully synced False otherwise
     */
    virtual bool SyncMultiViewPos(disti::DDD_RSOAsset* rsoAsset);

    /* Helper function for picking individual RSO
     * \param component  Component instance to check
     * \param logicalCoords  Picking ray, in logical coordinates
     * \return true if ray has intersected Component, false otherwise
     */
    bool Pick2DUsingRSOExtents(disti::ComponentBase *component, const disti::Vector& logicalCoords);

    /* Helper function for picking individual eyepoint-enabled RSO
     * \param asset  Asset instance to check
     * \param logicalCoords  Picking ray, in logical coordinates
     * \return true if ray has intersected Component, false otherwise
     */
    bool Pick2DUsingRSOEyepoint(disti::DDD_RSOAsset *asset, const disti::Vector& logicalCoords);

protected:

    
    disti::GLPolygon *_canvas;        /**< Polygon that defines the canvas to be drawn. */
    disti::Vector _viewTranslation;   /**< The current translation for the view */
    disti::Group _objects;            /**< Contains a list of components that will be used to draw with */
    float _viewScale;                 /**< Sets the viewing scale for the window */

    
    disti::DDD_AssetBase  *_currentlySelectedAsset;  /**< The currently selected Asset */
    disti::DDD_RSOAsset  *_currentlySelectedRSO;     /**< The currently selected RSO */

    disti::OpenGLMatrices _currentMatrices;     /**< The current OpenGL Matrices */

    disti::Vector _previousMouseEventLocation;  /**< The last mouse event location */

    disti::XMLConfigTarget *_target; 

    disti::DDD_PerformanceMonitor   *_drawProfiler,    /**< Measures Draw performance */
                                    *_renderProfiler,  /**< Measures render(draw+predraw) performance */
                                    *_fpsProfiler;     /**< Measures FPS performance */

    // borrowed from GlsDisplayFrame
    float _smoothedFrameDelay;   /**< Frame interval, smoothed based on actual draw performance */  
    bool _redraw;                /**< Flag indicating if the window should be redrawn */
    int _frameInterval;          /**< frame interval in microseconds */

};

#endif