eqtapmultitap.cpp

Symbian平台 数字键盘手机输入法源码

// eQTapMultitap.cpp: implementation of the CeQTapMultitap class.
//
//////////////////////////////////////////////////////////////////////

#include "eQTapMultitap.h"
#include "FepControl.h"
#include "multitapengine.h"

#include "FepIndicator.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CeQTapMultitap::CeQTapMultitap()
:		m_iPreviousMultiTapKeyCode(EKeyNull),
		m_bIsUper(FALSE),
		m_pMultiTapEngine(NULL)
{

}

CeQTapMultitap::~CeQTapMultitap()
{
	if (m_pMultiTapEngine)
		{
		delete m_pMultiTapEngine;
		m_pMultiTapEngine = NULL;
		}
}
int CeQTapMultitap::OnKeyEventProc(int nParameter1, int nParameter2)
{
	int nReturn = KEY_RESULT_NOTPROCESSED;
	TKeyEvent* aKeyEvent = (TKeyEvent*)nParameter1;
	TKeyResponse response = EKeyWasNotConsumed;
	TUint keyCode =0;
	TEventCode aEventCode = (TEventCode)nParameter2;
	TBool shortKeyPress=TRUE;
	TBool longKeyPress=FALSE;
	
	if((m_bIsIMActive == FALSE)||(aKeyEvent==NULL))
	{
		goto FuncExit;
	}
	keyCode =  aKeyEvent->iCode;
	shortKeyPress=(aEventCode==EEventKey && aKeyEvent->iRepeats==0);
	longKeyPress=(aEventCode==EEventKey && aKeyEvent->iRepeats==1 );
	

	if (m_iPreviousMultiTapKeyCode != keyCode)
	{
		// New key press, cancel multi-tap timer
		if(m_pMultiTapEngine->IsActive())
		{
			m_peQTapCtrl->CommitInlineEdit (ETrue);
		}
		m_pMultiTapEngine->Cancel();
	}

	switch (keyCode)
		{
		case '1':
			if(m_bIsUper==TRUE)
			{
				m_bIsUper=FALSE;
				m_peQTapCtrl->GetFepIndicator()->SetState(CFepIndicator::EStateAlphabat); 
				m_pMultiTapEngine->SetUpper(FALSE);
			}
			else
			{
				m_bIsUper=TRUE;
				m_peQTapCtrl->GetFepIndicator()->SetState(CFepIndicator::EStateUpperAlphabat); 
				m_pMultiTapEngine->SetUpper(TRUE);
			}
			response= EKeyWasConsumed;
			break;
		case '0':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			{
			if (shortKeyPress)
				{
				// insert a letter
				HandleMultiTapModeKeyCodeL(keyCode);
				response=EKeyWasConsumed;
				}
			else if (longKeyPress)
				{
				if (m_peQTapCtrl->IsInlineEditTrans())
					{// insert a digit

					// Set the new cursor position
					TInt newCursorPos = 0;
					TCursorSelection currentEditorSelection;

					// Gets the range of characters in the text editor which are selected
					m_peQTapCtrl->GetCursorSelection(currentEditorSelection);
					
					// If the number of characters in the current editor is greater than, move the cursor
					// position of the uncommitted text to the end.
					if (currentEditorSelection.Length())
						{	 
						// Gets the greater of the cursor and anchor positions
						newCursorPos = currentEditorSelection.HigherPos(); 

						// Sets the cursor and anchor positions for the uncommitted text
						m_peQTapCtrl->GetUnCommittedText().SetSelection(newCursorPos, newCursorPos);

						// Sets the range of characters in the text editor which should be selected
						m_peQTapCtrl->SetCursorSelection(m_peQTapCtrl->GetUnCommittedText());
						}
					
					// Our implementation: 
					// Treat all the long key press key as digit character. Therefore, 
					// we delete the previous character and replace it with a "keyCode" 

					TPtrC ptr = m_pMultiTapEngine->AppendCharacter(keyCode);
//					m_pMultiTapEngine->SetUpperLower(bUpperLower);
					m_peQTapCtrl->UpdateInlineEditL(ptr, 1); // Single character

					/*
					m_pMultiTapEngine->DeleteCharacter();
					TBuf<1> buffer = KNullDesC();
					buffer.Append(keyCode);
					m_peQTapCtrl->UpdateInlineEditL(buffer, 1);						
					m_peQTapCtrl->CommitInlineEdit(ETrue);
					*/

					response = EKeyWasConsumed; 
					}
				else // have received long keyprss without initial short keypress so just consume
					response = EKeyWasConsumed;
				}
			else
				response = EKeyWasConsumed;
			}
			break;

		case EKeyBackspace:
			if (m_peQTapCtrl->IsInlineEditTrans())
				{
				// If we're in inline editing transaction, just commit it and return
				//	m_peQTapCtrl->CommitInlineEdit (ETrue);
					response = EKeyWasConsumed;
				}
			else
				response = EKeyWasNotConsumed;
			break;

		case EKeyLeftArrow:
		case EKeyRightArrow:
		case EKeyUpArrow:
		case EKeyDownArrow:
			if (m_peQTapCtrl->IsInlineEditTrans())
				{
				// If we're in inline editing transaction, just commit it and return
			//	m_peQTapCtrl->CommitInlineEdit(ETrue);
				response = EKeyWasConsumed;
				}
			else
				response = EKeyWasNotConsumed;
			break;

		default:
			break;
		}

	m_iPreviousMultiTapKeyCode = keyCode;
	nReturn = response;
FuncExit:
	return nReturn;
}
int CeQTapMultitap::OnDrawIMWindow()
{
	int nReturn = 0;

	return nReturn;
}

