rc.h

Go to the documentation of this file.

// rc.h:  "Run Command" configuration file declarations, for Gnash.
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   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_RC_H
#define GNASH_RC_H

#include "dsodefs.h"
#include <string>
#include <vector>
#include <iosfwd>
#include <sstream>
#include <boost/cstdint.hpp>
#include <boost/tokenizer.hpp>

#include "StringPredicates.h"

#if !defined(_WIN32) && !defined(__HAIKU__) && !defined(ANDROID)
#include <sys/shm.h>
#else
#ifdef _WIN32
  typedef boost::uint32_t key_t;
#endif // _WIN32
#endif // _WIN32 and __HAIKU__

namespace gnash {
  
class DSOEXPORT RcInitFile 
{
public:

    static RcInitFile& getDefaultInstance();

    //
    void loadFiles();

    bool parseFile(const std::string& filespec);

    //
    bool updateFile(const std::string& filespec);
    
    //
    bool updateFile();
    
    bool useSplashScreen() const { return _splashScreen; }
    void useSplashScreen(bool value);

    bool useActionDump() const { return _actionDump; }
    void useActionDump(bool value);

    bool useParserDump() const { return _parserDump; }
    void useParserDump(bool value);

    bool useWriteLog() const { return _writeLog; }
    void useWriteLog(bool value);

    int getTimerDelay() const { return _delay; }
    void setTimerDelay(int x) { _delay = x; }

    bool showASCodingErrors() const { return _verboseASCodingErrors; }
    void showASCodingErrors(bool value);

    bool showMalformedSWFErrors() const { return _verboseMalformedSWF; }
    void showMalformedSWFErrors(bool value);

    bool showMalformedAMFErrors() const { return _verboseMalformedAMF; }
    void showMalformedAMFErrors(bool value);

    int getMovieLibraryLimit() const { return _movieLibraryLimit; }
    void setMovieLibraryLimit(int value) { _movieLibraryLimit = value; }

    bool enableExtensions() const { return _extensionsEnabled; }

    //
    bool startStopped() const { return _startStopped; }
    void startStopped(bool value) { _startStopped = value; }

    bool insecureSSL() const { return _insecureSSL; }
    void insecureSSL(bool value) { _insecureSSL = value; }
    
    int qualityLevel() const { return _quality; }
    void qualityLevel(int value) { _quality = value; }
    
    int verbosityLevel() const { return _verbosity; }
    void verbosityLevel(int value) { _verbosity = value; }
    
    void setDebugLog(const std::string &x) { _log = x; }
    const std::string& getDebugLog() const { return _log; }

    void setDocumentRoot(const std::string &x) { _wwwroot = x; }
    std::string getDocumentRoot() { return _wwwroot; }
    
    bool useDebugger() const { return _debugger; }
    void useDebugger(bool value) { _debugger = value; }

    bool useSound() const { return _sound; }
    void useSound(bool value) { _sound = value; }

    // strk: I'd drop this, and allow an -f switch to select
    //       the gnashrc file to use instead
    bool usePluginSound() const { return _pluginSound; }
    void usePluginSound(bool value) { _pluginSound = value; }

    bool popupMessages() const { return _popups; }
    void interfacePopups(bool value) { _popups = value; }

    bool useLocalDomain() const { return _localdomainOnly; }
    void useLocalDomain(bool value);

    bool useLocalHost() const { return _localhostOnly; }

    void useLocalHost(bool value);

    typedef std::vector<std::string> PathList;

    //
    const PathList& getWhiteList() const { return _whitelist; }

    //
    void setWhitelist (const std::vector<std::string>& list) { _whitelist = list; }

    //
    const PathList& getBlackList() const { return _blacklist; }

    bool showMouse() const { return _showMouse; }
    
    //
    void setBlacklist (const std::vector<std::string>& list) { 
        _blacklist = list;
    }

    //
    const PathList& getLocalSandboxPath() const { return _localSandboxPath; }

    void addLocalSandboxPath(const std::string& dir)
    {
        _localSandboxPath.push_back(dir);
    }

