/*

* 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:  The OutputSheet sub-pane class, CCalcOutputSheet.

*                Derived from CCoeControl.

*                The CCalcOutputSheet displays histroy data.

*                History data is scroll up and down.

*

*/

// INCLUDE FILES

#include    <AknUtils.h>

#include    <Calcsoft.rsg>

#include    <applayout.cdl.h>

#include     <AknsDrawUtils.h>

#include    <layoutmetadata.cdl.h>

#include    "CalcEnv.h"

#include    "CalcCont.h"    

#include    "CalcOutSheet.h"

#include    "CalcDoc.h"

#include    "CalcEditline.h"

#include    "CalcAppUi.h"

#include    "CalcHistory.h"

#include    "CalcDrawingConst.laf"

#include "fbs.h"

#include <AknIconUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknFepInternalCRKeys.h>

#include <eiksbfrm.h> 

#include <eikscrlb.h>

//  LOCAL CONSTANTS AND MACROS  

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

// Two-phased constructor.

CCalcOutputSheet* CCalcOutputSheet::NewL(

                    CCalcContainer* aContainer)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aContainer);

    CleanupStack::Pop(self); 

    return self;

    }

// Destructor

CCalcOutputSheet::~CCalcOutputSheet()

    {

    delete iOpSheetContext;

    if(iOperatorLayout)

        {

        iOperatorLayout->Reset();

        delete iOperatorLayout;    

        }

    if(iOperandLayout)

        {

        iOperandLayout->Reset();

        delete iOperandLayout;    

        }

    if(iEqualLineLayout)

        {

        iEqualLineLayout->Reset();

        delete iEqualLineLayout;    

        }

    if(iResultsLineLayout)

        {

        iResultsLineLayout->Reset();

        delete iResultsLineLayout;    

        }

    if (iCRKey)

        {

        delete iCRKey;

        iCRKey = NULL;

        }

    //Delete the scrollbar frame

    if(iSBFrame)

        {

        delete iSBFrame;

        iSBFrame = NULL;

        }

    }

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

// CCalcOutputSheet::ScrollToBottomL

// Scroll to bottom line.

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

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

//

void CCalcOutputSheet::ScrollToBottomL()

    {

    iScrollOffset = 0;

    //If scrollbar is present, update the scrollbar as well

     if( AknLayoutUtils::PenEnabled()  )

        {

          UpdateScrollIndicatorL();

        }

    DrawNow();

    }

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

// CCalcOutputSheet::NotifyClearHistory

// Called after clearing calculation history.

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

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

//

void CCalcOutputSheet::NotifyClearHistoryL()

    {

    iScrollOffset = 0;

    if( AknLayoutUtils::PenEnabled()  )

    {

        UpdateScrollIndicatorL();    

    }

    DrawNow();

    }

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

// CCalcOutputSheet::CanUp

// Check whether scroll-up can be done or not.

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

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

//

