/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <eiklbi.h>

#include <eikenv.h>

#include <AknsUtils.h>

#include <aknconsts.h>

#include <AknLayoutFont.h>

#include <AknBidiTextUtils.h>

#include <swtlaffacade.h>

#include <avkon.mbg>

#include "swtlabel.h"

#include "swtcontrolbase.h"

#include "swtfont.h"

const TInt KBorderMargin = 1;

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

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

// CSwtLabel::CSwtLabel

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

//

CSwtLabel::CSwtLabel(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                     MSwtComposite& aParent, TInt aStyle)

        : ASwtControlBase(aDisplay, aPeer, &aParent, aStyle)

        , iOriginalText(NULL)

{

    SetFocusing(EFalse);

}

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

// CSwtLabel::~CSwtLabel

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

//

CSwtLabel::~CSwtLabel()

{

    delete iEikLabel;

    delete iSeparatorHead;

    delete iSeparatorHeadMask;

    delete iSeparatorCenter;

    delete iSeparatorCenterMask;

    delete iSeparatorTail;

    delete iSeparatorTailMask;

    delete iOriginalText;

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

    }

    if (iImage != NULL)

        iImage->RemoveRef();

#ifdef _lint

    iDefaultFont = NULL;

    iImage       = NULL;

    iForegroundColor = NULL;

#endif

}

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

// CSwtLabel::ConstructL

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

//

void CSwtLabel::ConstructL()

{

    CCoeControl& coeParent = iParent->Control()->CoeControl();

    SetContainerWindowL(coeParent);

    CAknControl::MakeVisible(coeParent.IsVisible());

    CAknControl::SetDimmed(coeParent.IsDimmed());

    if (iStyle & KSwtStyleSeparator)

    {

        CreateSeparatorL();

    }

    else

    {

        CreateTextL();

    }

    SetBackground(this);   // Back will be drawn by ASwtControlBase::Draw

    ActivateL();

}

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

// CSwtLabel::CreateTextL

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

//

void CSwtLabel::CreateTextL()

{

    ASSERT(!(iStyle & KSwtStyleSeparator));

    ASSERT(!iEikLabel);

    iEikLabel = new(ELeave) CEikLabel();

    iEikLabel->SetFocusing(EFalse);

    iEikLabel->SetContainerWindowL(*this);

    iEikLabel->MakeVisible(EFalse);

    iEikLabel->SetDimmed(IsDimmed());

    iEikLabel->SetTextL(KNullDesC);

    SetAlignment(iStyle & KSwtAlignmentMask);

    RetrieveDefaultFontL();

    DoSetFontL(&iDefaultFont->Font());

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRgb defaultColor;

    if (AknsUtils::GetCachedColor(skin, defaultColor,

                                  KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6) == KErrNone)

    {

        iEikLabel->OverrideColorL(EColorLabelText, defaultColor);

    }

    // Correct position of CEikLabel will be set in PositionChanged()

}

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

// CSwtLabel::CreateSeparatorL

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

//

void CSwtLabel::CreateSeparatorL()

