/*
* 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\keypad.cpp
* This file contains the implementation of Keypad for the NEC LCD.
*
*/



#include <naviengine.h>
#include <naviengine_priv.h>
#include <e32event.h>
#include <e32event_private.h>
#include <e32keys.h>
#include "lcdgce.h"


// =-==LCD keypad settings and registers==================
const TUint KKeybPollTime = 100;
const TUint KHWKeyRL      = KHwFPGABase + 0x0410;   // Key return line
const TUint KHWKeySR      = KHwFPGABase + 0x0418;   // Key scan register

// Scan codes for buttons: (scan_register_value | (1<<line+4))
// SW1 - is on scan line 1
const TUint KHwKeyCodeArrowUp      = 0x21; // SW1 Up
const TUint KHwKeyCodeArrowRight   = 0x22; // SW1 Right
const TUint KHwKeyCodeArrowLeft    = 0x24; // SW1 Left
const TUint KHwKeyCodeArrowDown    = 0x28; // SW1 Down
const TUint KHwKeyCodeButtonCentre = 0x30; // SW1 Centre press
const TUint KHwKeyCodeButtonLeft   = 0x81; // SW2 - is on scan line 3
const TUint KHwKeyCodeButtonRight  = 0x41; // SW3 - is on scan line 2

const TUint KHwKeyNumArrowUp       = 0;
const TUint KHwKeyNumArrowDown     = 1;
const TUint KHwKeyNumArrowLeft     = 2;
const TUint KHwKeyNumArrowRight    = 3;
const TUint KHwKeyNumButtonCentre  = 4;
const TUint KHwKeyNumButtonLeft    = 5;
const TUint KHwKeyNumButtonRight   = 6;

//#define __KTRACE(s) s
#define __KTRACE(s)

enum TKeyMode
	{
	EKeyModeS60      = 0,
	EKeyModeTechview = 1,

	// This must be the last entry in the list
	EKeyModes
	};

class DNE1Keypad
	{
public:
	DNE1Keypad();
	TInt DoCreate();
	static void GetScanCodes(TAny* aPtr);
	void ProcessKey(TUint aKeyNum, TInt aState);

private:

	inline void AddEventForKey(TUint aKeyCode, TRawEvent::TType aEventType);
	NTimer   iKeyboardTimer;
	TUint    iKeyStates;
	TKeyMode iKeyMode;
	};


/* Macro to detect is the key is shifted */
#define SHIFTED(x)   (0x8000|(x))
#define ISSHIFTED(x) (0x8000&(x))
#define FUNCED(x)    (0x4000|(x))
#define ISFUNCED(x)  (0x4000&(x))
#define CTRLED(x)    (0x2000|(x))
#define ISCTRLED(x)  (0x2000&(x))
#define STDKEY(x)    (0x1FFF&(x))

// modify this table to change the key mapping
const TUint16 convertCode[][EKeyModes] =
	{
		// S60               TechView
		{ EStdKeyUpArrow,    EStdKeyUpArrow,    }, // SW1 Up
		{ EStdKeyDownArrow,  EStdKeyDownArrow,  }, // SW1 Down
		{ EStdKeyLeftArrow,  EStdKeyLeftArrow,  }, // SW1 Left
		{ EStdKeyRightArrow, EStdKeyRightArrow, }, // SW1 Right
		{ EStdKeyDevice3,    EStdKeyEnter,      }, // SW1 Centre Press
		{ EStdKeyDevice0,    EStdKeyEscape,     }, // SW2
		{ EStdKeyDevice1,    EStdKeyMenu,       }, // SW3
	};

void DNE1Keypad::AddEventForKey(TUint aKeyCode, TRawEvent::TType aEventType)
    {
	// convert character to keycode and shift, func, ctrl status
	TUint16 code      = convertCode[aKeyCode][iKeyMode];
	TBool   isShifted = ISSHIFTED(code);
	TBool   isFunced  = ISFUNCED(code);
	TBool   isCtrled  = ISCTRLED(code);
	TUint8  stdKey    = STDKEY(code);
	TRawEvent e;

	if (aEventType == TRawEvent::EKeyDown)
		{
		// post it as a sequence of events
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyRightShift,0);
			Kern::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftCtrl,0);
			Kern::AddEvent(e);
			}
		if (isFunced)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftFunc,0);
			Kern::AddEvent(e);
			}
		}

	e.Set(aEventType,stdKey,0);
	Kern::AddEvent(e);

	if (TRawEvent::EKeyUp)
		{
		if (isFunced)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);
			Kern::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftCtrl,0);
			Kern::AddEvent(e);
			}
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyRightShift,0);
			Kern::AddEvent(e);
			}
	    }
	}

