/*

* Copyright (c) 2002-2006 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:  Text scrolling functionality.

*

*/

// INCLUDE FILES

#include <AknUtils.h>

#include <gulicon.h>

#include <AknsDrawUtils.h>

#include <AknBidiTextUtils.h>

#include "xnnewstickercontrol.h"

#include "xnnewstickeradapter.h"

#include "xnproperty.h"

// CONSTANTS

/**

* for the empty space in pixels between text and image.

*/

const TInt KGap = 10;

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

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

// CXnNewstickerControl::CTitleData::CTitleData

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

// might leave.

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

//

CXnNewstickerControl::CTitleData::CTitleData(TInt aLenghtInPixels) :

    iTitleIsSvg(EFalse), iTextLenghtInPixels(aLenghtInPixels)

    {

    }

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

// Destructor

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

//

CXnNewstickerControl::CTitleData::~CTitleData()

    {

    delete iText;

    delete iData;

    }

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

// CXnNewstickerControl::CTitleData::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnNewstickerControl::CTitleData::ConstructL(const TDesC& aTitle)

    {

    delete iText;

    iText = NULL;

    iText = aTitle.AllocL();

    }

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

// CXnNewstickerControl::CTitleData::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnNewstickerControl::CTitleData::ConstructL(const TDesC8& aByteData)

    {

    iTitleIsSvg = ETrue;

    iData = aByteData.AllocL();

    iText = KNullDesC().AllocL();

    }

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

// CXnNewstickerControl::CTitleData::NewL

// Two-phased constructor.

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

//

CXnNewstickerControl::CTitleData* CXnNewstickerControl::CTitleData::NewL(

                const TDesC& aTitle, TInt aLenghtInPixels)

    {

    CXnNewstickerControl::CTitleData* self =

            CXnNewstickerControl::CTitleData::NewLC(aTitle, aLenghtInPixels);

    CleanupStack::Pop(self);

    return self;

    }

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

// CXnNewstickerControl::CTitleData::NewLC

// Two-phased constructor.

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

//

CXnNewstickerControl::CTitleData* CXnNewstickerControl::CTitleData::NewLC(

                const TDesC& aTitle, TInt aLenghtInPixels)

    {

    CXnNewstickerControl::CTitleData* self =

            new(ELeave) CXnNewstickerControl::CTitleData(aLenghtInPixels);

    CleanupStack::PushL(self);

    self->ConstructL(aTitle);

    return self;

    }

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

// CXnNewstickerControl::CTitleData::NewL

// Two-phased constructor.

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

//

CXnNewstickerControl::CTitleData* CXnNewstickerControl::CTitleData::NewL(

                const TDesC8& aByteData)

    {

    CXnNewstickerControl::CTitleData* self =

            CXnNewstickerControl::CTitleData::NewLC(aByteData);

    CleanupStack::Pop(self);

    return self;

    }

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

// CXnNewstickerControl::CTitleData::NewLC

// Two-phased constructor.

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

//

CXnNewstickerControl::CTitleData* CXnNewstickerControl::CTitleData::NewLC(

                const TDesC8& aByteData)

    {

    CXnNewstickerControl::CTitleData* self =

            new(ELeave) CXnNewstickerControl::CTitleData();

    CleanupStack::PushL(self);

    self->ConstructL(aByteData);

    return self;

    }

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

// CXnNewstickerControl::CTitleData::TitleText

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

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

//

const TDesC& CXnNewstickerControl::CTitleData::TitleText()

    {

    return *iText;

    }

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

// CXnNewstickerControl::CTitleData::SetTitleText

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

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

//

void CXnNewstickerControl::CTitleData::SetTitleTextL(const TDesC& aTitle)

    {

    HBufC* newTitle = aTitle.AllocL();

    delete iText;

    iText = newTitle;

    }

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

// CXnNewstickerControl::CTitleData::TitleTextLengthInPixels

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

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

//

TInt CXnNewstickerControl::CTitleData::TitleTextLengthInPixels()

    {

    return iTextLenghtInPixels;

    }

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

// CXnNewstickerControl::CTitleData::SetTitleTextLengthInPixels

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

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

//

void CXnNewstickerControl::CTitleData::SetTitleTextLengthInPixels(TInt aLenghtInPixels)

    {

    iTextLenghtInPixels = aLenghtInPixels;    

    }

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

// CXnNewstickerControl::CTitleData::IsSvgTitle

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

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

//

TBool CXnNewstickerControl::CTitleData::IsSvgTitle()

    {

    return iTitleIsSvg;

    }

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

// CXnNewstickerControl::CTitleData::SvgTitleData

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

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

//

