/*

* 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:  Document class, CCalcDocument

*                Derived from CEikDocument

*                The history of inputted data is held.

*                The memory of four-arithmetical-operations operation 

*                or a calculation result is held.

*                The last result and memory are saved at a file and 

*                it restores.

*

*/

// INCLUDE FILES  

#include    "CalcDoc.h"

#include    "CalcEditline.h"

#include    "CalcAppUi.h"

#include    "CalcApp.h"

#include	"CalcEnv.h"

#include    "CalcHistory.h"

#include	"e32math.h"

#include <e32cmn.h>

#include <s32file.h>

// CONSTANTS

const TReal64 KCalcDefaultMemory(0.0);

const TReal64 KCalcDefaultLastResult(0.0);

const TReal64 KCalcDefaultZero(1E-12);

_LIT( KCalculatorFilename,"Calcsoft.ini");

_LIT(KDelimiter, ":");

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

// Two-phased constructor.

CCalcDocument* CCalcDocument::NewL

                (CEikApplication& aApp) 

    {

    CCalcDocument* self = new (ELeave) CCalcDocument(aApp);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CCalcDocument::~CCalcDocument()

    {

    delete iHistory;

    }

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

// CCalcDocument::CalculateAndAddHistoryL

// This function is called when State is changed to State3 or State5. 

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

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

//

TReal64 CCalcDocument::CalculateAndAddHistoryL

                   (TReal64 aOperand,

                    const TCalcEditLine& aLine)

    {

	iProvisionalResult = CalculateL(aOperand, aLine.Operator()); 

	iHistory->Add(aLine);       // Add a line to history.	

	return iProvisionalResult;	

    }

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

// CCalcDocument::CalculateAndNoHistoryL

// This function is called when the calculations is not

// written to the Outputsheet (sqrt and percent in some cases).

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

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

//

TReal64 CCalcDocument::CalculateAndNoHistoryL

                   (TReal64 aOperand,

                    const TCalcEditLine& aLine)

	{

	TReal64 result = CalculateL(aOperand, aLine.Operator()); 

	return result;

	}

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

// CCalcDocument::CalculateAndModifyHistoryL

// This function is called when the output needs to be edited

// before it is displayed in the Outputsheet. This function 

// may call the CalculateL twice, because it may need to

// calculate the percent first.

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

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

//

TReal64 CCalcDocument::CalculateAndModifyHistoryL

                   (TReal64 aOperand,

                    TCalcEditLine& aLine,

					TCalcEditLine::TCalcOperatorType aOperator)

	{

	if (aOperator == TCalcEditLine::ECalcMultiply)

		iProvisionalResult = CalculateL(aOperand, aLine.Operator()); 

	else

		{

		TReal64 iTempResult = CalculateL(aOperand, aLine.Operator()); 

		iProvisionalResult = CalculateL(iTempResult, aOperator);

		}

	aLine.SetOperator(aOperator);

	// Get the percent character from iCalcAppEnv (it uses the resource

	// file to get the character).

	TChar character((iCalcAppEnv->OutSheetOperator(TCalcEditLine::ECalcPercent))[0]);

	aLine.AppendNumberStringL(character); // Add percent to the line

	iHistory->Add(aLine);       // Add a line to history.	

	return iProvisionalResult;

	}

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

// CCalcDocument::AddEqualLineAndUpdateLastResult

// This is called when "Equal" command is selected. 

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

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

//

void CCalcDocument::AddEqualLineAndUpdateLastResultL()

    {

    TCalcEditLine line;

    line.SetOperator(TCalcEditLine::ECalcEqual);

    line.SetNumber(iProvisionalResult);

    iHistory->Add(line);         // Add a line to history.

    iLastResult = iProvisionalResult;

    SaveStateL();

    }

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

// CCalcDocument::AddEmptyLine

// Add a empty line

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

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

//

void CCalcDocument::AddEmptyLine()

    {

    TCalcEditLine line;

    iHistory->Add(line);       

    }

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

// CCalcDocument::MemorySave

// Save a memory from value of current editor.

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

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

//

void CCalcDocument::MemorySaveL

                   (TReal64 aNewMemory)

    {

    iMemory = aNewMemory;

    SaveStateL();

    }

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

// CCalcDocument::HasMemory

// Check memory non-zero.

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

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

//

TBool CCalcDocument::HasMemory() const

    {

    return (iMemory != 0.0);

    }

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

// CCalcDocument::Memory

// Return memory.

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

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

//

TReal64 CCalcDocument::Memory() const

    {

    return (iMemory);

    }

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

// CCalcDocument::MemoryClear

// Clear memory.

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

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

//

void CCalcDocument::MemoryClearL()

    {

    iMemory = 0.0;

    SaveStateL(); 	

    }

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

// CCalcDocument::LastResult

// Return Last result.

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

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

//

TReal64 CCalcDocument::LastResult() const

    {

    return (iLastResult);

    }

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

// CCalcDocument::ProvisionalResult

// Return provisional result

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

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

//

TReal64 CCalcDocument::ProvisionalResult() const

    {

    return iProvisionalResult;

    }

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

// CCalcDocument::History

// Return CCalcHistory class.

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

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

//

CCalcHistory* CCalcDocument::History() const

    {

    return iHistory;

    }

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

// might leave.

//

CCalcDocument::CCalcDocument

               (CEikApplication& aApp) 

              : CEikDocument(aApp)

    {

    }

// Second phase constructor.

void CCalcDocument::ConstructL()

    {

    iHistory = new (ELeave) CCalcHistory();

    }

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

// CCalcDocument::CalculateL

// Calculate result

// Leave may occur, causes KErrOverflow or KErrDivideByZero.

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

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

//

TReal64 CCalcDocument::CalculateL

        (TReal64 aOperand,

         TCalcEditLine::TCalcOperatorType aOperator) 

    {

    TReal64  result(iProvisionalResult);

    switch (aOperator)

        {

        case  TCalcEditLine::ECalcAdd:

            {

            result += aOperand;

            if( Abs(result)<= KCalcDefaultZero )

            	{

            	result = 0;

            	}

            break;

            }

        case  TCalcEditLine::ECalcSubtract:

            {

            result -= aOperand;

            if( Abs(result)<= KCalcDefaultZero )

            	{

            	result = 0;

            	}

            break;

            }

        case  TCalcEditLine::ECalcMultiply:

            {

            result *= aOperand;

            break;

            }

        case  TCalcEditLine::ECalcDivide:

            {

            if ( aOperand == 0 )

                {

                iCCalcView->UpdateState( CCalcView::EOperator );

                User::Leave(KErrDivideByZero); //  Error causes

                }

            else

                {

                result /= aOperand;

                }

            break;

            }

		case TCalcEditLine::ECalcSqrt:

			{

			if ( aOperand < 0 )

				{

                User::Leave(KErrNotSupported); //  Error causes

                }

			else

				Math::Sqrt(result, aOperand);

			break;

			}

		case TCalcEditLine::ECalcPercent:

			{

			result = (result * aOperand) / 100;

			break;

			}

        case  TCalcEditLine::ECalcOperatorNone:

            {

            result = aOperand;

            break;

            }

        default:

            {

            break;

            }

        }

    //  Check Result. If overflow, Leave occurs.

    CheckResultL(&result);

    // Overflow do not occur

    return  result;

    }

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

// CCalcDocument::CheckResultL

// Check overflow and underflow  

// Leave may occur, causes KErrOverflow.

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

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

//

void CCalcDocument::CheckResultL

                   (TReal64* aResult)    

    {

    // Set data format 

    TRealFormat realFormat(KCalcMaxNumberWidth, KCalcMaxDigits);  

    if ( *aResult >= 0 )

        {

        realFormat.iWidth--;

        }

    realFormat.iType = KRealFormatNoExponent;

    realFormat.iTriLen = 0;  //  Delimit character is nothing

    TLocale locale;

    TChar separator(locale.DecimalSeparator());

    realFormat.iPoint = separator;

    TBuf<KCalcMaxNumberWidth> buffer;  

    TInt code = buffer.Num(*aResult, realFormat);

    if(KErrOverflow == code || KErrUnderflow == code)

	    {

	    TRealFormat realFormat(KCalcMaxNumberWidth);  

	    if ( *aResult >= 0 )

	        {

	        realFormat.iWidth--;

	        }

	    realFormat.iType = KRealFormatExponent;

	    realFormat.iPlaces = 3;

	    realFormat.iTriLen = 0;  //  Delimit character is nothing

	    TLocale locale;

	    TChar separator(locale.DecimalSeparator());

	    realFormat.iPoint = separator;

	    TBuf<KCalcMaxNumberWidth> buffer;  

	    code = buffer.Num(*aResult, realFormat);

	    }

	switch (code)

        {

        case KErrOverflow:

            {

            User::Leave(KErrOverflow);  

            break;

            }

        case KErrUnderflow:

            {

            *aResult = 0.0;

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CCalcDocument::ExternalizeL

// Externalising of the last result and memory.

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

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

//

void CCalcDocument::ExternalizeL

        (RWriteStream& aStream) const 

    {

    aStream.WriteReal64L(iLastResult);  // Write last result

    aStream.WriteReal64L(iMemory);      // Write memory

    }

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

// CCalcDocument::InternalizeL

// Internalising of the last result and memory.

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

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

//

void CCalcDocument::InternalizeL

        (RReadStream& aStream) 

    {

    iLastResult = aStream.ReadReal64L();    // Read last result

    iMemory = aStream.ReadReal64L();        // Read memory

    // If read value is out of range, 

    // memory is replaced to default one.

    TRAPD(error, CheckResultL(&iMemory));

    if (error == KErrOverflow)

        {

        iMemory = KCalcDefaultMemory;

        }

    // If read value is out of range, 

    // last result is replaced to default one.

    TRAP(error, CheckResultL(&iLastResult));

    if (error == KErrOverflow)

        {

        iLastResult = KCalcDefaultLastResult;

        }

    }

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

// CCalcDocument::CreateAppUiL

// This function is called when Calculator application is opened. 

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

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

//

CEikAppUi* CCalcDocument::CreateAppUiL()

    {

    return new (ELeave) CCalcAppUi;

    }

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

// CCalcDocument::SaveStateL

// Store memory and last result

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

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

//

void CCalcDocument::SaveStateL()

{

		RFileWriteStream out;

		RFs fileSession;

		User::LeaveIfError(fileSession.Connect());

    	CleanupClosePushL(fileSession);

    	TFileName filePath;

		TBuf<1> tempDes;

		TChar driveChar;

    	User::LeaveIfError(fileSession.PrivatePath(filePath));

    	fileSession.DriveToChar(KDefaultDrive, driveChar);

    	tempDes.Append(driveChar);

    	filePath.Insert(0,KDelimiter);

    	filePath.Insert(0,tempDes);

    	filePath.Append(KCalculatorFilename);

    	TInt err( out.Replace( fileSession, filePath,EFileWrite ) );

	if( !err )

		{

		TRAP( err, ExternalizeL( out ) );

		out.Close();

		}

  	CleanupStack::PopAndDestroy();

}

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

// CCalcDocument::LoadStateL

// Restore memory and last result

// This function is called when document file exists. 

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

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

//   

    void CCalcDocument::LoadStateL()

    {

    	RFileReadStream in;

    	RFs fileSession;

    	User::LeaveIfError(fileSession.Connect());

    	CleanupClosePushL(fileSession);

		TFileName filePath;

		TBuf<1> tempDes;

		TChar driveChar;

    	User::LeaveIfError(fileSession.PrivatePath(filePath));

    	fileSession.DriveToChar(KDefaultDrive, driveChar);

    	tempDes.Append(driveChar);

    	filePath.Insert(0,KDelimiter);

    	filePath.Insert(0,tempDes);

    	filePath.Append(KCalculatorFilename);

		TInt err( in.Open( fileSession, filePath,

			EFileRead ) );

	if( !err )

		{

		TRAPD(readErr,InternalizeL( in ) );

		if ( readErr )

        {

        // Internalizing fails.

        iMemory = KCalcDefaultMemory;         // Reset memoey

        iLastResult = KCalcDefaultLastResult; // Reset last result

        }