/*

* 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:  CCalcView is a view class of Calculator application.

*                Base class of CCalcView is CAknView. 

*

*/

// INCLUDE FILES

#include <avkon.hrh>

#include <eikon.hrh>

#include <eikmenup.h>

#include <aknnotewrappers.h> 

#include <AiwServiceHandler.h>

#include <aknbutton.h>

#include <hlplch.h>   // For HlpLauncher 

#include <featmgr.h>      // Feature Manager

#include <Calcsoft.rsg>

#include "CalcView.h"

#include "CalcCont.h" 

#include "CalcEdit.h"

#include "CalcAppUi.h"

#include "CalcDoc.h"

#include "CalcHistory.h"

#include "CalcOutSheet.h"

#include "CalcFunc.h"

#include "CalcEnv.h"

#include "calc.hrh" 

#include "CalcEditline.h"

//#include    "CalcCmdBtn.h"

#include <layoutmetadata.cdl.h>

#include <AiwMenu.h>

#include <AiwCommon.h>

//  LOCAL CONSTANTS AND MACROS  

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

// Two-phased constructor.

CCalcView* CCalcView::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

  // default constructor can leave.

void CCalcView::ConstructL()

    {

    BaseConstructL(R_CALC_VIEW_INFO);

    iCalcDocument = STATIC_CAST(CCalcDocument*, AppUi()->Document());

    iCalcDocument->SetCalcView( this );

    iCalcDocument->LoadStateL();

    /******** Initialize the ServiceHandler in the ConstructL *****/

    iServiceHandler = CAiwServiceHandler::NewL();

    /***** Attach the Menu Items of the Calculator and also the Interest *****/

    iServiceHandler->AttachMenuL(R_CALC_POPUPMENU, R_AIWHELPAPP_INTEREST);

    this->iLastResultSetected = EFalse;

    }

// Destructor

CCalcView::~CCalcView()

    {

     }

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

// CCalcView::State

// Return current state

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

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

//

CCalcView::TStateNo CCalcView::State() const

    {

    return iState;

    }

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

// CCalcView::LatestInput

// Return type of latest input

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

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

//

CCalcView::TKindOfInput CCalcView::LatestInput() const

    {

    return iLatestInput;

    }

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

// CCalcView::UpdateState

// Update state by using kind of input

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

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

//

