/*

* Copyright (c) 2008-2009 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:  

* ne1_tb\specific\keymap.cpp

* This file is part of the NE1_TBVariant 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, EStdKeyDevice3          }, // scancode range 5

	};

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,		// scancode range 5 mapping starts here

	EKeyDevice1,

	EKeyDevice2,

	EKeyDevice3,

	};

//

// 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),

			&scanCodeBlock_capsLock[0]

			}

		},

	convSubTable_shift=

		{

		&convKeyCodes_shift[0],

			{

			ARRAY_LENGTH(scanCodeBlock_shift),

			&scanCodeBlock_shift[0]

			}

		},

	convSubTable_func=

		{

		&convKeyCodes_func[0],

			{

			ARRAY_LENGTH(scanCodeBlock_func),

			&scanCodeBlock_func[0]

			}

		},

//	convSubTable_funcUnshifted=

//		{

//		&convKeyCodes_funcUnshifted[0],

//			{

//			ARRAY_LENGTH(scanCodeBlock_funcUnshifted),

//			&scanCodeBlock_funcUnshifted[0]

//			}

//		},

//	convSubTable_funcShifted=

//		{

//		&convKeyCodes_funcShifted[0],

//			{

//			ARRAY_LENGTH(scanCodeBlock_funcShifted),

//			&scanCodeBlock_funcShifted[0]

//			}

//		},

	convSubTable_ctrl=