source: trunk/synergy/lib/platform/COSXKeyState.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2004 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.
 */

#ifndef COSXKEYSTATE_H
#define COSXKEYSTATE_H

#include "CKeyState.h"
#include "stdmap.h"
#include "stdset.h"
#include "stdvector.h"
#include <Carbon/Carbon.h>

//! OS X key state
/*!
A key state for OS X.
*/
class COSXKeyState : public CKeyState {
public:
        typedef std::vector<KeyID> CKeyIDs;

        COSXKeyState();
        virtual ~COSXKeyState();

        //! @name modifiers
        //@{

        //! Handle modifier key change
        /*!
        Determines which modifier keys have changed and updates the modifier
        state and sends key events as appropriate.
        */
        void                            handleModifierKeys(void* target,
                                                        KeyModifierMask oldMask, KeyModifierMask newMask);

        //@}
        //! @name accessors
        //@{

        //! Convert OS X modifier mask to synergy mask
        /*!
        Returns the synergy modifier mask corresponding to the OS X modifier
        mask in \p mask.
        */
        KeyModifierMask         mapModifiersFromOSX(UInt32 mask) const;

        //! Map key event to keys
        /*!
        Converts a key event into a sequence of KeyIDs and the shadow modifier
        state to a modifier mask.  The KeyIDs list, in order, the characters
        generated by the key press/release.  It returns the id of the button
        that was pressed or released, or 0 if the button doesn't map to a known
        KeyID.
        */
        KeyButton                       mapKeyFromEvent(CKeyIDs& ids,
                                                        KeyModifierMask* maskOut, EventRef event) const;

        //! Map key and mask to native values
        /*!
        Calculates mac virtual key and mask for a key \p key and modifiers
        \p mask.  Returns \c true if the key can be mapped, \c false otherwise.
        */
        bool                            mapSynergyHotKeyToMac(KeyID key, KeyModifierMask mask,
                                                        UInt32& macVirtualKey,
                                                        UInt32& macModifierMask) const;

        //@}

        // IKeyState overrides
        virtual bool            fakeCtrlAltDel();
        virtual KeyModifierMask
                                                pollActiveModifiers() const;
        virtual SInt32          pollActiveGroup() const;
        virtual void            pollPressedKeys(KeyButtonSet& pressedKeys) const;

protected:
        // CKeyState overrides
        virtual void            getKeyMap(CKeyMap& keyMap);
        virtual void            fakeKey(const Keystroke& keystroke);

private:
        class CKeyResource;
        typedef std::vector<KeyboardLayoutRef> GroupList;

        // Add hard coded special keys to a CKeyMap.
        void                            getKeyMapForSpecialKeys(
                                                        CKeyMap& keyMap, SInt32 group) const;

        // Convert keyboard resource to a key map
        bool                            getKeyMap(CKeyMap& keyMap,
                                                        SInt32 group, const CKeyResource& r) const;

        // Get the available keyboard groups
        bool                            getGroups(GroupList&) const;

        // Change active keyboard group to group
        void                            setGroup(SInt32 group);

        // Check if the keyboard layout has changed and update keyboard state
        // if so.
        void                            checkKeyboardLayout();

        // Send an event for the given modifier key
        void                            handleModifierKey(void* target,
                                                        UInt32 virtualKey, KeyID id,
                                                        bool down, KeyModifierMask newMask);

        // Checks if any in \p ids is a glyph key and if \p isCommand is false.
        // If so it adds the AltGr modifier to \p mask.  This allows OS X
        // servers to use the option key both as AltGr and as a modifier.  If
        // option is acting as AltGr (i.e. it generates a glyph and there are
        // no command modifiers active) then we don't send the super modifier
        // to clients because they'd try to match it as a command modifier.
        void                            adjustAltGrModifier(const CKeyIDs& ids,
                                                        KeyModifierMask* mask, bool isCommand) const;