TBool CCalcOutputSheet::CanUp() const

    {

    // The number of lines of the history which a document has is got.

    TInt historyLine(iCalcHistory->Count());

    if ( (iCalcOutputSheetLines + iScrollOffset) < historyLine )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CCalcOutputSheet::CanDown

// Check whether scroll-down can be done or not.

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

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

//

TBool CCalcOutputSheet::CanDown() const

    {

    // The number of lines of the history which a document has is got.

    return (iScrollOffset != 0);

    }

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

// CCalcOutputSheet::ScrollUp

// history is scrolled up.

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

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

//

void CCalcOutputSheet::ScrollUp()

    {

    if (CanUp())

        {

        iScrollOffset++;

        DrawNow();

        }

    }

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

// CCalcOutputSheet::ScrollDown

// history is scrolled down.

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

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

//

void CCalcOutputSheet::ScrollDown()

    {

    if (CanDown())

        {

        iScrollOffset--;

        DrawNow();

        }

    }

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

// might leave.

//

CCalcOutputSheet::CCalcOutputSheet() 

    {

    }

// default constructor can leave.

void CCalcOutputSheet::ConstructL

        (CCalcContainer* aContainer) 

    {

    SetContainerWindowL(*aContainer);

    iCalcContainer = aContainer;

    iCalcAppEnv = CCalcAppEnv::Static();

    iCalcPaper = iCalcAppEnv->PaperBitmap();

    iCalcAppEnv->ScalablePaperBitmaps(iCalcScalablePaper);

#ifdef __SCALABLE_ICONS

    iCalcResultsLine = iCalcAppEnv->ResultsLineBitmap();

#endif

    CCalcAppUi* appui = iCalcAppEnv->AppUi();

    CCalcDocument* calcDocument = 

                   STATIC_CAST(CCalcDocument*, appui->Document());

    iCalcHistory = calcDocument->History(); 

    TAknLayoutScalableParameterLimits listLimits;

    listLimits = AknLayoutScalable_Apps::list_calc_item_pane_ParamLimits();

    iCalcOutputSheetLines   = (listLimits.LastRow()-listLimits.FirstRow()) + 1;

    iOpSheetContext = CAknsBasicBackgroundControlContext::NewL(KAknsIIDQsnFrCalcPaper , TRect(0,0,0,0), EFalse);

    iOperatorLayout = new(ELeave)CArrayFixFlat<TAknLayoutText>(iCalcOutputSheetLines);

    iOperandLayout = new(ELeave)CArrayFixFlat<TAknLayoutText>(iCalcOutputSheetLines);

    iResultsLineLayout = new(ELeave)CArrayFixFlat<TAknLayoutRect>(iCalcOutputSheetLines-1);

    iEqualLineLayout = new(ELeave)CArrayFixFlat<TAknLayoutRect>(iCalcOutputSheetLines-1);

    iUiLanguage = User::Language();

    }

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

// CCalcOutputSheet::SizeChanged

// Set size of control.

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

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

//

void CCalcOutputSheet::SizeChanged()

    {

    TRAP_IGNORE( SizeChangedOutSheetL() );

    }

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

// CCalcOutputSheet::SizeChanged

// Set size of control.

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

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

//

void CCalcOutputSheet::SizeChangedOutSheetL()

    {

    TRect parentRect(iCalcContainer->Rect());

    TAknLayoutScalableParameterLimits listLimits;

    if(AknLayoutUtils::PenEnabled())

    {

        listLimits = AknLayoutScalable_Apps::list_calc_item_pane_ParamLimits(enTouch_enabled);    

    }

    else

    {

        listLimits = AknLayoutScalable_Apps::list_calc_item_pane_ParamLimits(enTouch_disabled);    

    }

    iCalcOutputSheetLines   = (listLimits.LastRow()-listLimits.FirstRow()) + 1;

    iOperatorLayout->ResizeL(iCalcOutputSheetLines);

    iOperandLayout->ResizeL(iCalcOutputSheetLines);

    iResultsLineLayout->ResizeL(iCalcOutputSheetLines-1);

    iEqualLineLayout->ResizeL(iCalcOutputSheetLines-1);

    iOperatorLayout->Reset();

    iOperandLayout->Reset();

    iResultsLineLayout->Reset();

    iEqualLineLayout->Reset();

    TAknLayoutRect rectParent;

    TAknWindowLineLayout layoutOfParentResultsLine;

    TAknLayoutRect rectListCalcPane;

    if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )

        {

            TAknWindowLineLayout  calcPaperPane;

            //For Touch UI Layouts, different configuration

            if( AknLayoutUtils::PenEnabled() )

            {

                if (Layout_Meta_Data::IsLandscapeOrientation())

                {

                    calcPaperPane = AknLayoutScalable_Apps::calc_paper_pane(enTouch_with_lsc).LayoutLine();

                }

                else

                {

                    calcPaperPane = AknLayoutScalable_Apps::calc_paper_pane(enTouch_with_prt).LayoutLine();

                }

            }

            else

            {

                calcPaperPane = AknLayoutScalable_Apps::calc_paper_pane(enTouch_disabled).LayoutLine();

            }

            TAknLayoutRect rectcalcPaperPane;    

            rectcalcPaperPane.LayoutRect(parentRect,calcPaperPane);

            iSBBrPoint = rectcalcPaperPane.Rect().iBr;

            TAknWindowLineLayout layoutListCalcPane;

            if( AknLayoutUtils::PenEnabled() )

            {

                layoutListCalcPane = AknLayoutScalable_Apps::list_calc_pane(enTouch_enabled).LayoutLine();

            }

            else

            {

                layoutListCalcPane = AknLayoutScalable_Apps::list_calc_pane(enTouch_disabled).LayoutLine();

            }

            rectListCalcPane.LayoutRect(rectcalcPaperPane.Rect(),layoutListCalcPane);

        }

    TInt nTimes=(iCalcOutputSheetLines-1);

    for (TInt cnt(0); cnt < iCalcOutputSheetLines; cnt++)

        {

        if (AknLayoutUtils::ScalableLayoutInterfaceAvailable())

        {

        if(AknLayoutUtils::PenEnabled())

        {

            if (Layout_Meta_Data::IsLandscapeOrientation())

            {

                layoutOfParentResultsLine =  AknLayoutScalable_Apps::list_calc_item_pane(nTimes,enTouch_enabled).LayoutLine();    

            }

            else

            {

                layoutOfParentResultsLine =  AknLayoutScalable_Apps::list_calc_item_pane(nTimes,enTouch_enabled).LayoutLine();

            }

        }

        else

        {

            layoutOfParentResultsLine =  AknLayoutScalable_Apps::list_calc_item_pane(nTimes,enTouch_disabled).LayoutLine();    

        }

        rectParent.LayoutRect(rectListCalcPane.Rect(),layoutOfParentResultsLine) ;

        TAknLayoutText operatorLayout;

        TAknLayoutText operendLayout;

        if(AknLayoutUtils::PenEnabled())

        {

            operatorLayout.LayoutText(rectParent.Rect(),AknLayoutScalable_Apps::list_calc_item_pane_t2(enTouch_with_prt).LayoutLine(),iCalcAppEnv->OutSheetOperatorFont()); 

            iOperatorLayout->AppendL(operatorLayout);

            operendLayout.LayoutText(rectParent.Rect(),AknLayoutScalable_Apps::list_calc_item_pane_t1(enTouch_with_lsc).LayoutLine(),iCalcAppEnv->OutSheetOperatorFont()); 

            iOperandLayout->AppendL(operendLayout);

        }

        else

        {

            operatorLayout.LayoutText(rectParent.Rect(),AknLayoutScalable_Apps::list_calc_item_pane_t2(enTouch_disabled).LayoutLine(),iCalcAppEnv->OutSheetOperatorFont()); 

            iOperatorLayout->AppendL(operatorLayout);

            operendLayout.LayoutText(rectParent.Rect(),AknLayoutScalable_Apps::list_calc_item_pane_t1(enTouch_disabled).LayoutLine(),iCalcAppEnv->OutSheetOperatorFont()); 

            iOperandLayout->AppendL(operendLayout);    

        }

      // aCustomFont

     --nTimes;

        }

      else

      {

      //Scalable UI.

          TAknLayoutText operatorLayout;

        TAknLayoutText operendLayout;

          operatorLayout.LayoutText(parentRect,AppLayout::Calculator_texts_Line_8(nTimes),iCalcAppEnv->OutSheetOperatorFont()); // aCustomFont

        iOperatorLayout->AppendL(operatorLayout);        

        operendLayout.LayoutText(parentRect,AppLayout::Calculator_texts_Line_7(nTimes), NULL);

        iOperandLayout->AppendL(operendLayout);            

     --nTimes;

      }

    }

    //Scalable UI.

    nTimes = iCalcOutputSheetLines - 2;      

    for (TInt ii(0); ii < (iCalcOutputSheetLines - 1); ii++)

        {

        if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )

            {

#ifdef __SCALABLE_ICONS        

            layoutOfParentResultsLine =  AknLayoutScalable_Apps::list_calc_item_pane(nTimes).LayoutLine();

            rectParent.LayoutRect(rectListCalcPane.Rect(),layoutOfParentResultsLine) ;

            TAknWindowLineLayout   layoutOfResultsLine = AknLayoutScalable_Apps::list_calc_item_pane_g1().LayoutLine(); 

            TAknLayoutRect lineLayout;

            lineLayout.LayoutRect(rectParent.Rect(),layoutOfResultsLine);

            iResultsLineLayout->AppendL(lineLayout);

#else

            TAknLayoutRect lineLayout;

            lineLayout.LayoutRect(parentRect,AppLayout::Calculator_elements_Line_3(nTimes)); 

            iEqualLineLayout->AppendL(lineLayout);

#endif

            }

            else

            {

            TAknLayoutRect lineLayout;

            lineLayout.LayoutRect(parentRect,AppLayout::Calculator_elements_Line_3(nTimes)); 

            iEqualLineLayout->AppendL(lineLayout);

            }

        --nTimes;

        }

    TAknLayoutRect  paperRect;

    if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )

            {

            TAknLayoutRect rectCalcPaperPane;    

            TAknLayoutRect rectbgCalcPaperPane;

            //Different configuration for Touch Layouts

            if( AknLayoutUtils::PenEnabled() )

            {

                    //In landscape mode different configuration is needed

                 if (Layout_Meta_Data::IsLandscapeOrientation())

                 {

                    rectCalcPaperPane.LayoutRect(parentRect,AknLayoutScalable_Apps::calc_paper_pane(enTouch_with_lsc).LayoutLine());  

                 }

                 else

                 {

                    rectCalcPaperPane.LayoutRect(parentRect,AknLayoutScalable_Apps::calc_paper_pane(enTouch_with_prt).LayoutLine());      

                 }

                 rectbgCalcPaperPane.LayoutRect(rectCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane(enTouch_enabled).LayoutLine());

            }

            else

            {

                rectCalcPaperPane.LayoutRect(parentRect,AknLayoutScalable_Apps::calc_paper_pane(enTouch_disabled).LayoutLine());    

                rectbgCalcPaperPane.LayoutRect(rectCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane().LayoutLine());

            }

            iPaperPaneRect  = rectCalcPaperPane;

            iCalcPaperLayout[0].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g1().LayoutLine());

            iCalcPaperLayout[1].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g2().LayoutLine());

            iCalcPaperLayout[2].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g3().LayoutLine());

            iCalcPaperLayout[3].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g4().LayoutLine());

            iCalcPaperLayout[4].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g5().LayoutLine());

            iCalcPaperLayout[5].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g6().LayoutLine());

            iCalcPaperLayout[6].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g7().LayoutLine());

            iCalcPaperLayout[7].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::bg_calc_paper_pane_g8().LayoutLine());

            iCalcPaperLayout[8].LayoutRect(rectbgCalcPaperPane.Rect(),AknLayoutScalable_Apps::calc_bg_paper_pane_g9().LayoutLine());

            }

       iOpSheetContext->SetRect(Rect());

        //Only for touch UI, scrollbars are present

       if( AknLayoutUtils::PenEnabled()  )

        {

          UpdateScrollIndicatorL();

        }

        else

        {

        if(iSBFrame)

        {

            delete(iSBFrame);

            iSBFrame = NULL;

        }

        }

        }

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

