// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// omap3530/beagle_drivers/keytran/keymap.cpp

// This file is part of the Beagle Base port

// The keyboard lookup tables giving the function to be carried out

// and the new state of the keyboard

//

#include <k32keys.h>

#define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))

//

// Scancode conversion tables

// --------------------------

// The scancode conversion is arranged as a tree of tables which are used to

// convert a scancode to a keycode, taking into account the modifier state

// (shift, control, fn)

//

// How the tables work:

// --------------------

// Firstly, there is a distinction between the "scancodes" used in scanning

// the keyboard, and the "scancodes" used in this files.

//

// Typically the keyboard driver already contains a table to convert hardware

// key location codes produced during keyboard scanning into EPOC "scancodes".

// EPOC scancodes are defined for "standard" keys like shift, backspace,

// escape, in the TStdScanCode enum (see E32KEYS.H), and should be ASCII codes

// for normal characters. The keyboard driver should add these EPOC scancodes

// to the event queue, not hardware-dependant key locations.

//

// For now on "scancode" refers to EPOC scancodes:

//

// The keyboard is divided into a number of "blocks" of contiguous scancodes

//

// Blocks map to keycodes in a keycode table, and several blocks can be

// grouped and map to a single keycode table. Blocks map into the keycode

// table in the order they are declared. For example, if two scancode blocks

// with a range of 5 scancodes map to a single 10-entry keycode table, scancodes

// which fall in the first block will map to the first 5 entries in the keycode

// table, scancodes falling in the second block map the the next 5 entries in

// the keycode table.

//

// In theory it is possible to have multiple [keycode,scancode blocks] groups

// but there is little point doing this - grouping all the scancode blocks

// with a single keycode table holding all possible keycode values is usually

// sufficient (and simpler). However, there are some special cases where this

// is useful - the most obvious example is handling of shift and caps lock.

// The shift key implies everything that the caps-lock key does (upper case

// letters) plus some shifted characters for other keys. This is done by 

// defining two tables - the first handles only caps-lock (upper case), the 

// second handles all other keys that are affected only by shift. If caps-

// lock is active, only the caps-lock table is used. If shift is pressed both

// the caps-lock and shift tables are scanned for the conversion. This allows

// a base table to be extended with "extras", much like deriving a class from

// base class and extending it.

//

//

// There is one or more [keycode table, scancode blocks] group for each

// modifier state - e.g. a lower-case table, upper-case, ctrl, ctrl-shift.

// This is the root of the table.

//

// When converting a scancode the key translator first obtains the correct

// conversion tables for the modifier state. It then traverses all the scancode

// blocks looking for one which contains the scancode being converted. Once

// a matching scancode range is located, the key translator maps this into

// its position in the associated keycode table to obtain the converted keycode.

//

// The key tables below appear more complicated than they really are because of

// the intermediate structures that hold pointers to other structures. The

// important structures are:

//		SScanCodeBlock - contains a "start" and "end" for a scancode range

//		SConvSubTable - groups a number of scanode blocks with a keycode table

//		SConvTableNode - points to SConvSubTables for each modifier state

//		SConvTable - the root of the translation table - points to 1..n SConvTableNode

//

// The keycode tables are just an array of TUint16.

//

//

// TO DO: (optional)

//

// Keys which are not affected by modifier state

//

//

// This is a simple example of scancode to keycode mapping. The first block

// in scanCodeBlock_unmodifiable is a range of several scancodes, so maps to

// several entries in the keycode table convKeyCodes_unmodifiable.

//		EStdKeyLeftShift -> maps to -> EKeyLeftShift

//		EStdKeyRightShift -> maps to -> EKeyRightShift

//		...

//		EStdKeyScrollLock -> maps to -> EKeyScrollLock

//

LOCAL_D const SScanCodeBlock scanCodeBlock_unmodifiable[]=

	{

	{EStdKeyLeftShift, EStdKeyScrollLock},	// range 1: left shift to scroll lock

	};

LOCAL_D const TUint16 convKeyCodes_unmodifiable[]=

	{

	EKeyLeftShift,

	EKeyRightShift,

	EKeyLeftAlt,

	EKeyRightAlt,

	EKeyLeftCtrl,

	EKeyRightCtrl,

	EKeyLeftFunc,

	EKeyRightFunc,

	EKeyCapsLock,

	EKeyNumLock,

	EKeyScrollLock

	};

//

// TO DO: (optional)

//

// Base conversion table

// this table traps all of the keyboard's scanCodes except those in