const TDesC8& CXnNewstickerControl::CTitleData::SvgTitleData()

    {

    return *iData;

    }

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

// CXnNewstickerControl::CXnNewstickerControl

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

// might leave.

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

//

CXnNewstickerControl::CXnNewstickerControl(CXnNewstickerAdapter* aAdapter) :     

    iFirstDrawingTitleIndex(0),

    iFirstDrawingOffset(0),

    iImageWidthInPixels(0),

    iCurrentTitleIndex(-1),

    iSeparatorimage(NULL),

    iSeparatorImageWidth(0),

    iFont(NULL),

    iTextBaseline(0),

    iTextColor(KRgbBlack),

    iUnderlining(EUnderlineOff),

    iStrikethrough(EStrikethroughOff),

    iIsWestern(ETrue),

    iAdapter(aAdapter),

    iTextAlignment(ELayoutAlignLeft)

    {

    }

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

// CXnNewstickerControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnNewstickerControl::ConstructL()

    {

    if(AknLayoutUtils::LayoutMirrored())

        {

    	iIsWestern = EFalse;

        iTextAlignment = ELayoutAlignRight;

        }

    }

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

// CXnNewstickerControl::NewL

// Two-phased constructor.

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

//

CXnNewstickerControl* CXnNewstickerControl::NewL(CXnNewstickerAdapter* aAdapter)

    {

    CXnNewstickerControl* self = new(ELeave)CXnNewstickerControl(aAdapter);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();    

    return self;

    }

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

// CXnNewstickerControl::~CXnNewstickerControl()

// Destructor.

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

//

CXnNewstickerControl::~CXnNewstickerControl()

    {

    iTitles.ResetAndDestroy();

    delete iSeparatorimage;

    }

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

// CXnNewstickerControl::SetScrollAmount

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

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

//

void CXnNewstickerControl::SetScrollAmount(TInt aScrollAmount)

    {

    iSpeed = aScrollAmount;

    }

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

// CXnNewstickerControl::SetNewstickerRect

// Set visible rect.

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

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

//

void CXnNewstickerControl::SetNewstickerRect(TRect& aContentRect)

    {

    if(iContentRect != aContentRect)

        {

        iContentRect = aContentRect;

        iTextBaseline = iContentRect.Height() / 2 + iFont->AscentInPixels() / 2;

        SetBeginningState();

        for(TInt i = 0; i < iTitles.Count(); i++)

            {

            if(!iTitles[i]->IsSvgTitle())

                {

                TInt textWidth = iFont->TextWidthInPixels(

                    iTitles[i]->TitleText());

                iTitles[i]->SetTitleTextLengthInPixels(textWidth);

                }

            }

        CalculateTextFitInNewstickerRect();        

        }

    }

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

// CXnNewstickerControl::IsWestern

// Returns ETrue if western layout is used, otherwise EFalse is returned.

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

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

//

TBool CXnNewstickerControl::IsWestern()

    {

    return iIsWestern;

    }

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

// CXnNewstickerControl::AppendTitleL

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

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

//

void CXnNewstickerControl::AppendTitleL(const TDesC& aTitle)

    {

    TInt textWidth = iFont->TextWidthInPixels(aTitle);

    CTitleData* title = CTitleData::NewLC(aTitle, textWidth);

    iTitles.AppendL(title);

    CleanupStack::Pop(title);

    CalculateTextFitInNewstickerRect();    

    // if this is the first item

    if(iTitles.Count() == 1) 

        {

        iCurrentTitleIndex = 0;

        iAdapter->StartL();    

        }

    }

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

// CXnNewstickerControl::InsertTitleL

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

//

void CXnNewstickerControl::InsertTitleL(const TDesC& aTitle, TInt aIndex)

    {

    TInt textWidth = iFont->TextWidthInPixels(aTitle);

    CTitleData* title = CTitleData::NewLC(aTitle, textWidth);

    iTitles.InsertL(title, aIndex);

    CleanupStack::Pop(title);

    CountIndexAfterInsertL(aIndex);

    CalculateTextFitInNewstickerRect();    

    }

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

// CXnNewstickerControl::UpdateTitleL

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

//

void CXnNewstickerControl::UpdateTitleL(const TDesC& aTitle, TInt aIndex)

    {

    if ( aIndex >= 0 && aIndex < iTitles.Count() )

        {

        CTitleData* titleData = iTitles[aIndex];    

        TInt textWidth = iFont->TextWidthInPixels(aTitle);

        titleData->SetTitleTextL(aTitle);

        titleData->SetTitleTextLengthInPixels(textWidth);

        CalculateTextFitInNewstickerRect();

        }

    else

        {

        AppendTitleL(aTitle);

        }

    }

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

