gui.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
//   2011 Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_GUI_H
#define GNASH_GUI_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include <boost/intrusive_ptr.hpp>
#include <memory>
#include <string>
#include <map>
#include <utility>
#include <functional>

#include "snappingrange.h"  // for InvalidatedRanges
#include "GnashKey.h"
#include "VirtualClock.h"
#include "SystemClock.h"
#include "GnashEnums.h" 
#include "movie_root.h"

#ifdef USE_SWFTREE
#include "tree.hh" // for tree
#endif

// Define this to enable fps debugging without touching
// gnashconfig.h
//#define GNASH_FPS_DEBUG

//#define DISABLE_REGION_UPDATES_DEBUGGING 1


#define ENABLE_KEYBOARD_MOUSE_MOVEMENTS 1

// Forward declarations
namespace gnash {
    class SWFRect;
    class ScreenShotter;
    class RunResources;
    class movie_root;
    class movie_definition;
    class Renderer;
    class SWFRect;
}
namespace boost {
    template <typename Signature> class function;
}

namespace gnash {

enum gnash_cursor_type {
  CURSOR_HAND,
  CURSOR_NORMAL,
  CURSOR_INPUT
};

class Gui {

public:

    virtual ~Gui();

    virtual bool init(int argc, char **argv[]) = 0;

    virtual void setInterval(unsigned int interval) {
      _interval = interval;
    }

    //
    virtual VirtualClock& getClock() { return _virtualClock; }

    virtual void setTimeout(unsigned int timeout) = 0;

    void setScreenShotter(std::unique_ptr<ScreenShotter> ss);

    virtual bool createWindow(const char* title, int width, int height,
                       int xPosition = 0, int yPosition = 0) = 0;

    virtual void resizeWindow(int width, int height);

    virtual bool run() = 0;

    //
    void quit();

    virtual void renderBuffer() = 0;

    //
    // does not need to be implemented (optional feature),
    // but still needs to be available.
    //
    virtual void setInvalidatedRegion(const SWFRect& bounds);
    virtual void setInvalidatedRegions(const InvalidatedRanges& ranges);
    
    // Called right before rendering anything (after setInvalidatedRegion).
    // Used by GTK-AGG.
    virtual void beforeRendering() { /* nop */ };
    
    // Should return TRUE when the GUI/Renderer combination supports multiple
    // invalidated bounds regions. 
    virtual bool want_multiple_regions() { return false; }

    //
    virtual bool want_redraw();

    virtual void setCursor(gnash_cursor_type newcursor);

    virtual void setClipboard(const std::string& copy);

    // Information for System.capabilities to be reimplemented in
    // each gui.
    virtual double getPixelAspectRatio() const { return 0; }

    virtual std::pair<int, int> screenResolution() const {
        return std::make_pair(0, 0);
    }

    virtual double getScreenDPI() const { return 0; }

    //
    virtual std::string getScreenColor() const {
        return "color";
    }

    bool loops() const { return _loop; }

    bool isFullscreen() const { return _fullscreen; }

    //
    void notifyMouseMove(int x, int y);

    //
    void notifyMouseClick(bool mouse_pressed);

    //
    void notifyMouseWheel(int delta);

    //
    void notify_key_event(gnash::key::code k, int modifier, bool pressed);

    //
    void resize_view(int width, int height);

    //
    void updateStageMatrix();

    //
    bool advanceMovie(bool doDisplay = true);

    //
    static bool advance_movie(Gui* gui) {
        gui->advanceMovie();
        return true;
    }

    void refreshView();

    //
    virtual void setFullscreen();

    virtual void unsetFullscreen();

    virtual void hideMenu();
    
    //
    virtual bool showMouse(bool show);

    //
    virtual void showMenu(bool show);

    //
    virtual void allowScale(bool allow);
    
    // Toggle between fullscreen and normal mode
    void toggleFullscreen();

    //
    void stop();

    //
    void play();

    //
    void pause();

    //
    void start();

    bool isStopped() const { return _stopped; }
    
    bool isPlugin() const { return ((_xid)); }

    void takeScreenShot();

    void setMaxAdvances(unsigned long ul) { if (ul) _maxAdvances = ul; }
    
    void showUpdatedRegions(bool x) { _showUpdatedRegions = x; }
    bool showUpdatedRegions() const { return _showUpdatedRegions; }