{

    ASSERT(!iEikLabel);

    ASSERT(!iImage);

    delete iSeparatorHead;

    iSeparatorHead = NULL;

    delete iSeparatorHeadMask;

    iSeparatorHeadMask = NULL;

    delete iSeparatorCenter;

    iSeparatorCenter = NULL;

    delete iSeparatorCenterMask;

    iSeparatorCenterMask = NULL;

    delete iSeparatorTail;

    iSeparatorTail = NULL;

    delete iSeparatorTailMask;

    iSeparatorTailMask = NULL;

    // Get skin and bitmap ids

    TAknsItemID separatorHeadSkinId;

    TAknsItemID separatorCenterSkinId;

    TAknsItemID separatorTailSkinId;

    TInt separatorCenterId;

    TInt separatorCenterMaskId;

    if (iStyle & KSwtStyleVertical)

    {

        if (iStyle & KSwtStyleShadowIn)

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwin);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwin);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwin);

        }

        else if (iStyle & KSwtStyleShadowOut)

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwout);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwout);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwout);

        }

        else

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwnone);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwnone);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwnone);

        }

    }

    else

    {

        if (iStyle & KSwtStyleShadowIn)

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwin);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwin);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwin);

        }

        else if (iStyle & KSwtStyleShadowOut)

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwout);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwout);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwout);

        }

        else

        {

            separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwnone);

            separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwnone);

            separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwnone);

        }

    }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    // first, try to get separator specific images from skin

    _LIT(KNoneFile," ");

    TInt err(KErrNone);

    TRAP(err, AknsUtils::CreateIconL(

             skin,

             separatorHeadSkinId,

             iSeparatorHead,

             iSeparatorHeadMask,

             KNoneFile,

             0,

             0));

    if (err == KErrNone)

    {

        TRAP(err, AknsUtils::CreateIconL(

                 skin,

                 separatorCenterSkinId,

                 iSeparatorCenter,

                 iSeparatorCenterMask,

                 KNoneFile,

                 0,

                 0));

    }

    if (err == KErrNone)

    {

        TRAP(err, AknsUtils::CreateIconL(

                 skin,

                 separatorTailSkinId,

                 iSeparatorTail,

                 iSeparatorTailMask,

                 KNoneFile,

                 0,

                 0));

    }

    if (err != KErrNone)

        // if separator specific images are not available from skin

        // try to use dashed line image from skin, or from image file

    {

        if (iStyle & KSwtStyleVertical)

        {

            separatorCenterSkinId = KAknsIIDQgnGrafLinePrimaryVerticalDashed;

            separatorCenterId = EMbmAvkonQgn_graf_line_primary_vertical_dashed;

            separatorCenterMaskId = EMbmAvkonQgn_graf_line_primary_vertical_dashed_mask;

        }

        else

        {

            separatorCenterSkinId = KAknsIIDQgnGrafLinePrimaryHorizontalDashed;

            separatorCenterId = EMbmAvkonQgn_graf_line_primary_horizontal_dashed;

            separatorCenterMaskId = EMbmAvkonQgn_graf_line_primary_horizontal_dashed_mask;

        }

        AknsUtils::CreateIconL(

            skin,

            separatorCenterSkinId,

            iSeparatorCenter,

            iSeparatorCenterMask,

            KAvkonBitmapFile,

            separatorCenterId,

            separatorCenterMaskId);

        delete iSeparatorHead;

        iSeparatorHead = NULL;

        delete iSeparatorHeadMask;

        iSeparatorHeadMask =NULL;

        delete iSeparatorTail;

        iSeparatorTail = NULL;

        delete iSeparatorTailMask;

        iSeparatorTailMask = NULL;

        iDashedLineSeparatorInUse =  ETrue;

    }

    // Get separator thickness

    TAknLayoutRect layoutRect;

    const TInt KBigEnough(50);

    if (iStyle & KSwtStyleVertical)

    {

        layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPane,

                     TRect(0, 0, KBigEnough, KBigEnough), 0);

        iSeparatorThickness = layoutRect.Rect().Size().iWidth;

    }

    else

    {

        layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorHorizontalPane,

                     TRect(0, 0, KBigEnough, KBigEnough), 0);

        iSeparatorThickness = layoutRect.Rect().Size().iHeight;

    }

    if (iDashedLineSeparatorInUse)

    {

        iSeparatorThickness = 1;

    }

    ResizeSeparatorImages();

}

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

// CSwtLabel::NewL

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

//

CSwtLabel* CSwtLabel::NewL(MSwtDisplay& aDisplay,

                           TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)