// CXnNewstickerControl::DeleteTitle

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

//

void CXnNewstickerControl::DeleteTitleL(TInt aIndex)

    {

    TInt count = iTitles.Count();

    if (aIndex >= 0 && aIndex < count)

        {

        // If the last item will be deleted

        if(count == 1)

            {

            iAdapter->StopL();

            iFirstDrawingTitleIndex = GetNextTitleWithContent( 0 );

            SetBeginningState();

            iCurrentTitleIndex = -1;

            }

        if (aIndex == iFirstDrawingTitleIndex)

            {

            // If this happens to be the last item in the list

            if(aIndex == count - 1)

                {

                iFirstDrawingTitleIndex = GetNextTitleWithContent( 0 );

                }

            SetBeginningState();

            iCurrentTitleIndex = iFirstDrawingTitleIndex;

            }

        //  Check if the title was deleted before the current title

        else if (aIndex < iFirstDrawingTitleIndex)

            {

            iCurrentTitleIndex--;

            iFirstDrawingTitleIndex = GetNextTitleWithContent( iFirstDrawingTitleIndex-1, ETrue);

            }

        UpdateTitleL(KNullDesC, aIndex);

        CalculateTextFitInNewstickerRect();        

        }

    }

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

// CXnNewstickerControl::CurrentTitleIndex

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

//

TInt CXnNewstickerControl::CurrentTitleIndex()

    {

    return iCurrentTitleIndex;

    }

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

// CXnNewstickerControl::Title

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

//

const TDesC& CXnNewstickerControl::Title(TInt aIndex)

    {

    if (aIndex < 0 || aIndex > iTitles.Count())

        {

        return KNullDesC;

        }

    if (iTitles[aIndex]->IsSvgTitle())

        {

        return KNullDesC;

        }

    return iTitles[aIndex]->TitleText();

    }

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

// CXnNewstickerControl::SetSeparatorImageL

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

//

TInt CXnNewstickerControl::SetSeparatorImageL(CGulIcon* aIcon)

    {

    CFbsBitmap* bitmap = aIcon->Bitmap();

    if(AknIconUtils::IsMifIcon(bitmap))

        {

        delete iSeparatorimage;

        iSeparatorimage = aIcon;

        TInt maxHeight = iContentRect.Height();

        TSize size = TSize(maxHeight, maxHeight);        

        AknIconUtils::SetSize(bitmap, size, EAspectRatioPreservedAndUnusedSpaceRemoved);

        iSeparatorImageWidth = bitmap->SizeInPixels().iWidth + KGap;

        return KErrNone;

        }

    else

        {

        iSeparatorimage = NULL;

        return KErrNotSupported;

        }

    }

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

// CXnNewstickerControl::ClearTitles

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

//

void CXnNewstickerControl::ClearTitles()

    {

    TRAP_IGNORE(iAdapter->StopL());

    iFirstDrawingTitleIndex = 0;

    SetBeginningState();

    iCurrentTitleIndex = -1;

    // Don't delete just clear the contents

    for( TInt i = 0; i < iTitles.Count(); ++i )

        {

        TRAP_IGNORE( UpdateTitleL( KNullDesC, i ) );

        }

    iTextFitInNewstickerRect = EFalse;

    }

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

// CXnNewstickerControl::AppendSvgTitleL

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

//

void CXnNewstickerControl::AppendSvgTitleL(const TDesC8& aByteData)

    {

    CTitleData* title = CTitleData::NewLC(aByteData);

    iTitles.AppendL(title);

    CleanupStack::Pop(title);

    // if this is the first item

    if(iTitles.Count() == 1) 

        {

        iCurrentTitleIndex = 0;

        iAdapter->StartL();

        }

    }

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

// CXnNewstickerControl::InsertSvgTitleL

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

//

void CXnNewstickerControl::InsertSvgTitleL(const TDesC8& aByteData, TInt aIndex)

    {

    CTitleData* title = CTitleData::NewLC(aByteData);

    iTitles.InsertL(title, aIndex);

    CleanupStack::Pop(title);

    CountIndexAfterInsertL(aIndex);

    }

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

// CXnNewstickerControl::CurrentSvgTitle

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

//

const TDesC8& CXnNewstickerControl::CurrentSvgTitle()

    {

    CTitleData* title = iTitles[iFirstDrawingTitleIndex];

    //  Is it SVG title

    if (title->IsSvgTitle())

        {

        //  Yes, advance the title index

        iFirstDrawingTitleIndex++;

        if (iFirstDrawingTitleIndex >= iTitles.Count())

            {

            iFirstDrawingTitleIndex = 0;

            }

        //  Return the data

        return title->SvgTitleData();