/*
* Copyright (c) 2010 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:  Easy dialing test application.
*
*/

// INCLUDE FILES
#include "edta_screentextbuffer.h"
#include "edta_debugprint.h"
#include "edta.pan"

#include <coemain.h>
#include <aknsbasicbackgroundcontrolcontext.h>
#include <eiksbfrm.h>
#include <eikenv.h>
#include <eikdef.h>
#include <aknappui.h>
#include <aknutils.h>


const TInt KLineWidthCent = 90; // Percent of total screen width
const TInt KHeightMarginCent = 7; // Percent of total height
const TInt KBottomMarginCent = 3; // Percent of total height
const TInt KLineHeightCent = 135; // How many percent is the line height of font height
const TInt KCent = 100;
const TInt KInitialScreenBufferSize = 20; // This many lines is initially allocated to the screen buffer.
const TInt KInitialScreenStartAmount = 5; // This many screen starts are initially allocated to screen buffer.


CEdtaScreenTextBuffer* CEdtaScreenTextBuffer::NewL( const TRect& aRect )
    {
    CEdtaScreenTextBuffer* self = CEdtaScreenTextBuffer::NewLC( aRect );
    CleanupStack::Pop( self );
    return self;
    }

CEdtaScreenTextBuffer* CEdtaScreenTextBuffer::NewLC( const TRect& aRect )
    {
    CEdtaScreenTextBuffer* self = new ( ELeave ) CEdtaScreenTextBuffer;
    CleanupStack::PushL( self );
    self->ConstructL( aRect );
    return self;
    }

// constructors
CEdtaScreenTextBuffer::CEdtaScreenTextBuffer()
    {
    }

void CEdtaScreenTextBuffer::ConstructL( const TRect& aRect )
    {
    CreateWindowL();
    CalculateL(aRect);
    ActivateL();
    }

// destructor
CEdtaScreenTextBuffer::~CEdtaScreenTextBuffer()
    {
    delete iSBFrame;
    delete iScreenStarts;

    if ( iText )
        {
        iText->ResetAndDestroy();
        delete iText;
        }
    }

