Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members

CInputFilter.h

00001 /*
00002  * synergy -- mouse and keyboard sharing utility
00003  * Copyright (C) 2005 Chris Schoeneman
00004  * 
00005  * This package is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * found in the file COPYING that should have accompanied this file.
00008  * 
00009  * This package is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  */
00014 
00015 #ifndef CINPUTFILTER_H
00016 #define CINPUTFILTER_H
00017 
00018 #include "KeyTypes.h"
00019 #include "MouseTypes.h"
00020 #include "ProtocolTypes.h"
00021 #include "IPlatformScreen.h"
00022 #include "CString.h"
00023 #include "stdmap.h"
00024 #include "stdset.h"
00025 
00026 class CPrimaryClient;
00027 class CEvent;
00028 
00029 class CInputFilter {
00030 public:
00031     // -------------------------------------------------------------------------
00032     // Input Filter Condition Classes
00033     // -------------------------------------------------------------------------
00034     enum EFilterStatus {
00035         kNoMatch,
00036         kActivate,
00037         kDeactivate
00038     };
00039 
00040     class CCondition {
00041     public:
00042         CCondition();
00043         virtual ~CCondition();
00044 
00045         virtual CCondition*     clone() const = 0;
00046         virtual CString         format() const = 0;
00047 
00048         virtual EFilterStatus   match(const CEvent&) = 0;
00049 
00050         virtual void            enablePrimary(CPrimaryClient*);
00051         virtual void            disablePrimary(CPrimaryClient*);
00052     };
00053     
00054     // CKeystrokeCondition
00055     class CKeystrokeCondition : public CCondition {
00056     public:
00057         CKeystrokeCondition(IPlatformScreen::CKeyInfo*);
00058         CKeystrokeCondition(KeyID key, KeyModifierMask mask);
00059         virtual ~CKeystrokeCondition();
00060 
00061         KeyID                   getKey() const;
00062         KeyModifierMask         getMask() const;
00063 
00064         // CCondition overrides
00065         virtual CCondition*     clone() const;
00066         virtual CString         format() const;
00067         virtual EFilterStatus   match(const CEvent&);
00068         virtual void            enablePrimary(CPrimaryClient*);
00069         virtual void            disablePrimary(CPrimaryClient*);
00070 
00071     private:
00072         UInt32                  m_id;
00073         KeyID                   m_key;
00074         KeyModifierMask         m_mask;
00075     };
00076 
00077     // CMouseButtonCondition
00078     class CMouseButtonCondition : public CCondition {
00079     public:
00080         CMouseButtonCondition(IPlatformScreen::CButtonInfo*);
00081         CMouseButtonCondition(ButtonID, KeyModifierMask mask);
00082         virtual ~CMouseButtonCondition();
00083 
00084         ButtonID                getButton() const;
00085         KeyModifierMask         getMask() const;
00086 
00087         // CCondition overrides
00088         virtual CCondition*     clone() const;
00089         virtual CString         format() const;
00090         virtual EFilterStatus   match(const CEvent&);
00091 
00092     private:
00093         ButtonID                m_button;
00094         KeyModifierMask         m_mask;
00095     };
00096 
00097     // CScreenConnectedCondition
00098     class CScreenConnectedCondition : public CCondition {
00099     public:
00100         CScreenConnectedCondition(const CString& screen);
00101         virtual ~CScreenConnectedCondition();
00102 
00103         // CCondition overrides
00104         virtual CCondition*     clone() const;
00105         virtual CString         format() const;
00106         virtual EFilterStatus   match(const CEvent&);
00107 
00108     private:
00109         CString                 m_screen;
00110     };
00111 
00112     // -------------------------------------------------------------------------
00113     // Input Filter Action Classes
00114     // -------------------------------------------------------------------------
00115     
00116     class CAction {
00117     public:
00118         CAction();
00119         virtual ~CAction();
00120 
00121         virtual CAction*        clone() const = 0;
00122         virtual CString         format() const = 0;
00123 
00124         virtual void            perform(const CEvent&) = 0;
00125     };
00126     
00127     // CLockCursorToScreenAction
00128     class CLockCursorToScreenAction : public CAction {
00129     public:
00130         enum Mode { kOff, kOn, kToggle };
00131 
00132         CLockCursorToScreenAction(Mode = kToggle);
00133 
00134         Mode                    getMode() const;
00135 
00136         // CAction overrides
00137         virtual CAction*        clone() const;
00138         virtual CString         format() const;
00139         virtual void            perform(const CEvent&);
00140 
00141     private:
00142         Mode                    m_mode;
00143     };
00144     
00145     // CSwitchToScreenAction
00146     class CSwitchToScreenAction : public CAction {
00147     public:
00148         CSwitchToScreenAction(const CString& screen);
00149 
00150         CString                 getScreen() const;
00151 
00152         // CAction overrides
00153         virtual CAction*        clone() const;
00154         virtual CString         format() const;
00155         virtual void            perform(const CEvent&);
00156 
00157     private:
00158         CString                 m_screen;
00159     };
00160     
00161     // CSwitchInDirectionAction
00162     class CSwitchInDirectionAction : public CAction {
00163     public:
00164         CSwitchInDirectionAction(EDirection);
00165 
00166         EDirection              getDirection() const;
00167 
00168         // CAction overrides
00169         virtual CAction*        clone() const;
00170         virtual CString         format() const;
00171         virtual void            perform(const CEvent&);
00172 
00173     private:
00174         EDirection              m_direction;
00175     };
00176     
00177     // CKeyboardBroadcastAction
00178     class CKeyboardBroadcastAction : public CAction {
00179     public:
00180         enum Mode { kOff, kOn, kToggle };
00181 
00182         CKeyboardBroadcastAction(Mode = kToggle);
00183         CKeyboardBroadcastAction(Mode, const std::set<CString>& screens);
00184 
00185         Mode                    getMode() const;
00186         std::set<CString>       getScreens() const;
00187 
00188         // CAction overrides
00189         virtual CAction*        clone() const;
00190         virtual CString         format() const;
00191         virtual void            perform(const CEvent&);
00192 
00193     private:
00194         Mode                    m_mode;
00195         CString                 m_screens;
00196     };
00197 
00198     // CKeystrokeAction
00199     class CKeystrokeAction : public CAction {
00200     public:
00201         CKeystrokeAction(IPlatformScreen::CKeyInfo* adoptedInfo, bool press);
00202         ~CKeystrokeAction();
00203 
00204         void                    adoptInfo(IPlatformScreen::CKeyInfo*);
00205         const IPlatformScreen::CKeyInfo*
00206                                 getInfo() const;
00207         bool                    isOnPress() const;
00208 
00209         // CAction overrides
00210         virtual CAction*        clone() const;
00211         virtual CString         format() const;
00212         virtual void            perform(const CEvent&);
00213 
00214     protected:
00215         virtual const char*     formatName() const;
00216 
00217     private:
00218         IPlatformScreen::CKeyInfo*  m_keyInfo;
00219         bool                        m_press;
00220     };
00221 
00222     // CMouseButtonAction -- modifier combinations not implemented yet
00223     class CMouseButtonAction : public CAction {
00224     public:
00225         CMouseButtonAction(IPlatformScreen::CButtonInfo* adoptedInfo,
00226                                     bool press);
00227         ~CMouseButtonAction();
00228 
00229         const IPlatformScreen::CButtonInfo*
00230                                 getInfo() const;
00231         bool                    isOnPress() const;
00232 
00233         // CAction overrides
00234         virtual CAction*        clone() const;
00235         virtual CString         format() const;
00236         virtual void            perform(const CEvent&);
00237 
00238     protected:
00239         virtual const char*     formatName() const;
00240 
00241     private:
00242         IPlatformScreen::CButtonInfo*   m_buttonInfo;
00243         bool                            m_press;
00244     };
00245 
00246     class CRule {
00247     public:
00248         CRule();
00249         CRule(CCondition* adopted);
00250         CRule(const CRule&);
00251         ~CRule();
00252 
00253         CRule& operator=(const CRule&);
00254 
00255         // replace the condition
00256         void            setCondition(CCondition* adopted);
00257 
00258         // add an action to the rule
00259         void            adoptAction(CAction*, bool onActivation);
00260 
00261         // remove an action from the rule
00262         void            removeAction(bool onActivation, UInt32 index);
00263 
00264         // replace an action in the rule
00265         void            replaceAction(CAction* adopted,
00266                             bool onActivation, UInt32 index);
00267 
00268         // enable/disable
00269         void            enable(CPrimaryClient*);
00270         void            disable(CPrimaryClient*);
00271 
00272         // event handling
00273         bool            handleEvent(const CEvent&);
00274 
00275         // convert rule to a string
00276         CString         format() const;
00277 
00278         // get the rule's condition
00279         const CCondition*
00280                         getCondition() const;
00281 
00282         // get number of actions
00283         UInt32          getNumActions(bool onActivation) const;
00284 
00285         // get action by index
00286         const CAction&  getAction(bool onActivation, UInt32 index) const;
00287 
00288     private:
00289         void            clear();
00290         void            copy(const CRule&);
00291 
00292     private:
00293         typedef std::vector<CAction*> CActionList;
00294 
00295         CCondition*     m_condition;
00296         CActionList     m_activateActions;
00297         CActionList     m_deactivateActions;
00298     };
00299 
00300     // -------------------------------------------------------------------------
00301     // Input Filter Class
00302     // -------------------------------------------------------------------------
00303     typedef std::vector<CRule> CRuleList;
00304 
00305     CInputFilter();
00306     CInputFilter(const CInputFilter&);
00307     virtual ~CInputFilter();
00308 
00309     CInputFilter&       operator=(const CInputFilter&);
00310 
00311     // add rule, adopting the condition and the actions
00312     void                addFilterRule(const CRule& rule);
00313 
00314     // remove a rule
00315     void                removeFilterRule(UInt32 index);
00316 
00317     // get rule by index
00318     CRule&              getRule(UInt32 index);
00319 
00320     // enable event filtering using the given primary client.  disable
00321     // if client is NULL.
00322     void                setPrimaryClient(CPrimaryClient* client);
00323 
00324     // convert rules to a string
00325     CString             format(const CString& linePrefix) const;
00326 
00327     // get number of rules
00328     UInt32              getNumRules() const;
00329 
00331     bool                operator==(const CInputFilter&) const;
00333     bool                operator!=(const CInputFilter&) const;
00334 
00335 private:
00336     // event handling
00337     void                handleEvent(const CEvent&, void*);
00338 
00339 private:
00340     CRuleList           m_ruleList;
00341     CPrimaryClient*     m_primaryClient;
00342 };
00343 
00344 #endif

Generated on Fri Nov 6 00:21:14 2009 for synergy-plus by  doxygen 1.3.9.1