ScreenShotter.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_SCREENSHOT_H
#define GNASH_SCREENSHOT_H

#include <vector>
#include <string>
#include <boost/shared_ptr.hpp>
#include <set>
#include <algorithm>
#include <boost/lexical_cast.hpp>

#include "GnashEnums.h"

namespace gnash {
    class Renderer;
}

namespace gnash {

class ScreenShotter
{
public:

    typedef std::vector<size_t> FrameList;

    ScreenShotter(const std::string& fileName, int quality = 100);
    
    ScreenShotter(const std::string& fileName, FileType f, int quality = 100);

    ~ScreenShotter();

    void now() {
        _immediate = true;
    }

    void lastFrame() {
        _last = true;
    }

    struct NoAction { void operator()() const {} };

    //
    //
    void last(const Renderer& r) const {
        last<NoAction>(r);
    }

    //
    //
    template<typename Action>
    void last(const Renderer& r, Action* t = 0) const
    {
        if (_last) {
            if (t) (*t)();
            saveImage(r, "last");
        }
    }

    //
    //
    void screenShot(const Renderer& r, size_t frameAdvance) {
        screenShot<NoAction>(r, frameAdvance);
    }

    //
    //
    template<typename Action>
    void screenShot(const Renderer& r, size_t frameAdvance, Action* t = 0) {
        // Save an image if a spontaneous screenshot was requested or the
        // frame is in the list of requested frames.
        if (_immediate || std::binary_search(_frames.begin(), _frames.end(),
                    frameAdvance)) {

            // Check whether we've rendered an image for this frame.
            if (_done.find(frameAdvance) != _done.end()) {
                return;
            }
            if (t) (*t)();
            _done.insert(frameAdvance);

            saveImage(r, boost::lexical_cast<std::string>(frameAdvance));
            _immediate = false;
        }
        
    }

    void setFrames(const FrameList& frames);

private:

    void saveImage(const Renderer& r, const std::string& filename) const;

    bool _immediate;

    const std::string _fileName;

    bool _last;

    FrameList _frames;

    const FileType _type;

    const int _quality;

    std::set<int> _done;

};
 
} // end of gnash namespace

#endif

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