--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetoothengine/bthid/manager/inc/modifier.h Mon Jan 18 20:28:57 2010 +0200
@@ -0,0 +1,280 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Declares main application class.
+ *
+*/
+
+
+#ifndef __MODIFIER_H
+#define __MODIFIER_H
+
+#include <e32std.h>
+
+// ----------------------------------------------------------------------
+
+/*!
+ Convenience functions for working with HID (boot protocol style)
+ keyboard modifier flags. These are stored as an eight bit vector as
+ follows:
+
+ <pre>
+ +-------------------------------------------------------+
+ | Right | Left |
+ +-------------------------------------------------------+
+ | Func | Alt | Shft | Ctrl | Func | Alt | Shft | Ctrl |
+ +-------------------------------------------------------+
+ bit: 7 6 5 4 3 2 1 0
+ </pre>
+
+ We also make use of a "folded" representation, where there
+ is no distinction between the left and right versions of
+ the modifier keys:
+
+ <pre>
+ +---------------------------+---------------------------+
+ | 0 | 0 | 0 | 0 | Func | Alt | Shft | Ctrl |
+ +---------------------------+---------------------------+
+ bit: 7 6 5 4 3 2 1 0
+ </pre>
+
+ i.e. folded = left OR right.
+ */
+class THidModifier
+ {
+public:
+ THidModifier(TUint8 aFlags);
+
+ inline void Set(TUint8 aValue);
+ inline void Merge(TUint8 aValue);
+ inline void Clear(TUint8 aValue);
+
+ inline TUint8 Value() const;
+
+ inline TBool None() const;
+ inline TBool Shift() const;
+ inline TBool Control() const;
+ inline TBool Alt() const;
+ inline TBool Func() const;
+
+ inline TBool LeftControl() const;
+ inline TBool LeftShift() const;
+ inline TBool LeftAlt() const;
+ inline TBool LeftFunc() const;
+
+ inline TBool RightControl() const;
+ inline TBool RightShift() const;
+ inline TBool RightAlt() const;
+ inline TBool RightFunc() const;
+
+ inline TBool ControlAlt() const;
+
+ inline TBool ShiftOnly() const;
+ inline TBool ControlOnly() const;
+ inline TBool AltOnly() const;
+ inline TBool FuncOnly() const;
+
+ inline TUint8 Fold() const;
+
+ inline void InvertShift();
+
+public:
+ enum TModifiers
+ {
+ ELeftControl = (1 << 0),
+ ELeftShift = (1 << 1),
+ ELeftAlt = (1 << 2),
+ ELeftFunc = (1 << 3),
+ ERightControl = (1 << 4),
+ ERightShift = (1 << 5),
+ ERightAlt = (1 << 6),
+ ERightFunc = (1 << 7)
+ };
+
+ enum TFoldedModifiers
+ {
+ EUnmodified = 0, // ----
+ ECtrl = 1, // ---C
+ EShift = 2, // --S-
+ ECtrlShift = 3, // --SC
+ EAlt = 4, // -A--
+ EAltCtrl = 5, // -A-C
+ EAltShift = 6, // -AS-
+ EAltCtrlShift = 7, // -ASC
+ EFunc = 8, // F---
+ EFuncCtrl = 9, // F--C
+ EFuncShift = 10, // F-S-
+ EFuncCtrlShift = 11, // F-SC
+ EFuncAlt = 12, // FA--
+ EFuncAltCtrl = 13, // FA-C
+ EFuncAltShift = 14, // FAS-
+ EFuncAltCtrlShift = 15
+ // FASC
+ };
+
+private:
+ TUint8 iFlags;
+ };
+
+// ----------------------------------------------------------------------
+
+inline THidModifier::THidModifier(TUint8 aFlags) :
+ iFlags(aFlags)
+ {
+ // nothing else to do
+ }
+
+inline TUint8 THidModifier::Value() const
+ {
+ return iFlags;
+ }
+
+inline void THidModifier::Set(TUint8 aValue)
+ {
+ iFlags = aValue;
+ }
+
+inline void THidModifier::Merge(TUint8 aValue)
+ {
+ iFlags |= aValue;
+ }
+
+inline void THidModifier::Clear(TUint8 aValue)
+ {
+ iFlags &= ~aValue;
+ }
+
+// ----------------------------------------------------------------------
+// Individual keys:
+
+inline TBool THidModifier::LeftControl() const
+ {
+ return iFlags & ELeftControl;
+ }
+
+inline TBool THidModifier::LeftShift() const
+ {
+ return iFlags & ELeftShift;
+ }
+
+inline TBool THidModifier::LeftAlt() const
+ {
+ return iFlags & ELeftAlt;
+ }
+
+inline TBool THidModifier::LeftFunc() const
+ {
+ return iFlags & ELeftFunc;
+ }
+
+inline TBool THidModifier::RightControl() const
+ {
+ return iFlags & ERightControl;
+ }
+
+inline TBool THidModifier::RightShift() const
+ {
+ return iFlags & ERightShift;
+ }
+
+inline TBool THidModifier::RightAlt() const
+ {
+ return iFlags & ERightAlt;
+ }
+
+inline TBool THidModifier::RightFunc() const
+ {
+ return iFlags & ERightFunc;
+ }
+
+// ----------------------------------------------------------------------
+// Modifier states:
+
+inline TBool THidModifier::None() const
+ {
+ return iFlags == 0;
+ }
+
+inline TBool THidModifier::Shift() const
+ {
+ return LeftShift() || RightShift();
+ }
+
+inline TBool THidModifier::Control() const
+ {
+ return LeftControl() || RightControl();
+ }
+
+inline TBool THidModifier::Alt() const
+ {
+ return LeftAlt() || RightAlt();
+ }
+
+inline TBool THidModifier::Func() const
+ {
+ return LeftFunc() || RightFunc();
+ }
+
+inline TBool THidModifier::ControlAlt() const
+ {
+ return Alt() && Control();
+ }
+
+// ----------------------------------------------------------------------
+
+inline TUint8 THidModifier::Fold() const
+ {
+ TUint left = iFlags & 0x0f;
+ TUint right = (iFlags & 0xf0) >> 4;
+ return static_cast<TUint8> (left | right);
+ }
+
+// ----------------------------------------------------------------------
+
+inline TBool THidModifier::ShiftOnly() const
+ {
+ return Fold() == EShift;
+ }
+
+inline TBool THidModifier::ControlOnly() const
+ {
+ return Fold() == ECtrl;
+ }
+
+inline TBool THidModifier::AltOnly() const
+ {
+ return Fold() == EAlt;
+ }
+
+inline TBool THidModifier::FuncOnly() const
+ {
+ return Fold() == EFunc;
+ }
+
+// ----------------------------------------------------------------------
+
+inline void THidModifier::InvertShift()
+ {
+ if (iFlags & (ELeftShift | ERightShift))
+ {
+ iFlags &= ~(ELeftShift | ERightShift);
+ }
+ else
+ {
+ iFlags |= ELeftShift;
+ }
+ }
+
+// ----------------------------------------------------------------------
+
+#endif