    void restart();

    void setQuality(Quality q);

    Quality getQuality() const;

    void toggleSound();

#ifdef GNASH_FPS_DEBUG
    //
    void setFpsTimerInterval(float interval)
    {
            assert(interval >= 0.0);
            fps_timer_interval = interval;
    }
#endif // def GNASH_FPS_DEBUG


#ifdef USE_SWFTREE
    std::unique_ptr<movie_root::InfoTree> getMovieInfo() const;
#endif

    typedef std::map<std::string, std::string> VariableMap;

    void addFlashVars(VariableMap& vars);

    void setMovieDefinition(movie_definition* md);

    void setStage(movie_root* stage);

    void setAudioDump(const std::string& fname) {
        _audioDump = fname;
    }

    movie_root* getStage() { return _stage; };
    
    //
    virtual void error(const std::string& /*msg*/) {}

    //
    virtual bool yesno(const std::string& question);

    float getXScale() const { return _xscale; };

    float getYScale() const { return _yscale; };

    float getFPS() const { return (_movieDef) ? _movieDef->get_frame_rate() : 0;
    };

protected:

    Gui(RunResources& r);

    Gui(unsigned long xid, float scale, bool loop, RunResources& r);
    
    //
    //
    virtual void quitUI() {
        std::exit(EXIT_SUCCESS);
    }

    //
    virtual bool watchFD(int /* fd */)
    {
        log_unimpl("This GUI does not implement FD watching.");
        return false;
    }


    bool _loop;

    unsigned long _xid;

    // This would be 0,0,_width,_height, so maybe
    // we should not duplicate the info with those
    // explicit values too..
    geometry::Range2d<int> _validbounds;

    int _width;

    int _height;

    RunResources& _runResources;

    unsigned int _interval;

    std::shared_ptr<Renderer> _renderer;

    bool _redraw_flag;

    // True if Gnash is running in fullscreen
    bool _fullscreen;

    // True if mouse pointer is showing
    bool _mouseShown;

    // Maximum number of advances before exit; 0 for no limit.
    unsigned long _maxAdvances;
    
    unsigned long _advances;

    std::string _audioDump;

    virtual void stopHook() {}

    virtual void playHook() {}

    virtual bool visible() { return true; }
private:

    struct Display;

    std::map<int /* fd */, std::function<void ()> > _fd_callbacks;

    float _xscale;

    float _yscale;

    std::int32_t _xoffset;

    std::int32_t _yoffset;

    bool display(movie_root* m);
    
#ifdef GNASH_FPS_DEBUG
    unsigned int fps_counter;

    float fps_rate_min, fps_rate_max;   

    // Number of calls to fpsCounterTick, which is also
    // the number of calls to movie_advance()
    unsigned int fps_counter_total;

    std::uint64_t fps_timer, fps_start_timer;

    //
    float fps_timer_interval;
    
    unsigned int frames_dropped;

    //
    void fpsCounterTick();

#endif // def GNASH_FPS_DEBUG

    VariableMap _flashVars;

    boost::intrusive_ptr<movie_definition> _movieDef;
    
    movie_root* _stage;

    bool _stopped;

    bool _started;

    bool _showUpdatedRegions;

    SystemClock _systemClock;
    InterruptableVirtualClock _virtualClock;
    
    std::unique_ptr<ScreenShotter> _screenShotter;

#ifdef ENABLE_KEYBOARD_MOUSE_MOVEMENTS 
    int _xpointer;
    int _ypointer;
    bool _keyboardMouseMovements;
    int _keyboardMouseMovementsStep;
#endif // ENABLE_KEYBOARD_MOUSE_MOVEMENTS
};

namespace gui {
  std::unique_ptr<Gui> createFBGui(unsigned long xid, float scale, bool loop, RunResources& r);
}
std::unique_ptr<Gui> createGTKGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createKDEGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createQt4Gui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createSDLGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createFLTKGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createAQUAGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createRISCOSGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createAOS4Gui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createHaikuGui(unsigned long xid, float scale, bool loop, RunResources& r);
std::unique_ptr<Gui> createDumpGui(unsigned long xid, float scale, bool loop, RunResources& r);

 
} // end of gnash namespace

// end of _GUI_H_
#endif

// Local Variables:
// mode: C++
// indent-tabs-mode: nil
// End: