/*

* Copyright (c) 2002 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:  Source file of "editor sub-pane", CCalcEditorSubPane class 

*                which derived from CCoeControl class. 

*                Role of this class is to draw editor.

*

*/

// INCLUDE FILES

#include <AknUtils.h>

#include <Calcsoft.rsg>

#include <avkon.hrh>

#include <aknsoundsystem.h>

#include    <applayout.cdl.h>

#include <AknIconUtils.h>

#include    <AknsDrawUtils.h>

#include  <aknlayoutscalable_avkon.cdl.h>  

#include <AknLayout2ScalableDef.h>

#include <AvkonInternalCRKeys.h>

#include    <aknlayoutscalable_apps.cdl.h>

#include "CalcAppUi.h"

#include "CalcCont.h"

#include "CalcDoc.h"

#include "CalcEdit.h"

#include "CalcEnv.h"

#include "CalcDrawingConst.laf" // for drawing information.

#include "fbs.h"

#include <PtiKeyMappings.h>

#include <PtiDefs.h>

#include <PtiEngine.h>

#include <AknFepInternalCRKeys.h>

#include <layoutmetadata.cdl.h>

//  LOCAL CONSTANTS AND MACROS  

// If const TChar is used, complie error occurs in THUMB build.

// To avoid this, #define is used.

#define KCalcHashBtn '#' 

#define KZero 0.0 

// ================= MEMBER FUNCTIONS =======================

// Two-phased constructor.

CCalcEditorSubPane* CCalcEditorSubPane::NewL(

                    CCalcContainer* aContainer)

    {

    CCalcEditorSubPane* self = new (ELeave) CCalcEditorSubPane();

    CleanupStack::PushL(self);

    self->ConstructL(aContainer);

    CleanupStack::Pop(self); 

    return self;

    }

// Destructor

CCalcEditorSubPane::~CCalcEditorSubPane()

    {

    iQwertyModeStatusProperty.Close();

    delete iEngine;

    delete iCRKey;

    }

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

// CCalcEditorSubPane::EditLine

// Return reference of editor line which has been edited by user.

// (other items were commented in a header).

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

//

const TCalcEditLine& CCalcEditorSubPane::EditLine() const

    {

    return iEditLine;

    }

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

// CCalcEditorSubPane::SetEditorNumber

// Set TReal64 type editor number.

// (other items were commented in a header). 

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

//

void CCalcEditorSubPane::SetOperator(

     TCalcEditLine::TCalcOperatorType aType)

    {

    iEditLine.SetOperator(aType);

    }

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

// CCalcEditorSubPane::SetEditorNumber

// Set TReal64 type editor number.

// (other items were commented in a header). 

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

//

void CCalcEditorSubPane::SetEditorNumber(TReal64 aNewNumber)

    {

    iEditorNumber = aNewNumber;

    iEditLine.SetNumber(aNewNumber);

    }

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

// CCalcEditorSubPane::EditorNumber

// Return TReal64 type editor number

// (other items were commented in a header). 

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

//

TReal64 CCalcEditorSubPane::EditorNumber() const

    {

    return iEditorNumber;

    }

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

// CCalcEditorSubPane::ResetL

// Clear editor.

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::ResetL()

    {

    iEditLine.AllClear();  

    iEditLine.ClearL();

    }

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

// CCalcEditorSubPane::ClearOperand

// Clear operand

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::ClearOperand()

    {

    iEditLine.ClearOperand();  

    }

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

// CCalcEditorSubPane::ClearLastInput

// Clear last input.

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::ClearLastInputL()

    {

    const TPtrC number(iEditLine.NumberString());

    if (number.Length() == 1 && 

        iCalcContainer->View()->State() == CCalcView::EOperandOnly)

        {

        iCalcContainer->InputClearL();

        }

    else

        {

        if (iEditLine.CheckZeroL())

            {

            iCalcContainer->InputClearL();

            }

        else

            {

            ClearL();

            if (iEditLine.CheckZeroL() && 

                iCalcContainer->View()->State() == CCalcView::EOperandOnly)

                {

                iCalcContainer->InputClearL();

                }

            }

        }

    }

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

// CCalcEditorSubPane::OfferShortPressClearKeyEventL

// Handle short-press-clear-key and CBA-clear-key event.

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::OfferShortPressClearKeyEventL()

    {

    CCalcView* view = iCalcContainer->View();

    CCalcView::TStateNo state(view->State());

    CCalcView::TKindOfInput latestInput(view->LatestInput());

    switch (latestInput)

        {

        case (CCalcView::EMemoryRecall):

        case (CCalcView::EOperator):

            {

            if (state == CCalcView::EOperandOnly ||

                iEditLine.CheckZeroL())

                {

                iCalcContainer->InputClearL();

                }

            else 

                {

                ClearOperand();

                }

            break;

            }

        case (CCalcView::EMemorySave):

            {

            if (state != CCalcView::EOperandAndOperator ||

                iEditLine.CheckZeroL())

                {

                iCalcContainer->InputClearL();

                }

            else

                {

                ClearOperand();

                }

            break;

            }

        case (CCalcView::EEqual):

            {

            iCalcContainer->InputClearL();

            break;

            }

        default:

            {

            ClearLastInputL();

            break;

            }

        }

    }

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

// CCalcEditorSubPane::DoChangeSign

// Changing sign.

// This is not called when editor number is 0. 

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::DoChangeSignL(

     CCalcView::TStateNo aState)

    {

    // If current state is other than State1, "+/-" command is ignored.

    if (aState != CCalcView::EInitialMode)

        {

        if (aState == CCalcView::ESelectResult)

            {

            // "=" is disappeared from editor.

            iEditLine.SetOperator(TCalcEditLine::ECalcOperatorNone);  

            }

        iEditLine.ChangeSignL();

        iEditorNumber = iEditorNumber * (-1);

        DrawNow();

        }

    }

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

// CCalcEditorSubPane::DoMemoryRecallOrLastResult

// Update editor number to memory or last result.

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::DoMemoryRecallOrLastResult(

                    TReal64 aMemoryOrLastResult, 

                    CCalcView::TStateNo aState)

    {

    if (aState == CCalcView::ESelectResult)

        {

        // "=" is disappeared from editor.

        iEditLine.SetOperator(TCalcEditLine::ECalcOperatorNone);

        }

    iEditLine.SetNumber(aMemoryOrLastResult);

    iEditorNumber = aMemoryOrLastResult;

    DrawNow();

    }

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

// CCalcEditorSubPane::NotifyChangeDecimal

// Call when decimal separator is changed.

// (other items were commented in a header).

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

//

void CCalcEditorSubPane::NotifyChangeDecimal(TChar aOld, TChar aNew)

    {

    iEditLine.ChangeDecimal(aOld, aNew);

    DrawNow();

    }

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

// CCalcEditorSubPane::IsQwertyKeypadActive

// Called to check qwerty keypad is active or not

// (other items were commented in a header).

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

//

TInt CCalcEditorSubPane::IsQwertyKeypadActive()

	{

 	TInt value = 0;

    iQwertyModeStatusProperty.Get(value);

    return value;

	}

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

// CCalcEditorSubPane::OfferKeyEventL

// This function is called by CCalcContainer::OfferKeyEventL()

// when inputted key is number or "#". 

// (other items were commented in a header).

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

//

