gls_display_frame.h

Go to the documentation of this file.

/*! \file
  \brief  disti::glsDisplayFrame class.  The class for creating standalone executables.
 
  \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_DISPLAY_H
#define GLS_DISPLAY_H
 
// This is just here to have somewhere to put it that will get documented by doxygen.
/** \class Fl_Gl_Window
  * \htmlonly <dt><a href="fltk/Fl_Gl_Window.html">Fl_Gl_Window reference</a></dt> \endhtmlonly
  * \htmlonly <dt><a href="fltk/index.html">Complete Fltk documentation</a></dt> \endhtmlonly
  */
 
#ifdef GLES
#    if defined( EMSCRIPTEN )
#        include "events.h"
#        include "gls_gl.h"
#        include "gls_include.h"
#        include "timer.h"
#    else
#        include "embedded_display_frame.h"
namespace disti
{
/// Base class for all embedded (openGL ES) display frame classes.
typedef EmbeddedDisplayFrame glsDisplayFrame;
} // namespace disti
#    endif
 
#else
 
#    include "gls_include.h"
 
#    ifdef WIN32
#        pragma warning( push )
#        pragma warning( disable : 4244 )
#    endif
#    include <FL/Fl.H>
#    include <FL/Fl_Box.H>
#    include <FL/Fl_Gl_Window.H>
#    include <FL/Fl_Window.H>
#    ifdef WIN32
#        pragma warning( pop )
#    endif
 
#    include "events.h"
#    include "runtime_display_frame.h"
 
class Fl_Gl_Window;
 
namespace disti
{
class SplashDisplay;
class glsDisplayFrame;
 
/** \class OpenGLWindow
  * OpenGLWindow is a GL Studio specific implementation of the Fltk Fl_Gl_Window
  */
class OpenGLWindow : public Fl_Gl_Window
{
    glsDisplayFrame* frame; /**< The DisplayFrame associated with this window */
    MouseEvent       ev;    /**< Last mouse event received */
    KeyboardEvent    kev;   /**< Last keyboard event received */
 
    /** Overload of FLTK draw routine */
    GLS_EXPORT void draw();
 
public:
    /** Overload of FLTK make_current() method.  Sets this window as the current OpenGL context */
    GLS_EXPORT void make_current();
 
    /** Overload of FLTK end() method.  Used to signal FLTK to not make this the "current" window to add widgets to */
    GLS_EXPORT void end();
 
    /// Overload of FLTK resizable() method.
    /// \param win The widget to be used as the resizable region.
    GLS_EXPORT void resizable( OpenGLWindow* win );
 
    /** Overload of FLTK resize() method. Resizes the window.
      * \param x  New x coordinate of window on screen
      * \param y  New y coordinate of window on screen
      * \param w  New width of window in pixels
      * \param h  New height of window in pixels
      */
    GLS_EXPORT void resize( int x, int y, int w, int h );
 
    /** Overload of FLTK show() method. Sets the visible flag for this window, causing it to be shown the next time
      * the FLTK event loop is checked.
      */
    GLS_EXPORT void show();
 
    /// Overload of FLTK event handle routine. This is how mouse and keyboard events get passed in.
    /// \return 0 if the event was not handled, otherwise non zero (usually 1).
    GLS_EXPORT int handle( int );
 
    /** Constructor for window
      * \param x Initial x loc of window
      * \param y Initial y loc of window
      * \param w Initial width of window
      * \param h Initial height of window
      * \param l Window title
      * \param frame_  Display to associate with window */
    GLS_EXPORT OpenGLWindow( int x, int y, int w, int h, const char* l, glsDisplayFrame* frame_ );
 
    /** Grabs the window contents and saves them to an uncompressed 24 bit BMP file
      * \param filename  Name of the file to write a BMP to
      */
    GLS_EXPORT void GrabWindow( char* filename );
 
    /** Converts mouse window coordinates to logical simulation coordinates.
      * \param frame DisplayFrame to convert for
      * \param x Mouse Device coordinate
      * \param y Mouse Device coordinate
      * \param lx Filled in with logical X coordinate
      * \param ly Filled in with logical Y coordinate
      */
    GLS_EXPORT void WindowToLogical( glsDisplayFrame* frame, float x, float y, float& lx, float& ly );
};
 
typedef void ( *GlsDrawCallback )( glsDisplayFrame* ); ///< Typedef for a function pointer used for pre/post draw callbacks.
 
/** GL Studio standalone application class.
  * Creates one window and draws all contents in it.
  */
class glsDisplayFrame : public RuntimeDisplayFrame
{
protected:
    GlsDrawCallback _preDrawCallback;  /**< A function pointer that will be called prior to the Draw method being called */
    GlsDrawCallback _postDrawCallback; /**< A function pointer that will be called after the Draw method is called */
 
    SplashDisplay* splashDisplay; /**< The Spash screen image */
 