// convKeyCodes_unmodifiable. It appears last in the top-level table and

// is used to convert any scancode that is not converted by any of the

// other tables

//

LOCAL_D const SScanCodeBlock scanCodeBlock_base[]=

	{

	{EStdKeyNull, EStdKeyDownArrow},		// scancode range 1

	{'0', '9'},								// scancode range 2

	{'A', 'Z'},								// scancode range 3

	{EStdKeyF1, EStdKeyDictaphoneRecord},	// scancode range 4

	{EStdKeyDevice0,EStdKeyDeviceF},

	};

LOCAL_D const TUint16 convKeyCodes_base[]=

	{

	EKeyNull,				// scancode range 1 mapping starts here

	EKeyBackspace,

	EKeyTab,

	EKeyEnter,

	EKeyEscape,

	' ',

	EKeyPrintScreen,

	EKeyPause,

	EKeyHome,

	EKeyEnd,

	EKeyPageUp,

	EKeyPageDown,

	EKeyInsert,

	EKeyDelete,

	EKeyLeftArrow,

	EKeyRightArrow,

	EKeyUpArrow,

	EKeyDownArrow,

	'0',					// scancode range 2 mapping starts here

	'1',

	'2',

	'3',

	'4',

	'5',

	'6',

	'7',

	'8',

	'9',

	'a',					// scancode range 3 mapping starts here

	'b',

	'c',

	'd',

	'e',

	'f',

	'g',

	'h',

	'i',

	'j',

	'k',

	'l',

	'm',

	'n',

	'o',

	'p',

	'q',

	'r',

	's',

	't',

	'u',

	'v',

	'w',

	'x',

	'y',

	'z',

	EKeyF1,						// scancode range 4 mapping starts here

	EKeyF2,

	EKeyF3,

	EKeyF4,

	EKeyF5,

	EKeyF6,

	EKeyF7,

	EKeyF8,

	EKeyF9,

	EKeyF10,

	EKeyF11,

	EKeyF12,

	EKeyF13,

	EKeyF14,

	EKeyF15,

	EKeyF16,

	EKeyF17,

	EKeyF18,

	EKeyF19,

	EKeyF20,

	EKeyF21,

	EKeyF22,

	EKeyF23,

	EKeyF24,

	'`',

	',',

	'.',

	'/',

	'\\',

	';',

	'\'',

	'#',

	'[',

	']',

	'-',

	'=',

	'/',

	'*',

	'-',

	'+',

	EKeyEnter,

	EKeyEnd,

	EKeyDownArrow,

	EKeyPageDown,

	EKeyLeftArrow,

	EKeyNull, // numeric keypad '5'

	EKeyRightArrow,

	EKeyHome,

	EKeyUpArrow,

	EKeyPageUp,

	EKeyInsert,

	EKeyDelete,

	EKeyMenu,

	EKeyBacklightOn,

	EKeyBacklightOff,

	EKeyBacklightToggle,

	EKeyIncContrast,

	EKeyDecContrast,

	EKeySliderDown,

	EKeySliderUp,

	EKeyDictaphonePlay,

	EKeyDictaphoneStop,

	EKeyDictaphoneRecord,

	EKeyDevice0,

	EKeyDevice1,

	EKeyDevice2,

	EKeyDevice3,

	EKeyDevice4,

	EKeyDevice5,

	EKeyDevice6,

	EKeyDevice7,

	EKeyDevice8,

	EKeyDevice9,

	EKeyDeviceA,

	EKeyDeviceB,

	EKeyDeviceC,

	EKeyDeviceE,

	EKeyDeviceE,

	EKeyDeviceF,

	EKeyApplication0,

	EKeyApplication1,

	EKeyApplication2,

	EKeyApplication3,

	EKeyApplication4,

	EKeyApplication5,

	EKeyApplication6,

	EKeyApplication7,

	EKeyApplication8,

	EKeyApplication9,

	EKeyApplicationA,

	EKeyApplicationB,

	EKeyApplicationC,

	EKeyApplicationD,

	EKeyApplicationE,

	EKeyApplicationF,

	EKeyYes,

	EKeyNo,

	};

//

// TO DO: (optional)

//	

// caps-lock: this table traps those scanCodes which are affected by caps-lock

//

LOCAL_D const SScanCodeBlock scanCodeBlock_capsLock[]=

	{

	{'A', 'Z'}			// only alpha keys are affected by caps-lock

	};