TKeyResponse CCalcEditorSubPane::OfferKeyEventL

                ( const TKeyEvent& aKeyEvent,  

                  TEventCode aType )           

    {

    if (aType != EEventKey)

        {

        return EKeyWasNotConsumed;

        }

	TPtiKey keyQwertyValue = (TPtiKey)aKeyEvent.iScanCode;

    TChar decimal(iCalcAppEnv->DecimalSeparator());

#ifdef RD_INTELLIGENT_TEXT_INPUT

    TChar keyCode( aKeyEvent.iCode );

#else 

    TChar keyCode(aKeyEvent.iScanCode);

#endif

    TChar decimalkey(aKeyEvent.iCode);

    if( iDecimalCounter < KCalcMaxNumberWidth  )

    {

    	iAllowedDecimal.Append(decimal);

    	iDecimalCounter++;	

    }

		if(IsQwertyKeypadActive())

		{

#ifdef RD_INTELLIGENT_TEXT_INPUT

            if( MapDecimal(aKeyEvent) || MapDecimal(aKeyEvent) ||aKeyEvent.iCode == KCalcHashBtn )

                {

                keyCode = decimal;

                }		    	

#else

		    if(MapDecimal(keyQwertyValue,EPtiCaseUpper) || MapDecimal(keyQwertyValue,EPtiCaseLower) ||aKeyEvent.iCode == KCalcHashBtn )

		      {

		      keyCode = decimal;

		      }

#endif

                  //}

		}

	else

		{

		if (aKeyEvent.iCode == KCalcHashBtn)

	        {

	        keyCode = decimal;

	        }	

		}

    TKeyResponse response(EKeyWasNotConsumed);

    CCalcView* view = iCalcContainer->View();

    if (keyCode.IsDigit() || keyCode == decimal)

        {

        DrawDeferred();

        iCalcContainer->ProcessPreinputL();

        view->iLastResultSetected = EFalse;

        // Append input to editor space if editor space is not full.

        TRAPD(errorCode, iEditLine.AppendL(keyCode));

        //  If editor space is full, error message is shown.

        if (errorCode)  

            {

            CAknKeySoundSystem* soundSystem = 

                iCalcAppEnv->AppUi()->KeySounds();

            if (soundSystem)

                {

                soundSystem->PlaySound(EAvkonSIDInformationTone);

                }

            }

        else

            {

            if (iEditLine.CheckZeroL() && 

                iEditLine.Operator() == TCalcEditLine::ECalcOperatorNone)

                {

                view->UpdateState(CCalcView::EAllClear);

                }

            else

                {

                view->UpdateState(CCalcView::EOperand);

                }

            iEditorNumber = iEditLine.NumberL();

            }

		// Enable ChangeSign and Square root buttons

		// if there is no 0 in the editor.

		iCalcContainer->SetChangeSignEnableL();

		iCalcContainer->SetSqrtEnableL();

        iCalcContainer->SetClearKeyEnable();

		// Enable the Percent button if the calculator

		// is in correct state and there is no 0 in the editor.

		if ( iCalcContainer->GetState() == CCalcView::EOperandAndOperator || 

			 iCalcContainer->GetState() == CCalcView::EOperandAndOperatorAndOperand )

			if (keyCode.IsDigit())

				iCalcContainer->SetPercentEnableL();

			response = EKeyWasConsumed;

        }

    else if (decimalkey == EKeyBackspace)   

        {view->iLastResultSetected = EFalse;

        DrawDeferred();

        //  If Clear-Key is pressed long, number editor and operand

        // is clear and the state is set initial one.

        if (aKeyEvent.iRepeats)  

            {

            iCalcContainer->InputClearL();

            }

        // If Clear-key is pressed short, the latest input is deleted.

        else   

            {

            OfferShortPressClearKeyEventL();

            }

        iEditorNumber = iEditLine.NumberL();

        iCalcContainer->SetChangeSignEnableL();

		iCalcContainer->SetSqrtEnableL();

        iCalcContainer->SetClearKeyEnable();

        if ( iCalcContainer->GetState() == CCalcView::EOperandAndOperator || 

        	 iCalcContainer->GetState() == CCalcView::EOperandAndOperatorAndOperand ||

        	 iEditorNumber == KZero )

            iCalcContainer->SetPercentEnableL();

        response = EKeyWasConsumed;

        }

    return response;

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

CCalcEditorSubPane::CCalcEditorSubPane()

    {

    }

// Second-phase constructor

void CCalcEditorSubPane::ConstructL

        (CCalcContainer* aContainer) 

    {

    // The state is set initial one.

    // Number editor is set "0".

    iEditLine.ClearL();

    iEditorNumber = 0.0;

    SetContainerWindowL(*aContainer);

    iCalcContainer = aContainer;  

    // Load calc_display bitmap 

    iCalcAppEnv = CCalcAppEnv::Static();

    iCalcSideLDisplay = iCalcAppEnv->DisplaySideLBitmap();

    iCalcCenterDisplay = iCalcAppEnv->DisplayCenterBitmap();

    iCalcSideRDisplay = iCalcAppEnv->DisplaySideRBitmap();

    iIsQwertyActive = 0;

    User::LeaveIfError(iQwertyModeStatusProperty.Attach(KCRUidAvkon, KAknQwertyInputModeActive));

    // Try to get the English key mappings. If those are not available, use the 

    // mappings of the current input language. The order is this because all mappings

    // do not necessarily contain all characters neeeded by the Calculator.

    iLanguage = ELangEnglish;

    iEngine = CPtiEngine::NewL(ETrue);

    iCoreLanguage = static_cast<CPtiCoreLanguage*>(iEngine->GetLanguage( iLanguage ));

    if( !iCoreLanguage )

        {

        iCRKey = CRepository::NewL(KCRUidAknFep);

        TInt ret = iCRKey->Get(KAknFepInputTxtLang,iLanguage);

        if( ret!= KErrNone )

            {

            //Exit application if server is busy( Error Raised )

            iAvkonViewAppUi->Exit();

            }

            iCoreLanguage = static_cast<CPtiCoreLanguage*>(iEngine->GetLanguage(iLanguage));

        }

    RProperty::Get( KCRUidAvkon, KAknKeyBoardLayout, iKeyboardType );

    if( iCoreLanguage )

        {

#ifdef RD_INTELLIGENT_TEXT_INPUT

        if ( iKeyboardType == EPtiKeyboardHalfQwerty)

           {

           iHalfQwertyKeyMappings = static_cast<CPtiHalfQwertyKeyMappings*>(iCoreLanguage->GetHalfQwertyKeymappings());

           }

       else

#endif

          {

          iQwertyKeyMappings = static_cast<CPtiQwertyKeyMappings*>(iCoreLanguage->GetQwertyKeymappings());

          }

        }

#ifdef RD_INTELLIGENT_TEXT_INPUT

    if ( iKeyboardType == EPtiKeyboardHalfQwerty )

        { 

        iEngine->ActivateLanguageL( iLanguage, EPtiEngineHalfQwerty );

        }

    else if ( IsQwertyKeypadActive())

        { 

        iEngine->ActivateLanguageL( iLanguage, EPtiEngineQwerty );

        } 

  //      RProperty::Get( KCRUidAvkon, KAknKeyBoardLayout, iKeyboardType );

        iEngine->SetKeyboardType( TPtiKeyboardType (iKeyboardType ));

#endif

    // UI language is used to determine the used number format.

    iUiLanguage = User::Language();

    iDecimalCounter = 0;

    }