CConfig.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2012 Bolton Software Ltd.
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef CCONFIG_H
#define CCONFIG_H

#include "OptionTypes.h"
#include "ProtocolTypes.h"
#include "CNetworkAddress.h"
#include "CStringUtil.h"
#include "CInputFilter.h"
#include "XBase.h"
#include "stdmap.h"
#include "stdset.h"
#include "IPlatformScreen.h"
#include <iosfwd>

class CConfig;
class CConfigReadContext;

namespace std {
template <>
struct iterator_traits<CConfig> {
    typedef CString                     value_type;
    typedef ptrdiff_t                   difference_type;
    typedef bidirectional_iterator_tag  iterator_category;
    typedef CString*                    pointer;
    typedef CString&                    reference;
};
};


class CConfig {
public:
    typedef std::map<OptionID, OptionValue> CScreenOptions;
    typedef std::pair<float, float> CInterval;

    class CCellEdge {
    public:
        CCellEdge(EDirection side, float position);
        CCellEdge(EDirection side, const CInterval&);
        CCellEdge(const CString& name, EDirection side, const CInterval&);
        ~CCellEdge();

        CInterval       getInterval() const;
        void            setName(const CString& newName);
        CString         getName() const;
        EDirection      getSide() const;
        bool            overlaps(const CCellEdge&) const;
        bool            isInside(float x) const;

        // transform position to [0,1]
        float           transform(float x) const;

        // transform [0,1] to position
        float           inverseTransform(float x) const;

        // compares side and start of interval
        bool            operator<(const CCellEdge&) const;

        // compares side and interval
        bool            operator==(const CCellEdge&) const;
        bool            operator!=(const CCellEdge&) const;

    private:
        void            init(const CString& name, EDirection side,
                            const CInterval&);

    private:
        CString         m_name;
        EDirection      m_side;
        CInterval       m_interval;
    };

private:
    class CName {
    public:
        CName(CConfig*, const CString& name);

        bool            operator==(const CString& name) const;

    private:
        CConfig*        m_config;
        CString         m_name;
    };

    class CCell {
    private:
        typedef std::map<CCellEdge, CCellEdge> CEdgeLinks;

    public:
        typedef CEdgeLinks::const_iterator const_iterator;

        bool            add(const CCellEdge& src, const CCellEdge& dst);
        void            remove(EDirection side);
        void            remove(EDirection side, float position);
        void            remove(const CName& destinationName);
        void            rename(const CName& oldName, const CString& newName);

        bool            hasEdge(const CCellEdge&) const;
        bool            overlaps(const CCellEdge&) const;

        bool            getLink(EDirection side, float position,
                            const CCellEdge*& src, const CCellEdge*& dst) const;

        bool            operator==(const CCell&) const;
        bool            operator!=(const CCell&) const;

        const_iterator  begin() const;
        const_iterator  end() const;

    private:
        CEdgeLinks      m_neighbors;

    public:
        CScreenOptions  m_options;
    };
    typedef std::map<CString, CCell, CStringUtil::CaselessCmp> CCellMap;
    typedef std::map<CString, CString, CStringUtil::CaselessCmp> CNameMap;

public:
    typedef CCell::const_iterator link_const_iterator;
    typedef CCellMap::const_iterator internal_const_iterator;
    typedef CNameMap::const_iterator all_const_iterator;
    class const_iterator : std::iterator_traits<CConfig> {
    public:
        explicit const_iterator() : m_i() { }
        explicit const_iterator(const internal_const_iterator& i) : m_i(i) { }

        const_iterator& operator=(const const_iterator& i) {
            m_i = i.m_i;
            return *this;
        }
        CString         operator*() { return m_i->first; }
        const CString*  operator->() { return &(m_i->first); }
        const_iterator& operator++() { ++m_i;  return *this; }
        const_iterator  operator++(int) { return const_iterator(m_i++); }
        const_iterator& operator--() { --m_i;  return *this; }
        const_iterator  operator--(int) { return const_iterator(m_i--); }
        bool            operator==(const const_iterator& i) const {
            return (m_i == i.m_i);
        }
        bool            operator!=(const const_iterator& i) const {
            return (m_i != i.m_i);
        }

    private:
        internal_const_iterator m_i;
    };

    CConfig();
    virtual ~CConfig();




    bool                addScreen(const CString& name);


    bool                renameScreen(const CString& oldName,
                            const CString& newName);


    void                removeScreen(const CString& name);


    void                removeAllScreens();


    bool                addAlias(const CString& canonical,
                            const CString& alias);


    bool                removeAlias(const CString& alias);


    bool                removeAliases(const CString& canonical);


    void                removeAllAliases();