LOCAL_D const TUint16 convKeyCodes_capsLock[]=

	{

	'A',

	'B',

	'C',

	'D',

	'E',

	'F',

	'G',

	'H',

	'I',

	'J',

	'K',

	'L',

	'M',

	'N',

	'O',

	'P',

	'Q',

	'R',

	'S',

	'T',

	'U',

	'V',

	'W',

	'X',

	'Y',

	'Z'

	};

//

// TO DO: (optional)

//

// shift: this table traps those scanCodes which are affected

// by normal shift key EXCEPT for those scanCodes affected by caps-lock

//

LOCAL_D const SScanCodeBlock scanCodeBlock_shift[]=

	{

	{'0', '9'},

	{EStdKeyXXX, EStdKeyEquals},

	};

LOCAL_D const TUint16 convKeyCodes_shift[]=

	{

	')',

	'!',

	'@',/*'"',*/

	'#',			/*ELatin1Pound,*/

	'$',

	'%',

	'^',

	'&',

	'*',

	'(',

	'~',   /*ELatin1LogicNot,*/

	'<',

	'>',

	'?',

	'|',

	':',

	'"',

	'|', /*'~',*/

	'{',

	'}',

	'_',

	'+'

	};

//

// TO DO: (optional)

//

// func: this table traps those scanCodes which are affected

// by the func key but not shift

//

LOCAL_D const SScanCodeBlock scanCodeBlock_func[]=

	{

    {EStdKeyEscape, EStdKeyEscape},

    {'M', 'M'},

    {EStdKeyComma, EStdKeyComma},

    {EStdKeyLeftArrow, EStdKeyDownArrow},

	};

LOCAL_D const TUint16 convKeyCodes_func[]=

	{

    EKeyOff,

    EKeyDecContrast,

    EKeyIncContrast,

    EKeyHome,

    EKeyEnd,

    EKeyPageUp,

    EKeyPageDown,

	};

//

// TO DO: (optional)

//

// func: this table traps those scanCodes which are affected

// by func and shift - this is for func pressed, shift not pressed

//

//LOCAL_D const SScanCodeBlock scanCodeBlock_funcUnshifted[]=

//	{

//	{'E', 'E'},

//	};

//LOCAL_D const TUint16 convKeyCodes_funcUnshifted[]=

//	{

//	ELatin1LcEacute,

//	};

//

// TO DO: (optional)

//

// func: this table traps those scanCodes which are affected

// by func and shift - this is for func and shift both pressed

//

//LOCAL_D const SScanCodeBlock scanCodeBlock_funcShifted[]=

//	{

//	{'E', 'E'},

//	};

//LOCAL_D const TUint16 convKeyCodes_funcShifted[]=

//	{

//	ELatin1UcEacute,

//	};

//

// TO DO: (optional)

//

// ctrl: this table traps those scanCodes which are affected by ctrl

//

LOCAL_D const SScanCodeBlock scanCodeBlock_ctrl[]=

	{

	//

	// NOTE: The space key gets handled elsewhere, otherwise it gets

	// thrown away as a NULL key

	//	{EStdKeySpace, EStdKeySpace},

	{'A', 'Z'},

    {EStdKeyComma, EStdKeyComma},

	};

LOCAL_D const TUint16 convKeyCodes_ctrl[]=

	{

//	0,

	1,

	2,

	3,

	4,

	5,

	6,

	7,

	8,

	9,

	10,

	11,

	12,

	13,

	14,

	15,

	16,

	17,

	18,

	19,

	20,

	21,

	22,

	23,

	24,

	25,

	26,

	',',

	};

//

// TO DO: (optional)

//

// Each set of scancode+keycode tables must be grouped into a SConvSubTable.

// The lines below define a number of SConvSubTables for each of the groups

// above.

//

LOCAL_D const SConvSubTable

	convSubTable_unmodifiable=							// table for unmodifiable keys

		{

		&convKeyCodes_unmodifiable[0],					// the keycode table

			{

			ARRAY_LENGTH(scanCodeBlock_unmodifiable),	// number of scancode blocks

			&scanCodeBlock_unmodifiable[0]				// pointer to scancode blocks

			}

		},

	convSubTable_base=									// table for base keys

		{

		&convKeyCodes_base[0],							// keycode table

			{

			ARRAY_LENGTH(scanCodeBlock_base),			// number of scancode blocks

			&scanCodeBlock_base[0]						// pointer to scancode blocks

			}

		},

	convSubTable_capsLock=

		{

		&convKeyCodes_capsLock[0],

			{

			ARRAY_LENGTH(scanCodeBlock_capsLock),