/*
* 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