void CCalcView::UpdateState

        (const TKindOfInput& aKind)   

    {

    iLatestInput = aKind;

    switch (aKind)

       {

        case EOperand:

        case EMemoryRecall:

            {

            switch (iState)

                {

                case EInitialMode: 

                case ESelectResult:

                    iState = EOperandOnly;

                    break;

                case EOperandAndOperator:

                    iState = EOperandAndOperatorAndOperand;

                    break;

                default:

                    break;

                }

            break;

            }

        case EOperatorResult:

            {

            iState = EOperatorOnlyResult;

            break;

            }

        case EOperator:

            {

            iState = EOperandAndOperator;

            break;

            }

        case EEqual:

            {

            iState = ESelectResult;

            break;

            }

        case EMemorySave:

            {

            switch (iState)

                {

                case EOperandAndOperatorAndOperand:

                    iState = ESelectResult;

                    break;

                case ESelectResult:

                    iState = EOperandOnly;

                    break;

                default:

                    break;

                }

            break;

            }

        case EAllClear:

            {

            iState = EOperandOnly;

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CCalcView::ErrorMsgL

// Display error message

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

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

//

void CCalcView::ErrorMsgL

        (TInt aErrorCode) 

    {

    TInt resourceId(0);

    switch (aErrorCode)

        {

        case KErrOverflow:

            {

            resourceId = R_CALC_ERROR_OUTOFRANGE;

            break;

            }

        case KErrDivideByZero:

            {

            resourceId = R_CALC_ERROR_DIVISIONBYZERO;

             // UpdateState( EOperator );

            break;

            }

        case KErrNotSupported:

            {

            resourceId = R_CALC_ERROR_NEGATIVEVALUESQRT;

            break;

            }

        default:

            {

            return;

            }

        }

    //Localisation of scalable UI.

    HBufC* message = iCoeEnv->AllocReadResourceLC(resourceId) ;

    CAknErrorNote* note = new (ELeave) CAknErrorNote();

    note->ExecuteLD(*message);

    CleanupStack::PopAndDestroy(message);

    }

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

// CCalcView::DynInitMainMenuPane

// Delete meaningless items from main menu.

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

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

//

void CCalcView::DynInitMainMenuPane    

              (CEikMenuPane* aMenuPane) 

    {

    switch (iState)

        {

        case ESelectResult:

            {

            aMenuPane->DeleteMenuItem(ECalcCmdLastResult);

            break;

            }

        case EInitialMode:

            {

            aMenuPane->DeleteMenuItem(ECalcCmdClearCalcAndHistory);

            break;

            }

        case EOperandOnly:

            {

            if (iCalcDocument->History()->Count() == 0)

                {

                aMenuPane->DeleteMenuItem(ECalcCmdClearCalcAndHistory);

                }

             if(iLastResultSetected)

                 {

                aMenuPane->DeleteMenuItem(ECalcCmdLastResult);     

                 }

            break;

            }

        case EOperandAndOperator:

        case EOperandAndOperatorAndOperand:

             if(iLastResultSetected)

                 {

                aMenuPane->DeleteMenuItem(ECalcCmdLastResult);     

                 }

            break;      

        default:

            {

            break;

            }

        }

    }                        

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

// CCalcView::DynInitMemoryMenuPane

// Delete meaningless items from menu of memory 

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

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

//

void CCalcView::DynInitMemoryMenuPane

        (CEikMenuPane* aMenuPane)

    {

    if (!iCalcDocument->HasMemory())

        {

        aMenuPane->DeleteMenuItem(ECalcCmdMemoryClear);

        }    

    }

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

// CCalcView::NotifyChangeDecimal

// Call when decimal separator is changed.

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

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

//

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

    {

    iContainer->NotifyChangeDecimal(aOld, aNew);

    }

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

// CCalcView::HandleCommandL

// Handling command.

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

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

//

void CCalcView::HandleCommandL

        ( TInt aCommand ) 

    {

    // Handle the command generated by:

    //   1. menu item selection

    //   2. short-cut key press

    switch ( aCommand )

        {

        case ECalcCmdResult:

            {

            HandleResultL();

            break;

            }

        case ECalcCmdAdd:

            {

            HandleOperatorL(TCalcEditLine::ECalcAdd);

            break;

            }

        case ECalcCmdSubtract:

            {

            HandleOperatorL(TCalcEditLine::ECalcSubtract);

            break;

            }

        case ECalcCmdMultiply:

            {

            HandleOperatorL(TCalcEditLine::ECalcMultiply);

            break;

            }

        case ECalcCmdDivide:

            {

            HandleOperatorL(TCalcEditLine::ECalcDivide);

            break;

            }

        case ECalcCmdChangeSign:

            {

            this->iLastResultSetected = EFalse;

            HandleChangeSignL();

            break;

            }

        case ECalcCmdLastResult:

            {

            HandleLastResultL();

            break;

            }

        case ECalcCmdPercent:

            {

            HandleOperatorL(TCalcEditLine::ECalcPercent);

            // The result is always is displayed

            // after the percent button is pressed.

            // But if there was a error in the calculation

            // this if will enable us to not call the

            // HandleResultL and thus making sure that

            // the state of the buttons is identical to the

            // situation before the calculation.

            if (iState == EOperatorOnlyResult)

                HandleResultL();

            break;

            }

        case ECalcCmdSqrt:

            {

//            TRequestStatus trs;

//            RTimer timer;

//            timer.CreateLocal();

//            timer.After(trs, 1000*2);

//            while ( trs == KRequestPending) {

//                  User::WaitForAnyRequest();

//            }

//            timer.Cancel();

//            timer.Close();

            HandleOperatorL(TCalcEditLine::ECalcSqrt);

            // HandleResultL only if sqrt was pressed after single operand.

            if (iState == EOperatorOnlyResult)

                HandleResultL();

            break;

            }

        case ECalcCmdMemorySave:

            {

            HandleMemorySaveL();

            break;

            }

        case ECalcCmdMemoryRecall:

            {

            this->iLastResultSetected = EFalse;

            HandleMemoryRecallL();

            break;

            }

        case ECalcCmdMemoryClear:

            {

            HandleMemoryClearL();

            break;

            }

        case ECalcCmdScrollUp:

            {

            HandleScrollUp();

            break;

            }

        case ECalcCmdScrollDown:

            {

            HandleScrollDown();

            break;

            }

        case ECalcCmdClearCalcAndHistory:

            {

            DoClearCalcAndHistoryL();

            break;

            }

        case EAknSoftkeyExit:

        case EEikCmdExit:

            {

            STATIC_CAST(CCalcAppUi*, AppUi())->ExitCalculator();

            break;

            }

        case ECalcCmdHelp: 

            {

            if (FeatureManager::FeatureSupported( KFeatureIdHelp ))

                {

                HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(), AppUi()->AppHelpContextL());

                }

            break;

            }

        case EAknSoftkeySelect:

            {

            iContainer->HandleMiddleSoftKey();

            break;

            }

        //Below cases are possible only for Touch UI Layouts

        case ECalcCmdOne:

            {

            iContainer->SetOperatorFromTouchL(1);

            }

            break;

        case ECalcCmdTwo:

            {

            iContainer->SetOperatorFromTouchL(2);

            }

            break;

        case ECalcCmdThree:

            {

            iContainer->SetOperatorFromTouchL(3);

            }

            break;

        case ECalcCmdFour:

            {

            iContainer->SetOperatorFromTouchL(4);

            }

            break;

        case ECalcCmdFive:

            {

            iContainer->SetOperatorFromTouchL(5);

            }

            break;

        case ECalcCmdSix:

            {

            iContainer->SetOperatorFromTouchL(6);

            }

            break;

        case ECalcCmdSeven:

            {

            iContainer->SetOperatorFromTouchL(7);

            }

            break;

        case ECalcCmdEight:

            {

            iContainer->SetOperatorFromTouchL(8);

            }

            break;

        case ECalcCmdNine:

            {

            iContainer->SetOperatorFromTouchL(9);

            }

            break;

        case ECalcCmdZero:

            {

            iContainer->SetOperatorFromTouchL(0);

            }

            break;

        case ECalcCmdSeparator:

            {

            iContainer->SetSeparatorFromTouchL();

            }

            break;

        case ECalcCmdCancel:

            {