        // Maps an OS X virtual key id to a KeyButton.  This simply remaps
        // the ids so we don't use KeyButton 0.
        static KeyButton        mapVirtualKeyToKeyButton(UInt32 keyCode);

        // Maps a KeyButton to an OS X key code.  This is the inverse of
        // mapVirtualKeyToKeyButton.
        static UInt32           mapKeyButtonToVirtualKey(KeyButton keyButton);

private:
        class CKeyResource : public IInterface {
        public:
                virtual bool    isValid() const = 0;
                virtual UInt32  getNumModifierCombinations() const = 0;
                virtual UInt32  getNumTables() const = 0;
                virtual UInt32  getNumButtons() const = 0;
                virtual UInt32  getTableForModifier(UInt32 mask) const = 0;
                virtual KeyID   getKey(UInt32 table, UInt32 button) const = 0;

                // Convert a character in the current script to the equivalent KeyID
                static KeyID    getKeyID(UInt8);

                // Convert a unicode character to the equivalent KeyID.
                static KeyID    unicharToKeyID(UniChar);
        };

        class CKCHRKeyResource : public CKeyResource {
        public:
                CKCHRKeyResource(const void*);

                // CKeyResource overrides
                virtual bool    isValid() const;
                virtual UInt32  getNumModifierCombinations() const;
                virtual UInt32  getNumTables() const;
                virtual UInt32  getNumButtons() const;
                virtual UInt32  getTableForModifier(UInt32 mask) const;
                virtual KeyID   getKey(UInt32 table, UInt32 button) const;

        private:
                struct KCHRResource {
                public:
                        SInt16          m_version;
                        UInt8           m_tableSelectionIndex[256];
                        SInt16          m_numTables;
                        UInt8           m_characterTables[1][128];
                };
                struct CKCHRDeadKeyRecord {
                public:
                        UInt8           m_tableIndex;
                        UInt8           m_virtualKey;
                        SInt16          m_numCompletions;
                        UInt8           m_completion[1][2];
                };
                struct CKCHRDeadKeys {
                public:
                        SInt16                          m_numRecords;
                        CKCHRDeadKeyRecord      m_records[1];
                };

                const KCHRResource*     m_resource;
        };

        class CUCHRKeyResource : public CKeyResource {
        public:
                CUCHRKeyResource(const void*, UInt32 keyboardType);

                // CKeyResource overrides
                virtual bool    isValid() const;
                virtual UInt32  getNumModifierCombinations() const;
                virtual UInt32  getNumTables() const;
                virtual UInt32  getNumButtons() const;
                virtual UInt32  getTableForModifier(UInt32 mask) const;
                virtual KeyID   getKey(UInt32 table, UInt32 button) const;

        private:
                typedef std::vector<KeyID> KeySequence;

                bool                    getDeadKey(KeySequence& keys, UInt16 index) const;
                bool                    getKeyRecord(KeySequence& keys,
                                                        UInt16 index, UInt16& state) const;
                bool                    addSequence(KeySequence& keys, UCKeyCharSeq c) const;

        private:
                const UCKeyboardLayout*                 m_resource;
                const UCKeyModifiersToTableNum* m_m;
                const UCKeyToCharTableIndex*    m_cti;
                const UCKeySequenceDataIndex*   m_sdi;
                const UCKeyStateRecordsIndex*   m_sri;
                const UCKeyStateTerminators*    m_st;
                UInt16                                                  m_spaceOutput;
        };

        // OS X uses a physical key if 0 for the 'A' key.  synergy reserves
        // KeyButton 0 so we offset all OS X physical key ids by this much
        // when used as a KeyButton and by minus this much to map a KeyButton
        // to a physical button.
        enum {
                KeyButtonOffset = 1
        };

        typedef std::map<KeyboardLayoutRef, SInt32> GroupMap;
        typedef std::map<UInt32, KeyID> CVirtualKeyMap;

        CVirtualKeyMap          m_virtualKeyMap;
        mutable UInt32          m_deadKeyState;
        GroupList                       m_groups;
        GroupMap                        m_groupMap;
};

#endif