void CEdtaScreenTextBuffer::SizeChanged()
    {
    // TRAP_IGNORE( CalculateL( Rect() ) );
    // DrawDeferred();
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::Draw()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::Draw( const TRect& aRect ) const
    {
	// DebugPrintF(_L("CEdtaScreenTextBuffer::Draw, rect: %d, %d - %d, %d"), aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY );

    __ASSERT_DEBUG( iText, Panic(EEdtaFieldNotInitialized,_L("CEdtaScreenTextBuffer::Draw: iText == NULL") ));
    __ASSERT_DEBUG( iScreenStarts, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::Draw: iScreenStarts == NULL") ));
    __ASSERT_DEBUG( iScreenStarts->Count() > 0, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::Draw: iScreenStarts has zero elements") ));

    CWindowGc& gc = SystemGc();

    gc.SetBrushColor( KRgbWhite );
    gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
    gc.Clear( aRect );
    
    if ( IsFocused() )
        {
        TRect frame( aRect );
        frame.Shrink(3,3);
        frame.iBr.iX -= 10;
        gc.SetPenColor(KRgbBlack);
        gc.SetPenSize( TSize(2,2) );
        TSize cornerRounding(8,8);
        gc.DrawRoundRect( frame, cornerRounding );
        }
    
    gc.UseFont( iFont );

    // index of the first line on the screen in the text array
    TInt firstLine = 0 ;
    if((iScreenStarts ) && (iScreenStarts->Count() > iCurrentScreen))
        {
        firstLine = ( (*iScreenStarts)[ iCurrentScreen ] );
        }
    else
        {
        firstLine = (*iScreenStarts)[ iScreenStarts->Count() - 1 ];
        }

    // index of the last line on the screen in the text array
    TInt lastLine( firstLine + iLinesPerScreen - 1 );

    gc.SetBrushStyle( CGraphicsContext::ENullBrush );

    TPoint position( iTopBaseLineX, iTopBaseLineY );
    TPoint topLeft;
    TSize rectSize( iLineWidth, iBaseLineDelta +iFont->DescentInPixels() );

    for ( TInt index = firstLine; index < iText->Count() && index <= lastLine; index++, position.iY += iBaseLineDelta )
        {
        HBufC* text = (*iText)[ index ];

        if ( text )
            {
            topLeft = TPoint( position.iX, position.iY-iBaseLineDelta );
            gc.SetPenColor(KRgbBlack);
            gc.DrawText( *text, TRect( topLeft, rectSize ), iBaseLineDelta, iTextAlign );
            }
        }

    gc.DiscardFont();

    // DebugPrintF(_L("CEdtaScreenTextBuffer::Draw exit"));
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::ActivateL()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::ActivateL()
    {
    CCoeControl::ActivateL();
    UpdateScrollIndicatorL();
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::SetTextL()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::WriteLineL(TRefByValue<const TDesC> aText,... )
    {
    TBuf<KEdtaMaxLineWidth> bufLine;
    VA_LIST list;
    VA_START(list,aText);
    bufLine.FormatList(aText,list);

    if(!bufLine.Length())
        {
        iText->AppendL( NULL );
        }
    else
        {
        HBufC* line = HBufC::NewLC(bufLine.Length());
        *line = bufLine;
        iText->AppendL( line );
        CleanupStack::Pop(line);
        }

    // Updating scrollbars and screen starts etc are moved to UpdateScrollIndicatorL()

    // if text, last line is shown again in next screen
    iDoNotShowLastLineAgain = EFalse;

    DrawDeferred(); //New
    UpdateScrollIndicatorL();
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::DeleteLastLine()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::DeleteLastLine(TInt aCount)
    {
    __ASSERT_DEBUG( iText, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::DeleteLastLine: iText == NULL") ));
    __ASSERT_DEBUG( iText->Count() > 0, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::DeleteLastLine: iText has zero elements") ));

    while (aCount > 0)
        {
        // Avoiding memory leaks
        TInt lastIndex = iText->Count() - 1;

        // The first item in iText cannot be deleted, since UpdateScrollIndicatorL
        // relies on there being at least one item.
        if (lastIndex > 0)
            {
            HBufC* text = (*iText)[ lastIndex ];
            delete text;
            iText->Delete(lastIndex);
            }
        --aCount;
        }
    }



// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::OfferKeyEventL()
// -----------------------------------------------------------------------------
TKeyResponse CEdtaScreenTextBuffer::OfferKeyEventL( const TKeyEvent& aKeyEvent,
                                              TEventCode aType )
    {
    __ASSERT_DEBUG(iScreenStarts, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::OfferKeyEventL: iScreenStarts == NULL") ));
    __ASSERT_DEBUG(iScreenStarts->Count() > 0, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::OfferKeyEventL: iScreenStarts has zero elements") ));

    if ( aType == EEventKey && iScreenStarts->Count() > 1 )
        {
        switch ( aKeyEvent.iCode )
            {
            case EKeyUpArrow:
                if ( iCurrentScreen > 0 )
                    {
                    iCurrentScreen--;
                    DrawNow();
                    UpdateScrollIndicatorL();
                    }
                break;

            case EKeyDownArrow:
                if ( iCurrentScreen < iScreenStarts->Count() - 1 )
                    {
                    iCurrentScreen++;
                    DrawNow();
                    UpdateScrollIndicatorL();
                    }
                break;

            default:
                return EKeyWasNotConsumed;
            }
        }

    return EKeyWasConsumed;
    }



// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::FocusChanged()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::FocusChanged(TDrawNow aDrawNow)
    {
    if ( aDrawNow == EDrawNow )
        {
        DrawNow();
        }
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::HandleScrollEventL()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::HandleScrollEventL ( CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)
    {
    //Only on page up/down,scroll up/down and drag events
    switch (aEventType)
        {
        case EEikScrollPageDown:
        case EEikScrollPageUp:
        case EEikScrollThumbDragVert:
        case EEikScrollUp:
        case EEikScrollDown:

            iCurrentScreen = aScrollBar->ThumbPosition();

            //Refresh now
            DrawNow();
            UpdateScrollIndicatorL();
            break;
        }
    }

// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::UpdateScrollIndicatorL()
//
// This function assumes that
// - iText exists and has at least one element.
// - iScreenStarts exist and has at least one element.
// These conditions are met if CalculateL / ConstructL has been called.
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::UpdateScrollIndicatorL()
    {
    __ASSERT_DEBUG( iText, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::UpdateScrollIndicatorL: iText == NULL") ));
    __ASSERT_DEBUG( iText->Count() > 0, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::UpdateScrollIndicatorL: iText has zero elements") ));
    __ASSERT_DEBUG( iScreenStarts, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::UpdateScrollIndicatorL: iScreenStarts == NULL") ));
    __ASSERT_DEBUG( iScreenStarts->Count() > 0, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::UpdateScrollIndicatorL: iScreenStarts has zero elements") ));

    TInt lastLine( iText->Count() - 1 );
    TInt screenStart( (*iScreenStarts)[ iScreenStarts->Count() - 1 ] );

    TBool firstNewScreenHandled( EFalse );

    while ( lastLine >= screenStart + iLinesPerScreen )
        {
        if ( !firstNewScreenHandled && iDoNotShowLastLineAgain )
            {
            screenStart++;
            firstNewScreenHandled = ETrue;
            }

        // If the shows screen is the last on, scroll the view along with new lines.
        if (iCurrentScreen == iScreenStarts->Count() - 1)
            {
            iCurrentScreen++;
            }

        screenStart += iLinesPerScreen - 1;
        iScreenStarts->AppendL( screenStart );
        }

    if ( !iSBFrame )
        {
        iSBFrame = new( ELeave ) CEikScrollBarFrame( this, NULL, ETrue );

        iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse); // non-window owning scrollbar
        iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);

        iSBFrame->SetScrollBarFrameObserver(this);
        iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EAuto);
        }

    TEikScrollBarModel vSbarModel;
    vSbarModel.iThumbPosition = iCurrentScreen;
    vSbarModel.iScrollSpan = iScreenStarts->Count();
    vSbarModel.iThumbSpan = 1;

    TRect rect(Rect());
    TEikScrollBarFrameLayout layout;
    layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;

    // For EDoubleSpan type scrollbar
    if (vSbarModel.iThumbPosition + vSbarModel.iThumbSpan > vSbarModel.iScrollSpan)
        {
        // Not let scrollbar values overflow
        vSbarModel.iThumbPosition = vSbarModel.iScrollSpan - vSbarModel.iThumbSpan;
        }

    TAknDoubleSpanScrollBarModel vDsSbarModel(vSbarModel);
    iSBFrame->TileL(NULL, &vDsSbarModel, rect, rect, layout);
    iSBFrame->SetVFocusPosToThumbPos(vDsSbarModel.FocusPosition());
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::CalculateL()
// Needs to be called in construction, and whenever layout changes.
// Screen orientation change, etc.
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::CalculateL(const TRect& aRect)
    {
    // DebugPrintF(_L("CEdtaScreenTextBuffer::CalculateL, rect: %d, %d - %d, %d"), aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY  );

    TRect rect(0,0,0,0);

    iCurrentScreen = 0;

    iFont = AknLayoutUtils::FontFromId(EAknLogicalFontSecondaryFont);

    // Calculate various text positioning parameters
    iBaseLineDelta = iFont->HeightInPixels() * KLineHeightCent / KCent;

    TInt mainPaneWidth( aRect.iBr.iX - aRect.iTl.iX );
    TInt mainPaneHeight( aRect.iBr.iY - aRect.iTl.iY );
    // Line width is 90% (by default) of client rect, and horizontal margins 10%
    iLineWidth = mainPaneWidth * KLineWidthCent / KCent;

    iTopBaseLineX = ( mainPaneWidth - iLineWidth ) / 2;

    // top margin is 7% (by default) of the client rect
    TInt topMargin = mainPaneHeight * KHeightMarginCent / KCent;
    iTopBaseLineY = topMargin + iFont->AscentInPixels();

    // minimum bottom margin is 3% (by default) of the client rect
    TInt bottomMargin = mainPaneHeight * KBottomMarginCent / KCent;
    iLinesPerScreen =
        ( mainPaneHeight - topMargin - bottomMargin ) / iBaseLineDelta;

    iTextAlign = CGraphicsContext::ELeft;

    // Text must not be deleted, otherwise all accumulated data will be lost.
    if ( !iText )
        {
        // Every text line on screen is one entry in this array
        iText = new( ELeave ) CArrayPtrFlat<HBufC>( KInitialScreenBufferSize );
        iText->AppendL(NULL); // Extra newline for visual reasons
        }

     if ( iScreenStarts )
        {
        delete iScreenStarts;
        iScreenStarts = NULL;
        }


    // This array contains indices for lines that start the subsequent
    // screens, for custom scrolling
    iScreenStarts = new( ELeave ) CArrayFixFlat<TInt>( KInitialScreenStartAmount );
    // Initialisation: first screen starts at line 0.
    iScreenStarts->AppendL( 0 );

    if ( iSBFrame )
        {
        delete iSBFrame;
        iSBFrame = NULL;
        }

    UpdateScrollIndicatorL();
    }


// -----------------------------------------------------------------------------
// CEdtaScreenTextBuffer::HandleResourceChange()
// -----------------------------------------------------------------------------
void CEdtaScreenTextBuffer::HandleResourceChange(TInt aType)
    {
    switch ( aType )
        {
        case KEikDynamicLayoutVariantSwitch :
            {
            TRAPD( error, CalculateL( iAvkonAppUi->ClientRect() ));

            if( error != KErrNone )
                {
                DebugPrintF(_L("CEdtaScreenTextBuffer::HandleResourceChange: CalculateL -method failed: %d"), error );
                }
            else
                {
                DrawNow();
                }
            }
            break;

        case KAknsMessageSkinChange :
            {
            __ASSERT_DEBUG(iSBFrame, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::HandleResourceChange: iSBFrame == NULL") ));

            TRAPD( error,
                {
                iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse); // window owning scrollbar
                iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);
                iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EOn);
                UpdateScrollIndicatorL();
                }
            );

            if( error != KErrNone )
                {
                DebugPrintF(_L("CEdtaScreenTextBuffer::HandleResourceChange: Create ScrollBars failed: %d"), error );
                __ASSERT_DEBUG( error == KErrNone, Panic(EEdtaFieldNotInitialized, _L("CEdtaScreenTextBuffer::HandleResourceChange => Skin change caused panic") ));
                }
            }

        default:
            {
            CCoeControl::HandleResourceChange(aType);
            }
            break;
        }
    }


// ---------------------------------------------------------
// CEdtaScreenTextBuffer::MopSupplyObject()
// Pass skin information if need.
// ---------------------------------------------------------
TTypeUid::Ptr CEdtaScreenTextBuffer::MopSupplyObject(TTypeUid aId)
    {
    return CCoeControl::MopSupplyObject(aId);
    }


// End of file