{

    CSwtLabel* self = new(ELeave) CSwtLabel(aDisplay, aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtLabel::ClipTextL

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

//

void  CSwtLabel::ClipTextL(TInt aWHint)

{

    if (iOriginalText == NULL || aWHint <= 0 || !iEikLabel)

    {

        return;

    }

    RBuf textToClip;

    textToClip.Create(*iOriginalText);

    textToClip.CleanupClosePushL();

    const CFont* font = iEikLabel->Font();

    if (iOriginalTextLineCount == 1)

    {

        if (aWHint > font->CharWidthInPixels(CEditableText::EEllipsis))

        {

            AknTextUtils::ClipToFit(textToClip, *font, aWHint);

        }

    }

    iEikLabel->SetTextL(textToClip);

    CleanupStack::PopAndDestroy(); // textToClip

}

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

// CSwtLabel::ComputeTextSizeL

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

//

TSize CSwtLabel::ComputeTextSizeL(TInt aWHint, TInt aHHint)

{

    // Return non default hints

    if (aWHint != KSwtDefault && aHHint != KSwtDefault)

    {

        return TSize(aWHint, aHHint);

    }

    // Compute size

    TSize prefSize(0, 0);

    if ((iStyle & KSwtStyleWrap) && !(aWHint == KSwtDefault && aHHint == KSwtDefault))

    {

        // Wrap text with a default hint

        if (aWHint != KSwtDefault)

        {

            prefSize.iWidth = aWHint;

            prefSize.iHeight = CalcWrappedTextHeightL(aWHint);

        }

        else

        {

            prefSize.iHeight = aHHint;

            prefSize.iWidth = CalcWrappedTextWidth(aHHint);

        }

    }

    else

    {

        // This will return the width of the longer line and height that fits all lines

        prefSize = MinimumSize();

    }

    // Avoid text touching the border

    prefSize += TPoint(2 * KBorderMargin, 2 * KBorderMargin);

    if (aHHint != KSwtDefault)

    {

        prefSize.iHeight = aHHint;

    }

    if (aWHint != KSwtDefault)

    {

        prefSize.iWidth = aWHint;

    }

    return prefSize;

}

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

// CSwtLabel::CalcWrappedTextHeightL

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

//

TInt CSwtLabel::CalcWrappedTextHeightL(TInt aWidth)

{

    if (iOriginalText == NULL || aWidth <= 0 || !iEikLabel)

    {

        return 0;

    }

    // Calculate the number of lines when wrapping text to the given rectangle

    const TInt ARRAY_GRANULARITY = 4;

    CArrayFixFlat<TPtrC>* wrappedArray = new(ELeave) CArrayFixFlat<TPtrC>(ARRAY_GRANULARITY);

    CleanupStack::PushL(wrappedArray);

    const CFont* font(iEikLabel->Font());

    // NOTE!!! AknTextUtils::WrapToArrayL behaves strange for strings that

    // contain '-' (dash) char. Sometimes return one lesser line if several

    // dashes are encountered.

    AknTextUtils::WrapToArrayL(*iOriginalText, aWidth, *font, *wrappedArray);

    TInt nbStrings = wrappedArray->Count();

    if (nbStrings < 1)

    {

        // It happens when aWidth < Char's width

        // here just set nBStrings to 1

        // so something can be visible.

        nbStrings = 1;

    }

    // Calculate text height

    const TInt result(MinimumHeight(nbStrings));

    wrappedArray->Reset();

    CleanupStack::PopAndDestroy(wrappedArray);

    return result;

}

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

// CSwtLabel::CalcWrappedTextWidth

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

//

TInt CSwtLabel::CalcWrappedTextWidth(TInt aHeight)

{

    if (iOriginalText == NULL || aHeight <= 0)

    {

        return 0;

    }

    // This will return the width of the longer line and height that fits all lines

    return MinimumWidth();

}

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

// CSwtLabel::WrapTextL

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

//

void CSwtLabel::WrapTextL(TSize aSize)

{

    WrapTextL(aSize.iWidth, aSize.iHeight);

}

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

// CSwtLabel::WrapTextL

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

//

void CSwtLabel::WrapTextL(TInt aWHint, TInt aHHint)

{

    if (iOriginalText == NULL || aWHint <= 0 || aHHint <= 0 || !iEikLabel)

    {

        return;

    }

    const CFont* font = iEikLabel->Font();

    // Estimate how many text rows within given rectangle

    // Use HeightInPixels same as MinimumHeight

    TInt textPaneHeight = font->HeightInPixels();

    const TInt gap = iEikLabel->PixelGapBetweenLines();

    // The last row in label does not add a gap after it. So...

    // aHHint = rows * textPaneHeight + (rows - 1) * gap; and therefore...

    TInt rows = (aHHint + gap) / (textPaneHeight + gap);

    if (rows < 1)

    {

        // It happens when hint height < Char's height

        // here just set nBStrings to 1

        // so something can be visible.

        rows = 1;

    }

    // Setup width arrray

    CArrayFixFlat< TInt >* widthsArray = new(ELeave) CArrayFixFlat< TInt >(rows);

    CleanupStack::PushL(widthsArray);

    widthsArray->SetReserveL(rows);

    TInt i;

    for (i = 0; i < rows; ++i)

    {

        widthsArray->AppendL(aWHint);

    }

    // Convert text into wrapped text with AKnTextUtils

    RBuf wrappedBuffer;

    const TInt KDouble(2);

    wrappedBuffer.CreateL(KDouble *(iOriginalText->Length()));

    wrappedBuffer.CleanupClosePushL();

    AknTextUtils::WrapToStringAndClipL(*iOriginalText, *widthsArray, *font, wrappedBuffer);

    // Set wrapped text

    iEikLabel->SetTextL(wrappedBuffer);

    CleanupStack::PopAndDestroy(); // wrappedBuffer

    CleanupStack::PopAndDestroy(widthsArray);

}

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

// CSwtLabel::RetrieveDefaultFontL

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

//