    //
    void setLocalSandboxPath(const PathList& path)
    {
        _localSandboxPath = path;
    }

    const std::string& getFlashVersionString() const {
        return _flashVersionString;
    }
    
    void setFlashVersionString(const std::string& value) {
        _flashVersionString = value;
    }

    const std::string& getFlashSystemOS() const {
        return _flashSystemOS;
    }
    
    void setFlashSystemOS(const std::string& value) {
        _flashSystemOS = value;
    }

    const std::string& getFlashSystemManufacturer() const {
        return _flashSystemManufacturer;
    }
    
    void setFlashSystemManufacturer(const std::string& value) {
        _flashSystemManufacturer = value;
    }
    
    const std::string& getGstAudioSink() const { return _gstaudiosink; }
    
    void setGstAudioSink(const std::string& value) { _gstaudiosink = value; }

    int getRetries() const { return _retries; }
    
    void setRetries(int x) { _retries = x; }

    double getStreamsTimeout() const { return _streamsTimeout; }

    void setStreamsTimeout(const double &x) { _streamsTimeout = x; }

    //
    const std::string &getURLOpenerFormat() const
    {
        return _urlOpenerFormat;
    }
    
    void setURLOpenerFormat(const std::string& value)
    {
        _urlOpenerFormat = value;
    }
 
    // Get the name of the hardware acclerator to use for video
    const std::string &getHWAccel() const { return _hwaccel; }

    // Set the name of the hardware acclerator to use for video
    void setHWAccel(const std::string &x) { _hwaccel = x; }

    // Get the name of the renderer to draw the display
    const std::string& getRenderer() const { return _renderer; }

    // Set the name of the renderer to draw the display
    void setRenderer(const std::string& x) { _renderer = x; }

    // Get the name of the media handler to use for video/audio
    const std::string& getMediaHandler() const { return _mediahandler; }

    // Set the name of the media handler to use for video/audio
    void setMediaHandler(const std::string& x) { _mediahandler = x; }

    // Get the location of the sandbox for .sol files
    const std::string &getSOLSafeDir() const { return _solsandbox; }

    // Set the location of the sandbox for .sol files
    void setSOLSafeDir(const std::string &x) { _solsandbox = x; }

    bool getSOLLocalDomain() const { return _sollocaldomain; }
    
    void setSOLLocalDomain(bool x) { _sollocaldomain = x; }
    
    bool getSOLReadOnly() const { return _solreadonly; }
    
    void setSOLReadOnly(bool x) { _solreadonly = x; }
    
    bool getLocalConnection() const { return _lcdisabled; }
    
    void setLocalConnection(bool x) { _lcdisabled = x; }
    
    bool getLCTrace() const { return _lctrace; }
    
    void setLCTrace(bool x) { _lctrace = x; }

    key_t getLCShmKey() const { return static_cast<key_t>(_lcshmkey); }
    
    void setLCShmKey(bool x) { _lcshmkey = x; }

    bool ignoreFSCommand() const { return _ignoreFSCommand; }
    
    void ignoreFSCommand(bool value) { _ignoreFSCommand = value; }
    
    void saveStreamingMedia(bool value) { _saveStreamingMedia = value; }

    bool saveStreamingMedia() const { return _saveStreamingMedia; }

    void saveLoadedMedia(bool value) { _saveLoadedMedia = value; }

    bool saveLoadedMedia() const { return _saveLoadedMedia; }

    void setMediaDir(const std::string& value) { _mediaCacheDir = value; }

    const std::string& getMediaDir() const { return _mediaCacheDir; }
        
    void setWebcamDevice(int value) {_webcamDevice = value;}
    
    int getWebcamDevice() const {return _webcamDevice;}
    
    void setAudioInputDevice(int value) {_microphoneDevice = value;}
    
    int getAudioInputDevice() {return _microphoneDevice;}

    const std::string& getRootCert() const {
        return _rootcert;
    }
    void setRootCert(const std::string& value) {
        _rootcert = value;
    }