    bool                connect(const CString& srcName,
                            EDirection srcSide,
                            float srcStart, float srcEnd,
                            const CString& dstName,
                            float dstStart, float dstEnd);


    bool                disconnect(const CString& srcName,
                            EDirection srcSide);


    bool                disconnect(const CString& srcName,
                            EDirection srcSide, float position);


    void                setSynergyAddress(const CNetworkAddress&);


    bool                addOption(const CString& name,
                            OptionID option, OptionValue value);


    bool                removeOption(const CString& name, OptionID option);


    bool                removeOptions(const CString& name);


    CInputFilter*       getInputFilter();





    bool                isValidScreenName(const CString& name) const;

    const_iterator      begin() const;
    const_iterator      end() const;

    all_const_iterator  beginAll() const;
    all_const_iterator  endAll() const;


    bool                isScreen(const CString& name) const;


    bool                isCanonicalName(const CString& name) const;


    CString             getCanonicalName(const CString& name) const;


    CString             getNeighbor(const CString&, EDirection,
                            float position, float* positionOut) const;


    bool                hasNeighbor(const CString&, EDirection) const;


    bool                hasNeighbor(const CString&, EDirection,
                            float start, float end) const;

    link_const_iterator beginNeighbor(const CString&) const;
    link_const_iterator endNeighbor(const CString&) const;

    const CNetworkAddress&  getSynergyAddress() const;


    const CScreenOptions* getOptions(const CString& name) const;


    bool                    hasLockToScreenAction() const;

    bool                operator==(const CConfig&) const;
    bool                operator!=(const CConfig&) const;


    void                    read(CConfigReadContext& context);


    friend std::istream&    operator>>(std::istream&, CConfig&);


    friend std::ostream&    operator<<(std::ostream&, const CConfig&);


    static const char*  dirName(EDirection);


    static CString      formatInterval(const CInterval&);


private:
    void                readSection(CConfigReadContext&);
    void                readSectionOptions(CConfigReadContext&);
    void                readSectionScreens(CConfigReadContext&);
    void                readSectionLinks(CConfigReadContext&);
    void                readSectionAliases(CConfigReadContext&);

    CInputFilter::CCondition*
                        parseCondition(CConfigReadContext&,
                            const CString& condition,
                            const std::vector<CString>& args);
    void                parseAction(CConfigReadContext&,
                            const CString& action,
                            const std::vector<CString>& args,
                            CInputFilter::CRule&, bool activate);

    void                parseScreens(CConfigReadContext&, const CString&,
                            std::set<CString>& screens) const;
    static const char*  getOptionName(OptionID);
    static CString      getOptionValue(OptionID, OptionValue);

private:
    CCellMap            m_map;
    CNameMap            m_nameToCanonicalName;
    CNetworkAddress     m_synergyAddress;
    CScreenOptions      m_globalOptions;
    CInputFilter        m_inputFilter;
    bool                m_hasLockToScreenAction;
};


class CConfigReadContext {
public:
    typedef std::vector<CString> ArgList;

    CConfigReadContext(std::istream&, SInt32 firstLine = 1);
    ~CConfigReadContext();

    bool            readLine(CString&);
    UInt32          getLineNumber() const;

    operator void*() const;
    bool            operator!() const;

    OptionValue     parseBoolean(const CString&) const;
    OptionValue     parseInt(const CString&) const;
    OptionValue     parseModifierKey(const CString&) const;
    OptionValue     parseCorner(const CString&) const;
    OptionValue     parseCorners(const CString&) const;
    CConfig::CInterval
                    parseInterval(const ArgList& args) const;
    void            parseNameWithArgs(
                        const CString& type, const CString& line,
                        const CString& delim, CString::size_type& index,
                        CString& name, ArgList& args) const;
    IPlatformScreen::CKeyInfo*
                    parseKeystroke(const CString& keystroke) const;
    IPlatformScreen::CKeyInfo*
                    parseKeystroke(const CString& keystroke,
                        const std::set<CString>& screens) const;
    IPlatformScreen::CButtonInfo*
                    parseMouse(const CString& mouse) const;
    KeyModifierMask parseModifier(const CString& modifiers) const;

private:
    // not implemented
    CConfigReadContext& operator=(const CConfigReadContext&);

    static CString  concatArgs(const ArgList& args);

private:
    std::istream&   m_stream;
    SInt32          m_line;
};


class XConfigRead : public XBase {
public:
    XConfigRead(const CConfigReadContext& context, const CString&);
    XConfigRead(const CConfigReadContext& context,
                            const char* errorFmt, const CString& arg);
    ~XConfigRead();

protected:
    // XBase overrides
    virtual CString     getWhat() const throw();

private:
    CString             m_error;
};

#endif