void DNE1Keypad::ProcessKey(TUint aKeyNum, TInt aState)
	{
	// if the key was pressed last time AND key is now not pressed
	if ((iKeyStates & (1<<aKeyNum)) && (aState == 0))
		{
		// send a key up event
		__KTRACE(Kern::Printf("issue KeyUp for key %d ", aKeyNum));
		AddEventForKey(aKeyNum,TRawEvent::EKeyUp);

		// mark this key as released..
		iKeyStates &= ~(1<<aKeyNum);
		}
	// if the key was NOT pressed last time AND key is now pressed
	else if (!(iKeyStates & (1<<aKeyNum)) && (aState == 1))
		{
		// send a key down event
		__KTRACE(Kern::Printf("issue KeyDown for key %d ", aKeyNum));
		AddEventForKey(aKeyNum,TRawEvent::EKeyDown);

		// mark this key as pressed down..
		iKeyStates |= (1<<aKeyNum);
		}
	}


void DNE1Keypad::GetScanCodes(TAny* aPtr)
	{
	DNE1Keypad* pD=(DNE1Keypad*)aPtr;

	TInt keyRow, key=0;
	for(keyRow = 1; keyRow < 4; ++keyRow)
		{
		AsspRegister::Write16(KHWKeySR, keyRow);        // make line active..
		TUint16 skey = AsspRegister::Read16(KHWKeyRL);  // and scan it, 1=key was pressed..

		if(skey)
			{
			key = (skey | (1<<(keyRow+4)));
			}
		}

	// process each key in turn, passing the current state
	pD->ProcessKey(KHwKeyNumArrowUp,      ((key & KHwKeyCodeArrowUp     )==KHwKeyCodeArrowUp     ));
	pD->ProcessKey(KHwKeyNumArrowRight,   ((key & KHwKeyCodeArrowRight  )==KHwKeyCodeArrowRight  ));
	pD->ProcessKey(KHwKeyNumArrowLeft,    ((key & KHwKeyCodeArrowLeft   )==KHwKeyCodeArrowLeft   ));
	pD->ProcessKey(KHwKeyNumArrowDown,    ((key & KHwKeyCodeArrowDown   )==KHwKeyCodeArrowDown   ));
	pD->ProcessKey(KHwKeyNumButtonCentre, ((key & KHwKeyCodeButtonCentre)==KHwKeyCodeButtonCentre));
	pD->ProcessKey(KHwKeyNumButtonLeft,   ((key & KHwKeyCodeButtonLeft  )==KHwKeyCodeButtonLeft  ));
	pD->ProcessKey(KHwKeyNumButtonRight,  ((key & KHwKeyCodeButtonRight )==KHwKeyCodeButtonRight ));

	pD->iKeyboardTimer.Again(KKeybPollTime);
	}

DNE1Keypad::DNE1Keypad() :
	iKeyboardTimer(GetScanCodes, this),
	iKeyStates(0)
	{
	TUint idMode = AsspRegister::Read32(KHwIDMODE);
	TUint keyMode = (idMode & KHmKeyConfigSwitch) >> KHsKeyConfigSwitch;

	switch (keyMode)
		{
		default:
		case 0: iKeyMode = EKeyModeTechview; break;
		case 1: iKeyMode = EKeyModeS60;      break;
		}
	}

TInt DNE1Keypad::DoCreate()
	{
	iKeyboardTimer.OneShot(KKeybPollTime, ETrue);
	return KErrNone;
	}


DECLARE_STANDARD_EXTENSION()
	{
	// check the display mode - and if LCD is not on
	// (any of ANALOG modes is set)- do not create/start the driver..
	TInt r = KErrNoMemory;
	TInt mode = ReadDipSwitchDisplayMode();
	if(mode == DISPLAY_MODE_ANALOG_VGA                ||
	   mode == DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE_OLD ||
	   mode == DISPLAY_MODE_ANALOG_QVGA_PORTRAIT      ||
	   mode == DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE)
		{
		__KTRACE(Kern::Printf("keypad.cpp: LCD panel not switched on...\nwill not start the driver"));
		r = KErrNone; //  just return..
		}
	else
		{
		DNE1Keypad* pD= new DNE1Keypad;
		if (pD)
			r = pD->DoCreate();
		}

	return r;
	}