include/cinder/app/App.h

Go to the documentation of this file.

/*
 Copyright (c) 2012, The Cinder Project, All rights reserved.

 This code is intended for use with the Cinder C++ library: http://libcinder.org

 Redistribution and use in source and binary forms, with or without modification, are permitted provided that
 the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and
    the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
    the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include "cinder/Cinder.h"
#include "cinder/app/Renderer.h"
#include "cinder/app/Window.h"
#include "cinder/Vector.h"
#include "cinder/app/MouseEvent.h"
#include "cinder/app/KeyEvent.h"
#include "cinder/app/FileDropEvent.h"
#include "cinder/Display.h"
#include "cinder/DataSource.h"
#include "cinder/Timer.h"
#include "cinder/Function.h"
#include "cinder/Thread.h"
#if defined( CINDER_COCOA )
    #if defined( CINDER_COCOA_TOUCH )
        #if defined( __OBJC__ )
            #import <UIKit/UIKit.h>
            #import <CoreFoundation/CoreFoundation.h>
        #endif
    #else
        #include <ApplicationServices/ApplicationServices.h>
    #endif
    #if defined __OBJC__
        @class CinderView;
        @class NSBundle;
    #else
        class NSBundle;
    #endif
//  class CinderView;
#elif defined( CINDER_MSW )
    #include "cinder/msw/OutputDebugStringStream.h"
#endif

#include <vector>
#include <algorithm>

namespace cinder {
class Timeline;
} // namespace cinder

namespace boost { namespace asio {
class io_service;
} } // namespace boost::asio

namespace cinder { namespace app { 


struct BooleanOrEventCombiner {
    typedef bool    result_type;

    template<typename InputIterator>
    bool    operator()( InputIterator first, InputIterator last ) const
    {
        bool handled = ( first == last ) ? true : false;
        while( first != last )
            handled = *first++ || handled;
        
        return handled;
    }
};

struct BooleanAndEventCombiner {
    typedef bool    result_type;

    template<typename InputIterator>
    bool    operator()( InputIterator first, InputIterator last ) const
    {
        bool result = true;
        while( first != last )
            result = *first++ && result;
        
        return result;
    }
};

template<typename T>
struct BitwiseAndEventCombiner {
    typedef T   result_type;

    template<typename InputIterator>
    T   operator()( InputIterator first, InputIterator last ) const
    {
        if( first == last )
            return 0;
        T mask = *first++;
        while( first != last )
            mask &= *first++;

        return mask;
    }
};

class App {
 public:
    class Settings {
      public:
        // whether or not the app should terminate prior to launching
        bool    isPrepared() const { return ! mShouldQuit; };

        void    setWindowSize( int windowSizeX, int windowSizeY ) { mDefaultWindowFormat.setSize( Vec2i( windowSizeX, windowSizeY ) ); }
        void    setWindowSize( const Vec2i &size ) { mDefaultWindowFormat.setSize( size ); }
        Vec2i   getWindowSize() const { return mDefaultWindowFormat.getSize(); }
        
        Vec2i   getWindowPos() const { return mDefaultWindowFormat.getPos(); }
        void    setWindowPos( int windowPosX, int windowPosY ) { mDefaultWindowFormat.setPos( Vec2i( windowPosX, windowPosY ) ); }
        void    setWindowPos( const Vec2i &windowPos ) { mDefaultWindowFormat.setPos( windowPos ); }
        bool    isWindowPosSpecified() const { return mDefaultWindowFormat.isPosSpecified(); }
        void    unspecifyWindowPos() { mDefaultWindowFormat.unspecifyPos(); }

        bool    isFullScreen() { return mDefaultWindowFormat.isFullScreen(); }
        void    setFullScreen( bool fullScreen = true, const FullScreenOptions &options = FullScreenOptions() ) { mDefaultWindowFormat.setFullScreen( fullScreen, options ); }

        bool    isResizable() const { return mDefaultWindowFormat.isResizable(); }
        void    setResizable( bool resizable = true ) { mDefaultWindowFormat.setResizable( resizable ); }
        bool    isBorderless() const { return mDefaultWindowFormat.isBorderless(); }
        void    setBorderless( bool borderless = true ) { mDefaultWindowFormat.setBorderless( borderless ); }
        bool    isAlwaysOnTop() const { return mDefaultWindowFormat.isAlwaysOnTop(); }
        void    setAlwaysOnTop( bool alwaysOnTop = true ) { mDefaultWindowFormat.setAlwaysOnTop( alwaysOnTop ); }

        DisplayRef  getDisplay() const { return mDefaultWindowFormat.getDisplay(); }
        void        setDisplay( DisplayRef display ) { mDefaultWindowFormat.setDisplay( display ); }

        void        prepareWindow( const Window::Format &format );
        std::vector<Window::Format>&        getWindowFormats() { return mWindowFormats; }
        const std::vector<Window::Format>&  getWindowFormats() const { return mWindowFormats; }\

        void        enableHighDensityDisplay( bool enable = true ) { mEnableHighDensityDisplay = enable; }
        bool        isHighDensityDisplayEnabled() const { return mEnableHighDensityDisplay; }

        Window::Format      getDefaultWindowFormat() const { return mDefaultWindowFormat; }
        void                setDefaultWindowFormat( const Window::Format &format ) { mDefaultWindowFormat = format; }

        void        enableMultiTouch( bool enable = true ) { mEnableMultiTouch = enable; }
        bool        isMultiTouchEnabled() const { return mEnableMultiTouch; }

        void    enablePowerManagement( bool aPowerManagement = true );
        bool    isPowerManagementEnabled() const { return mPowerManagement; }

        const std::string&  getTitle() const { return mTitle; }
        void                setTitle( const std::string &title ) { mTitle = title; }

        void    setFrameRate( float frameRate );
        void    disableFrameRate();
        bool    isFrameRateEnabled() const { return mFrameRateEnabled; }
        float   getFrameRate() const { return mFrameRate; }
        
        Settings();
        virtual ~Settings() {}    

      protected:
        bool            mShouldQuit; // defaults to false, facilitates early termination

        // A vector of Windows which have been requested using prepareWindow. An empty vector implies defaults.
        std::vector<Window::Format>     mWindowFormats;
        // The Window format which will be used if prepareWindow is not called
        Window::Format                  mDefaultWindowFormat;
            
        bool            mFrameRateEnabled;
        float           mFrameRate;
        bool            mPowerManagement; // allow screensavers or power management to hide app. default: false
        bool            mEnableHighDensityDisplay;
        bool            mEnableMultiTouch;
        std::string     mTitle;
        
        friend class App;
    };


 public:
    // interface
    App();
    virtual ~App();

    virtual void    setup() {}
    virtual void    shutdown() {}

    virtual void    update() {}
    virtual void    draw() {}
    
    virtual void    mouseDown( MouseEvent event ) {}
    virtual void    mouseUp( MouseEvent event ) {}  
    virtual void    mouseWheel( MouseEvent event ) {}
    virtual void    mouseMove( MouseEvent event ) {}
    virtual void    mouseDrag( MouseEvent event ) {}    

    virtual void    touchesBegan( TouchEvent event ) {}
    virtual void    touchesMoved( TouchEvent event ) {}
    virtual void    touchesEnded( TouchEvent event ) {}
    
    virtual void    keyDown( KeyEvent event ) {}
    virtual void    keyUp( KeyEvent event ) {}
    virtual void    resize() {}
    virtual void    fileDrop( FileDropEvent event ) {}
    
    virtual void    quit() = 0;

    signals::signal<void()>&    getSignalUpdate() { return mSignalUpdate; }

    signals::signal<void()>&    getSignalShutdown() { return mSignalShutdown; }
    void                        emitShutdown();

    const std::vector<TouchEvent::Touch>&   getActiveTouches() const { return getWindow()->getActiveTouches(); }

    // Accessors
    virtual const Settings& getSettings() const = 0;
    RendererRef         getRenderer() const { return getWindow()->getRenderer(); }
    DisplayRef          getDisplay() const { return getWindow()->getDisplay(); }

    virtual WindowRef   getWindow() const = 0;
    virtual size_t      getNumWindows() const = 0;
    virtual WindowRef   getWindowIndex( size_t index ) const = 0;

    virtual void    enablePowerManagement( bool powerManagement = true ) { mPowerManagement = powerManagement; }
    virtual bool    isPowerManagementEnabled() const { return mPowerManagement; }
    
    int                 getWindowWidth() const { return getWindow()->getWidth(); }
    int                 getWindowHeight() const { return getWindow()->getHeight(); }
    void                setWindowSize( int windowWidth, int windowHeight ) { setWindowSize( Vec2i( windowWidth, windowHeight ) ); }
    void                setWindowSize( const Vec2i &size ) { getWindow()->setSize( size ); }

    Vec2f               getWindowCenter() const { return Vec2f( (float)getWindowWidth(), (float)getWindowHeight() ) * 0.5f; }
    Vec2i               getWindowSize() const { return Vec2i( getWindowWidth(), getWindowHeight() ); }
    float               getWindowAspectRatio() const { return getWindowWidth() / (float)getWindowHeight(); }

    Area                getWindowBounds() const { return Area( 0, 0, getWindowWidth(), getWindowHeight() ); }
    float               getWindowContentScale() const { return getWindow()->getContentScale(); }
    
    Vec2i               getWindowPos() const { return getWindow()->getPos(); }
    int                 getWindowPosX() const { return getWindow()->getPos().x; }
    int                 getWindowPosY() const { return getWindow()->getPos().y; }
    void                setWindowPos( int x, int y ) { setWindowPos( Vec2i( x, y ) ); }
    virtual void        setWindowPos( const Vec2i &windowPos ) { getWindow()->setPos( windowPos ); }
    
    virtual float       getFrameRate() const = 0;
    virtual void        setFrameRate( float frameRate ) = 0;
    float               getAverageFps() const { return mAverageFps; }
    double              getFpsSampleInterval() const { return mFpsSampleInterval; }
    void                setFpsSampleInterval( double sampleInterval ) { mFpsSampleInterval = sampleInterval; }  

    bool                isFullScreen() const { return getWindow()->isFullScreen(); }
    void                setFullScreen( bool aFullScreen, const FullScreenOptions &options = FullScreenOptions() ) { getWindow()->setFullScreen( aFullScreen, options ); }

    double              getElapsedSeconds() const { return mTimer.getSeconds(); }
    uint32_t            getElapsedFrames() const { return mFrameCount; }

    static Vec2i        getMousePos();
    
    // utilities
    static DataSourceRef        loadResource( const std::string &macPath, int mswID, const std::string &mswType );
#if defined( CINDER_COCOA )

    static DataSourceRef        loadResource( const std::string &macPath );
    static fs::path             getResourcePath( const fs::path &rsrcRelativePath );
    static fs::path             getResourcePath();
#else

    static DataSourceRef        loadResource( int mswID, const std::string &mswType );
#endif
    
    DataSourceRef           loadAsset( const fs::path &relativePath );
    fs::path                getAssetPath( const fs::path &relativePath );
    void                    addAssetDirectory( const fs::path &dirPath );
    
    virtual fs::path            getAppPath() const = 0;
#if defined( CINDER_COCOA )

    virtual NSBundle*           getBundle() const;
#endif


    fs::path        getOpenFilePath( const fs::path &initialPath = "", std::vector<std::string> extensions = std::vector<std::string>() );
    fs::path        getFolderPath(const fs::path &initialPath="");

    fs::path        getSaveFilePath( const fs::path &initialPath = "", std::vector<std::string> extensions = std::vector<std::string>() );

    std::ostream&   console();
    
    Timeline&       timeline() { return *mTimeline; }

    static bool     isPrimaryThread();

    boost::asio::io_service&    io_service() { return *mIo; }
    
    
    
    void    dispatchAsync( const std::function<void()> &fn );
    
    template<typename T>
    typename std::result_of<T()>::type dispatchSync( T fn )
    {
        if( isPrimaryThread() )
            return fn();
        else {
            typedef typename std::result_of<T()>::type result_type;
#if defined( _MSC_VER ) && ( _MSC_VER <= 1600 ) // slightly different signature with Boost.Thread
            std::packaged_task<result_type> task( std::move(fn) );
#else
            std::packaged_task<result_type()> task( std::move(fn) );
#endif
            auto fute = task.get_future();
            dispatchAsync( [&task]() { task(); } );
            return fute.get();
        }
    }

    RendererRef getDefaultRenderer() const { return mDefaultRenderer; }
    Surface copyWindowSurface();
    Surface copyWindowSurface( const Area &area );
    void    restoreWindowContext();

    RendererRef     findSharedRenderer( RendererRef searchRenderer ) const;
    
    // DO NOT CALL - should be private but aren't for esoteric reasons
    // Internal handlers - these are called into by AppImpl's. If you are calling one of these, you have likely strayed far off the path.
    virtual void    privateSetup__();
    virtual void    privateUpdate__();

#if defined( CINDER_MSW )
    // Not all Windows target types receive paint events, and the AppImplMswRenderer* needs to know that.
    virtual bool        getsWindowsPaintEvents() = 0;
#endif

    virtual bool        receivesEvents() const { return true; }

    static App*         get() { return sInstance; }

  protected:
    // These are called by application instantation macros and are only used in the launch process
    static void     prepareLaunch();
    static void     executeLaunch( App *app, RendererRef defaultRenderer, const char *title, int argc, char * const argv[] );
    static void     cleanupLaunch();
    
    virtual void    launch( const char *title, int argc, char * const argv[] ) = 0;
    

#if defined( CINDER_MSW )
    friend class AppImplMsw;
    std::shared_ptr<std::ostream>   mOutputStream;
#endif

  private:
      void      prepareAssetLoading();
      fs::path  findAssetPath( const fs::path &relativePath );
  
#if defined( CINDER_COCOA )
    static void             *sAutoReleasePool;
#endif

    Timer                   mTimer;
    uint32_t                mFrameCount;
    float                   mAverageFps;
    uint32_t                mFpsLastSampleFrame;
    double                  mFpsLastSampleTime;
    double                  mFpsSampleInterval;

    std::shared_ptr<Timeline>   mTimeline;

    signals::signal<void()>     mSignalUpdate, mSignalShutdown;
    
    std::shared_ptr<boost::asio::io_service>    mIo;
    std::shared_ptr<void>                       mIoWork; // boost::asio::io_service::work, but can't fwd declare member class
    
    // have we already setup the default path to assets?
    bool                        mAssetDirectoriesInitialized;
    // Path to directories which contain assets
    std::vector<fs::path>       mAssetDirectories;
    
  protected:
    static App*                 sInstance;
    RendererRef                 mDefaultRenderer;
    bool                        mPowerManagement;
};

inline WindowRef    getWindow() { return App::get()->getWindow(); }
inline size_t       getNumWindows() { return App::get()->getNumWindows(); }
inline WindowRef    getWindowIndex( size_t index ) { return App::get()->getWindowIndex( index ); }

inline int  getWindowWidth() { return App::get()->getWindowWidth(); }
inline void     setWindowPos( const Vec2i &windowPos ) { App::get()->setWindowPos( windowPos);  }
inline void     setWindowPos( int x, int y ) { setWindowPos( Vec2i( x, y ) );  }
inline int  getWindowHeight() { return App::get()->getWindowHeight(); }
inline void     setWindowSize( int windowWidth, int windowHeight ) { App::get()->setWindowSize( windowWidth, windowHeight ); }

inline Vec2f    getWindowCenter() { return App::get()->getWindowCenter(); }
inline Vec2i    getWindowSize() { return App::get()->getWindowSize(); }
inline Vec2i    getWindowPos() { return App::get()->getWindowPos(); }
inline float    getWindowAspectRatio() { return App::get()->getWindowAspectRatio(); }

inline Area     getWindowBounds() { return App::get()->getWindowBounds(); }
inline float    getWindowContentScale() { return App::get()->getWindowContentScale(); }
inline float    getFrameRate() { return App::get()->getFrameRate(); }
inline void     setFrameRate( float frameRate ) { App::get()->setFrameRate( frameRate ); }
inline bool     isFullScreen() { return App::get()->isFullScreen(); }
inline void     setFullScreen( bool fullScreen = true ) { App::get()->setFullScreen( fullScreen ); }

inline float    toPixels( float s ) { return getWindow()->toPixels( s ); }
inline Vec2f    toPixels( Vec2f s ) { return getWindow()->toPixels( s ); }
inline  Vec2i   toPixels( Vec2i s ) { return app::getWindow()->toPixels( s ); }
inline  Area    toPixels( const Area &a ) { return getWindow()->toPixels( a ); }
inline  Rectf   toPixels( const Rectf &a ) { return getWindow()->toPixels( a ); }
inline  float   toPoints( float s ) { return getWindow()->toPoints( s ); }
inline  Vec2f   toPoints( Vec2f s ) { return getWindow()->toPoints( s ); }
inline  Vec2i   toPoints( Vec2i s ) { return getWindow()->toPoints( s ); }
inline  Area    toPoints( const Area &a ) { return getWindow()->toPoints( a ); }
inline  Rectf   toPoints( const Rectf &a ) { return getWindow()->toPoints( a ); }

inline double   getElapsedSeconds() { return App::get()->getElapsedSeconds(); }
inline uint32_t getElapsedFrames() { return App::get()->getElapsedFrames(); }

inline DataSourceRef        loadResource( const std::string &macPath, int mswID, const std::string &mswType ) { return App::loadResource( macPath, mswID, mswType ); }
#if defined( CINDER_COCOA )

    inline DataSourceRef    loadResource( const std::string &macPath ) { return App::loadResource( macPath ); }
#else

    inline DataSourceRef    loadResource( int mswID, const std::string &mswType ) { return App::loadResource( mswID, mswType ); }
#endif

inline DataSourceRef        loadAsset( const fs::path &relativePath ) { return App::get()->loadAsset( relativePath ); }
inline fs::path             getAssetPath( const fs::path &relativePath ) { return App::get()->getAssetPath( relativePath ); }
inline void                 addAssetDirectory( const fs::path &dirPath ) { App::get()->addAssetDirectory( dirPath ); }

inline fs::path     getAppPath() { return App::get()->getAppPath(); }

inline fs::path     getOpenFilePath( const fs::path &initialPath = "", std::vector<std::string> extensions = std::vector<std::string>() ) { return App::get()->getOpenFilePath( initialPath, extensions ); }

inline fs::path     getSaveFilePath( const fs::path &initialPath = "", std::vector<std::string> extensions = std::vector<std::string>() ) { return App::get()->getSaveFilePath( initialPath, extensions ); }


inline std::ostream&    console() { return App::get()->console(); }

inline Timeline&    timeline() { return App::get()->timeline(); }

inline Surface  copyWindowSurface() { return App::get()->copyWindowSurface(); }
inline Surface  copyWindowSurface( const Area &area ) { return App::get()->copyWindowSurface( area ); }
inline void     restoreWindowContext() { return App::get()->restoreWindowContext(); }

#if defined( CINDER_COCOA )

inline ::CGContextRef   createWindowCgContext() { return (std::dynamic_pointer_cast<Renderer2d>(App::get()->getRenderer()))->getCgContext(); }
#endif


class ResourceLoadExc : public Exception {
  public:
#if defined( CINDER_COCOA )
    ResourceLoadExc( const std::string &macPath );
#elif defined( CINDER_MSW )
    ResourceLoadExc( int mswID, const std::string &mswType );
    ResourceLoadExc( const std::string &macPath, int mswID, const std::string &mswType );
#endif

    virtual const char * what() const throw() { return mMessage; }

    char mMessage[4096];
};

class AssetLoadExc : public Exception {
  public:
    AssetLoadExc( const fs::path &relativePath );

    virtual const char * what() const throw() { return mMessage; }

    char mMessage[4096];
};

} } // namespace cinder::app