// CCalcOutputSheet::UpdateScrollIndicatorL

// Creates and updates the scrollbar

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

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

void CCalcOutputSheet::UpdateScrollIndicatorL()

    {

        if( !AknLayoutUtils::PenEnabled()  )

        {

            return;

        }

        TAknLayoutRect rectCalcScrollPane;    

        //Get the layout information for the scrollbar

        if( AknLayoutUtils::PenEnabled() )

        {

         if (Layout_Meta_Data::IsLandscapeOrientation())

         {

            rectCalcScrollPane.LayoutRect(iPaperPaneRect.Rect(),AknLayoutScalable_Apps::scroll_pane_cp024().LayoutLine());  

         }

         else

         {

            rectCalcScrollPane.LayoutRect(iPaperPaneRect.Rect(),AknLayoutScalable_Apps::scroll_pane_cp024().LayoutLine());      

         }

        }

                //Create scrollbar if not created already

        if ( !iSBFrame )

        {

        //Make this class as the observer class as well

        iSBFrame = new( ELeave ) CEikScrollBarFrame( this,this, ETrue );

        // Decide which type of scrollbar is to be shown

        CAknAppUi* appUi = iAvkonAppUi;

        if (AknLayoutUtils::DefaultScrollBarType(appUi) == CEikScrollBarFrame::EDoubleSpan)

        {

            // For EDoubleSpan type scrollbar

            iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse); // non-window owning scrollbar            

            iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);

        }

        else

        {

            // For EArrowHead type scrollbar

            iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EArrowHead);

        }  

        iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EOff);

        }

        TEikScrollBarModel hSbarModel;

        TEikScrollBarModel vSbarModel;

        //By default span is one if only one page is present

        if(iCalcHistory->Count() < iCalcOutputSheetLines)