CeQTapMultitap* CeQTapMultitap::NewL(CeQTapControl* pControl)
{
	CeQTapMultitap* self = new(ELeave)CeQTapMultitap(pControl);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();	// self
	return self;
}

CeQTapMultitap::CeQTapMultitap(CeQTapControl* pControl)
:		m_iPreviousMultiTapKeyCode(EKeyNull),
		m_bIsUper(FALSE),
		m_pMultiTapEngine(NULL)
 
{
	m_peQTapCtrl = pControl;
	m_bIsIMActive = FALSE;
}

void CeQTapMultitap::ConstructL()
{
	// Create multi-tap input engine
	m_pMultiTapEngine = CExampleFepMultiTapEngine::NewL(*m_peQTapCtrl);
}
void CeQTapMultitap::HandleMultiTapModeKeyCodeL(TUint aKeyCode)
	{
	if (!m_pMultiTapEngine->IsActive())
		{
		// timer timeout, treats this as new key press
		m_iPreviousMultiTapKeyCode = EKeyNull;
		}

	if ((aKeyCode != m_iPreviousMultiTapKeyCode) && m_peQTapCtrl->IsInlineEditTrans())
		{
		// new key press
		m_peQTapCtrl->CommitInlineEdit(EFalse);
		}


	if (!m_peQTapCtrl->IsInlineEditTrans())
		{ 
		// Previous transaction is not inline editor editing, so start it.
		if (m_pMultiTapEngine->IsActive())
		{
			m_peQTapCtrl->StartInlineEdit(KNullDesC, 0, EFalse);
		}
		else
		{
			m_peQTapCtrl->StartInlineEdit(KNullDesC, 0, ETrue);
		}
		}

  if (m_peQTapCtrl->IsInlineEditTrans())
		{
		// Update a new character and get a pointer to the engine buffer
		TPtrC ptr = m_pMultiTapEngine->AppendCharacter(aKeyCode); 
		m_peQTapCtrl->UpdateInlineEditL(ptr, 1); // Single character
		}
	}
void CeQTapMultitap::ClearEngineBuffer()
{
	m_pMultiTapEngine->ClearBuffer ();
}
void CeQTapMultitap::SwitchToMultiTap()
{
	ActiveMTWindow(FALSE);
}

void CeQTapMultitap::ActiveMTWindow(TBool bActive)
{
	TPoint fepControlPos;
	RWindow& window = m_peQTapCtrl->GetRWindow();

	if (bActive == TRUE)  //打开输入法窗口	
	{
		window.SetVisible(ETrue);
		m_peQTapCtrl->SetWindowVisibleState(TRUE);
	}
	else                 //关闭输入法窗口
	{
		window.SetVisible(EFalse);
		m_peQTapCtrl->SetWindowVisibleState(FALSE);
	}
}