    bool _sKeyTogglesStatistics; /**< When true, the [s] key toggles statistics */
    bool _escKeyExits;           /**< When true, the [Esc] key exits the application */
 
    /* \see DisplayFrame */
    virtual GLS_EXPORT EventCompressor<DisplayFrame>* GetEventCompressor() DISTI_METHOD_OVERRIDE { return &eventCompressor; }
 
public:
    OpenGLWindow* theWindow; /**< The window associated with this DisplayFrame */
 
    /** Used for event compression.  Not for general use by users. */
    EventCompressor<DisplayFrame> eventCompressor;
 
    /** Creates this glsDisplayFrame
      * \param name  Window Title
      * \param width Width of Dsplay Frame in pixels
      * \param height Width of Dsplay Frame in pixels
      */
    GLS_EXPORT glsDisplayFrame( const char* name, int width, int height );
 
    virtual GLS_EXPORT ~glsDisplayFrame();
 
    /** Removes (hides) the spash screen */
    virtual GLS_EXPORT void RemoveSplash();
 
    /** Creates the spash screen */
    virtual GLS_EXPORT void CreateSplash();
 
    /** Creates this display frame.  Called after the constructor so that things that need to
      * access the OpenGL context can safely do so */
    virtual GLS_EXPORT void Create();
 
    /** Sets up the default Orthographic projection (which supports things like pan and zoom) */
    virtual GLS_EXPORT void SetProjection();
 
    /// \see RuntimeDisplayFrame
    /// \note Overridden to return true if any window is open.
    /// \return True if any window is open.
    GLS_EXPORT bool FrameAnimate() DISTI_METHOD_OVERRIDE;
 
    /** \see RuntimeDisplayFrame */
    GLS_EXPORT void Paint() DISTI_METHOD_OVERRIDE;
 
    /** Redraw the window now.  
      * This actually calls the OpenGL Drawing routines. 
      */
    virtual GLS_EXPORT void Redraw();
 
    /** \see DisplayFrame.  On Desktop, this also triggers the frame to redraw.  This function is deprecated and should not be called by user code.  Call Invalidate() from the GlsPainterInterface
      * to signal that the frame needs to be redrawn (if using conditional animation), and call Paint() to trigger the displayframe to redraw.
      * \deprecated
      */
    GLS_EXPORT void SetRedraw() DISTI_METHOD_OVERRIDE;
 
    /** Set the dimensions for the display frame window
      * \param X  New X coordinate of window
      * \param Y  New Y coordinate of window
      * \param W  New width of window
      * \param H  New height of window
      */
    virtual GLS_EXPORT void SetWindowDimensions( int X, int Y, int W, int H );
 
    /** Get the dimensions for the display frame window
      * \param X Gets X coordinate of window
      * \param Y Gets Y coordinate of window
      * \param W Gets width of window
      * \param H Gets height of window
      */
    virtual GLS_EXPORT void GetWindowDimensions( int& X, int& Y, int& W, int& H );
 
    /// Sets the post draw callback to the function pointer passed in.
    /// \param cb The new callback to use.
    virtual GLS_EXPORT void PostDrawCallback( GlsDrawCallback cb );
 
    /// Sets the pre draw callback to the function pointer passed in.
    /// \param cb The new callback to use.
    virtual GLS_EXPORT void PreDrawCallback( GlsDrawCallback cb );
 
    /** Sets the mode flags for the window
      * \param flags  The mode flags
      */
    virtual GLS_EXPORT void WindowFlags( unsigned long flags );
 
    /** Called after calling handle.  
      * \param handled True when the event has already been handled
      * \param ev the pointer to the the event
      * \return True If PostHandle has handled the event.
      * Checks for statistics toggle [s] key, and [ESC] key press.
      * The user can override this to turn off these behaviors.
      */
    virtual GLS_EXPORT bool PostHandle( bool handled, DisplayEvent* ev );
 
    /** Causes the window to center the view on the specified logical coordinate.  
      * It takes into account the possible rotation of the top group. 
      * \param lx  Logical X Coordinate
      * \param ly  Logical Y Coordinate
      */
    virtual GLS_EXPORT void CenterOnLogical( float lx, float ly );
 
    /** \return Whether or not the 'S' key is enabled for controlling statistics 
      */
    virtual GLS_EXPORT bool SKeyTogglesStatistics();
 
    /** Enable/disable s key for toggling statistics
      * \param flag  Whether or not S key will toggle statistics
      */
    virtual GLS_EXPORT void SKeyTogglesStatistics( bool flag );
 
    /** \return Whether or not the ESC key exits application
      */
    virtual GLS_EXPORT bool EscKeyExits();
 
    /** Enable/disable ESC key for exiting application
      * \param flag  Whether or not ESC key exits application
      */
    virtual GLS_EXPORT void EscKeyExits( bool flag );
};
 
} // namespace disti
 
#endif
#endif