348 lines
8.3 KiB
C++
348 lines
8.3 KiB
C++
/*
|
|
* synergy -- mouse and keyboard sharing utility
|
|
* Copyright (C) 2005 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
|
*
|
|
* 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 CINPUTFILTER_H
|
|
#define CINPUTFILTER_H
|
|
|
|
#include "KeyTypes.h"
|
|
#include "MouseTypes.h"
|
|
#include "ProtocolTypes.h"
|
|
#include "IPlatformScreen.h"
|
|
#include "CString.h"
|
|
#include "stdmap.h"
|
|
#include "stdset.h"
|
|
|
|
class CPrimaryClient;
|
|
class CEvent;
|
|
|
|
class CInputFilter {
|
|
public:
|
|
// -------------------------------------------------------------------------
|
|
// Input Filter Condition Classes
|
|
// -------------------------------------------------------------------------
|
|
enum EFilterStatus {
|
|
kNoMatch,
|
|
kActivate,
|
|
kDeactivate
|
|
};
|
|
|
|
class CCondition {
|
|
public:
|
|
CCondition();
|
|
virtual ~CCondition();
|
|
|
|
virtual CCondition* clone() const = 0;
|
|
virtual CString format() const = 0;
|
|
|
|
virtual EFilterStatus match(const CEvent&) = 0;
|
|
|
|
virtual void enablePrimary(CPrimaryClient*);
|
|
virtual void disablePrimary(CPrimaryClient*);
|
|
};
|
|
|
|
// CKeystrokeCondition
|
|
class CKeystrokeCondition : public CCondition {
|
|
public:
|
|
CKeystrokeCondition(IPlatformScreen::CKeyInfo*);
|
|
CKeystrokeCondition(KeyID key, KeyModifierMask mask);
|
|
virtual ~CKeystrokeCondition();
|
|
|
|
KeyID getKey() const;
|
|
KeyModifierMask getMask() const;
|
|
|
|
// CCondition overrides
|
|
virtual CCondition* clone() const;
|
|
virtual CString format() const;
|
|
virtual EFilterStatus match(const CEvent&);
|
|
virtual void enablePrimary(CPrimaryClient*);
|
|
virtual void disablePrimary(CPrimaryClient*);
|
|
|
|
private:
|
|
UInt32 m_id;
|
|
KeyID m_key;
|
|
KeyModifierMask m_mask;
|
|
};
|
|
|
|
// CMouseButtonCondition
|
|
class CMouseButtonCondition : public CCondition {
|
|
public:
|
|
CMouseButtonCondition(IPlatformScreen::CButtonInfo*);
|
|
CMouseButtonCondition(ButtonID, KeyModifierMask mask);
|
|
virtual ~CMouseButtonCondition();
|
|
|
|
ButtonID getButton() const;
|
|
KeyModifierMask getMask() const;
|
|
|
|
// CCondition overrides
|
|
virtual CCondition* clone() const;
|
|
virtual CString format() const;
|
|
virtual EFilterStatus match(const CEvent&);
|
|
|
|
private:
|
|
ButtonID m_button;
|
|
KeyModifierMask m_mask;
|
|
};
|
|
|
|
// CScreenConnectedCondition
|
|
class CScreenConnectedCondition : public CCondition {
|
|
public:
|
|
CScreenConnectedCondition(const CString& screen);
|
|
virtual ~CScreenConnectedCondition();
|
|
|
|
// CCondition overrides
|
|
virtual CCondition* clone() const;
|
|
virtual CString format() const;
|
|
virtual EFilterStatus match(const CEvent&);
|
|
|
|
private:
|
|
CString m_screen;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Input Filter Action Classes
|
|
// -------------------------------------------------------------------------
|
|
|
|
class CAction {
|
|
public:
|
|
CAction();
|
|
virtual ~CAction();
|
|
|
|
virtual CAction* clone() const = 0;
|
|
virtual CString format() const = 0;
|
|
|
|
virtual void perform(const CEvent&) = 0;
|
|
};
|
|
|
|
// CLockCursorToScreenAction
|
|
class CLockCursorToScreenAction : public CAction {
|
|
public:
|
|
enum Mode { kOff, kOn, kToggle };
|
|
|
|
CLockCursorToScreenAction(Mode = kToggle);
|
|
|
|
Mode getMode() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
private:
|
|
Mode m_mode;
|
|
};
|
|
|
|
// CSwitchToScreenAction
|
|
class CSwitchToScreenAction : public CAction {
|
|
public:
|
|
CSwitchToScreenAction(const CString& screen);
|
|
|
|
CString getScreen() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
private:
|
|
CString m_screen;
|
|
};
|
|
|
|
// CSwitchInDirectionAction
|
|
class CSwitchInDirectionAction : public CAction {
|
|
public:
|
|
CSwitchInDirectionAction(EDirection);
|
|
|
|
EDirection getDirection() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
private:
|
|
EDirection m_direction;
|
|
};
|
|
|
|
// CKeyboardBroadcastAction
|
|
class CKeyboardBroadcastAction : public CAction {
|
|
public:
|
|
enum Mode { kOff, kOn, kToggle };
|
|
|
|
CKeyboardBroadcastAction(Mode = kToggle);
|
|
CKeyboardBroadcastAction(Mode, const std::set<CString>& screens);
|
|
|
|
Mode getMode() const;
|
|
std::set<CString> getScreens() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
private:
|
|
Mode m_mode;
|
|
CString m_screens;
|
|
};
|
|
|
|
// CKeystrokeAction
|
|
class CKeystrokeAction : public CAction {
|
|
public:
|
|
CKeystrokeAction(IPlatformScreen::CKeyInfo* adoptedInfo, bool press);
|
|
~CKeystrokeAction();
|
|
|
|
void adoptInfo(IPlatformScreen::CKeyInfo*);
|
|
const IPlatformScreen::CKeyInfo*
|
|
getInfo() const;
|
|
bool isOnPress() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
protected:
|
|
virtual const char* formatName() const;
|
|
|
|
private:
|
|
IPlatformScreen::CKeyInfo* m_keyInfo;
|
|
bool m_press;
|
|
};
|
|
|
|
// CMouseButtonAction -- modifier combinations not implemented yet
|
|
class CMouseButtonAction : public CAction {
|
|
public:
|
|
CMouseButtonAction(IPlatformScreen::CButtonInfo* adoptedInfo,
|
|
bool press);
|
|
~CMouseButtonAction();
|
|
|
|
const IPlatformScreen::CButtonInfo*
|
|
getInfo() const;
|
|
bool isOnPress() const;
|
|
|
|
// CAction overrides
|
|
virtual CAction* clone() const;
|
|
virtual CString format() const;
|
|
virtual void perform(const CEvent&);
|
|
|
|
protected:
|
|
virtual const char* formatName() const;
|
|
|
|
private:
|
|
IPlatformScreen::CButtonInfo* m_buttonInfo;
|
|
bool m_press;
|
|
};
|
|
|
|
class CRule {
|
|
public:
|
|
CRule();
|
|
CRule(CCondition* adopted);
|
|
CRule(const CRule&);
|
|
~CRule();
|
|
|
|
CRule& operator=(const CRule&);
|
|
|
|
// replace the condition
|
|
void setCondition(CCondition* adopted);
|
|
|
|
// add an action to the rule
|
|
void adoptAction(CAction*, bool onActivation);
|
|
|
|
// remove an action from the rule
|
|
void removeAction(bool onActivation, UInt32 index);
|
|
|
|
// replace an action in the rule
|
|
void replaceAction(CAction* adopted,
|
|
bool onActivation, UInt32 index);
|
|
|
|
// enable/disable
|
|
void enable(CPrimaryClient*);
|
|
void disable(CPrimaryClient*);
|
|
|
|
// event handling
|
|
bool handleEvent(const CEvent&);
|
|
|
|
// convert rule to a string
|
|
CString format() const;
|
|
|
|
// get the rule's condition
|
|
const CCondition*
|
|
getCondition() const;
|
|
|
|
// get number of actions
|
|
UInt32 getNumActions(bool onActivation) const;
|
|
|
|
// get action by index
|
|
const CAction& getAction(bool onActivation, UInt32 index) const;
|
|
|
|
private:
|
|
void clear();
|
|
void copy(const CRule&);
|
|
|
|
private:
|
|
typedef std::vector<CAction*> CActionList;
|
|
|
|
CCondition* m_condition;
|
|
CActionList m_activateActions;
|
|
CActionList m_deactivateActions;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Input Filter Class
|
|
// -------------------------------------------------------------------------
|
|
typedef std::vector<CRule> CRuleList;
|
|
|
|
CInputFilter();
|
|
CInputFilter(const CInputFilter&);
|
|
virtual ~CInputFilter();
|
|
|
|
CInputFilter& operator=(const CInputFilter&);
|
|
|
|
// add rule, adopting the condition and the actions
|
|
void addFilterRule(const CRule& rule);
|
|
|
|
// remove a rule
|
|
void removeFilterRule(UInt32 index);
|
|
|
|
// get rule by index
|
|
CRule& getRule(UInt32 index);
|
|
|
|
// enable event filtering using the given primary client. disable
|
|
// if client is NULL.
|
|
void setPrimaryClient(CPrimaryClient* client);
|
|
|
|
// convert rules to a string
|
|
CString format(const CString& linePrefix) const;
|
|
|
|
// get number of rules
|
|
UInt32 getNumRules() const;
|
|
|
|
//! Compare filters
|
|
bool operator==(const CInputFilter&) const;
|
|
//! Compare filters
|
|
bool operator!=(const CInputFilter&) const;
|
|
|
|
private:
|
|
// event handling
|
|
void handleEvent(const CEvent&, void*);
|
|
|
|
private:
|
|
CRuleList m_ruleList;
|
|
CPrimaryClient* m_primaryClient;
|
|
};
|
|
|
|
#endif
|