    const std::string& getCertFile() const {
        return _certfile;
    }
    void setCertFile(const std::string& value) {
        _certfile = value;
    }

    const std::string& getCertDir() const {
        return _certdir;
    }
    void setCertDir(const std::string& value) {
        _certdir = value;
    }

    void ignoreShowMenu(bool value) { _ignoreShowMenu=value; }

    bool ignoreShowMenu() const { return _ignoreShowMenu; }

    int getScriptsTimeout() const { return _scriptsTimeout; }

    void setScriptsTimeout(int x) { _scriptsTimeout = x; }

    int getScriptsRecursionLimit() const { return _scriptsRecursionLimit; }

    void setScriptsRecursionLimit(int x) { _scriptsRecursionLimit = x; }

    void lockScriptLimits(bool x) { _lockScriptLimits = x; }

    bool lockScriptLimits() const { return _lockScriptLimits; }

    void dump();    

protected:
    
    // A function only for writing path lists to an outstream.
    void writeList(const PathList& list, std::ostream& o);

    RcInitFile();

    ~RcInitFile();

    static void expandPath(std::string& path);

    //
    static bool extractSetting(bool &var, const std::string& pattern,
                        const std::string &variable, const std::string &value);

    //
    template<typename T>
    static bool extractNumber(T& num, const std::string& pattern,
                        const std::string &variable, const std::string &value)
    {

        StringNoCaseEqual noCaseCompare;

        if (noCaseCompare(variable, pattern)) {
            std::istringstream in(value);
            if (in >> num) return true;
            
            num = 0;
            return true;
        }
        
        return false;
    }

    //
    static bool extractDouble(double &out, const std::string& pattern,
                        const std::string &variable, const std::string &value);


    //
    void parseList(std::vector<std::string>& list, const std::string &action,
                                const std::string &items);

    typedef boost::char_separator<char> Sep;
    typedef boost::tokenizer< Sep > Tok;

    boost::uint32_t  _delay;

    boost::uint32_t  _movieLibraryLimit;   

    bool _debug;

    bool _debugger;

    boost::uint32_t  _verbosity;

    //
    std::string  _urlOpenerFormat;

    std::string  _flashVersionString;
    
    std::string _gstaudiosink;

    std::string  _flashSystemOS;       

    std::string  _flashSystemManufacturer;

    bool _actionDump;

    bool _parserDump;

    bool _verboseASCodingErrors;

    bool _verboseMalformedSWF;

    bool _verboseMalformedAMF;

    bool _splashScreen;

    bool _localdomainOnly;
    
    bool _localhostOnly;

    bool _showMouse;

    PathList _whitelist;
    
    PathList _blacklist;
    
    std::string _log;
    
    bool _writeLog;
    
    std::string _wwwroot;
    
    int _retries;
    
    bool _sound;
    
    bool _pluginSound;          

    bool _extensionsEnabled;    

    bool _startStopped;         

    bool _insecureSSL;          

    double _streamsTimeout;

    PathList _localSandboxPath;

    std::string _solsandbox;

    bool _solreadonly;
    bool _sollocaldomain;
    
    // Disable local connection
    bool _lcdisabled;
    
    bool _lctrace;
    
    boost::uint32_t _lcshmkey;
    
    bool _ignoreFSCommand;

    int _quality;

    bool _saveStreamingMedia;
    
    bool _saveLoadedMedia;

    std::string _mediaCacheDir;

    bool _popups;

    bool _useXv;
        
    int _webcamDevice;
    
    int _microphoneDevice;

    std::string _certfile;

    std::string _certdir;

    std::string _rootcert;

    bool _ignoreShowMenu;

    std::string _hwaccel;

    std::string _renderer;

    std::string _mediahandler;

    int _scriptsTimeout;

    int _scriptsRecursionLimit;

    bool _lockScriptLimits;
};

// End of gnash namespace 
}

#endif


// local Variables:
// mode: C++
// indent-tabs-mode: t
// End: