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

 * Copyright (c) 2009, 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 <swtlaffacade.h>

#include <swtbrowserschemehandler.h>

#include <AknBidiTextUtils.h>

#include <AknsUtils.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include "swtfont.h"

#include "swtlink.h"

const TInt KBorderMargin = 1;

/**

 * Link fragment descriptor.

 * Holds information about unformatted link text fragments.

 */

NONSHARABLE_CLASS(CSwtLinkFragmentDescriptor)

        : public CBase

{

public:

    static CSwtLinkFragmentDescriptor* NewL(TInt aOffset, TInt aLength);

    static CSwtLinkFragmentDescriptor* NewL(TInt aOffset,

                                            TInt aLength, const TDesC& aTarget);

    TInt Offset() const;

    TInt Length() const;

    const TDesC* Target() const;

    virtual ~CSwtLinkFragmentDescriptor();

protected:

    CSwtLinkFragmentDescriptor(TInt aOffset, TInt aLength);

    void ConstructL(const TDesC& aTarget);

private:

    /**

     * Offset from beginning of the string

     */

    TInt iOffset;

    /**

     * Length of the fragment in characters

     */

    TInt iLength;

    /**

     * Fragment target. Either string returned by selection listener,

     * or NULL if fragment is non-active.

     * Own.

     */

    HBufC* iTarget;

};

/**

 * Drawable link fragment information container.

 * Holds information about formatted fragments created for drawing.

 */

NONSHARABLE_CLASS(CSwtDrawableLinkFragment)

        : public CBase

{

public:

    static CSwtDrawableLinkFragment* NewL(

        const TPtrC& aText,

        const TRect& aRect,

        const CFont& aFont,

        const CSwtLinkFragmentDescriptor* aFragmentDescriptor);

    virtual ~CSwtDrawableLinkFragment();

protected:

    CSwtDrawableLinkFragment(

        const TRect& aRect,

        const CSwtLinkFragmentDescriptor* aFragmentDescriptor);

    void ConstructL(const TPtrC& aText, const CFont& aFont);

public:

    const TDes& Text() const;

    const TRect& Rect() const;

    const CSwtLinkFragmentDescriptor* FragmentDescriptor() const;

private:

    /**

     * Rectangle into which fragment should be drawn.

     *

     */

    TRect iRect;

    /**

     * Pointer to fragment descriptor to which this instance belongs.

     * Not own.

     */

    const CSwtLinkFragmentDescriptor* iFragmentDescriptor;

    /**

     * Formatted text.

     */

    RBuf iFormattedText;

};

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

/**

 * Creates new instance of CSwtLink

 */

CSwtLink* CSwtLink::NewL(

    MSwtDisplay&   aDisplay,

    TSwtPeer       aPeer,

    MSwtComposite& aParent,

    TInt           aStyle)

{

    CSwtLink* self = new(ELeave) CSwtLink(aDisplay,

                                          aPeer,

                                          aParent,

                                          aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

/**

 * Destructor

 */

CSwtLink::~CSwtLink()

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif // RD_TACTILE_FEEDBACK

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    iText.Close();

    iFormattedText.Close();

    iDrawableLinkFragments.ResetAndDestroy();

    iDrawableLinkFragments.Close();

    iLinkFragmentsDescriptors.ResetAndDestroy();

    iLinkFragmentsDescriptors.Close();

}

/**

 * Constructor

 */

CSwtLink::CSwtLink(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

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

        , iTextLineCount(0)

        , iLineGap(0)

        , iLineHeight(0)

{

    // Orientation needs to be coerced if it wasn't given explicitly

    if (!(aStyle & KSwtOrientationMask))

    {

        iStyle &= ~KSwtOrientationMask;

    }

}

/**

 * Constructs current instnace

 */

void CSwtLink::ConstructL()

{

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

    SetContainerWindowL(coeParent);

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

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

    UpdateDefaultFontL();

    DoSetFont(&iDefaultFont->Font());

    UpdateMarginValues();

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

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#endif // RD_TACTILE_FEEDBACK

    ActivateL();

}

/**

 * Handles resource change

 * @param aType Type of resource change.

 */

void CSwtLink::SwtHandleResourceChangeL(TInt aType)

{

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        UpdateDefaultFontL();

        DoSetFont(&iDefaultFont->Font());

        UpdateMarginValues();

        BuildDrawableFragmentsListL(TextRect());

    }

}

/**

 * Updates default font

 */

void CSwtLink::UpdateDefaultFontL()

{

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(),

                                  iDisplay.Device().GetSystemFont()->Font());

}

/**

 * Updates margins

 */

void CSwtLink::UpdateMarginValues()

{

    TMargins8 padding = iDisplay.UiUtils().InlineReferencePadding();

    iHorizontalMargin = padding.iLeft;

    iVerticalMargin = padding.iTop;

}

/**

 * Builds list of fragment descriptors from array of text fragments and

 * array of their targets.

 *

 * @param aTextFragments Array of text fragments

 * @param aLinkTargets Array of strings which should be passed to

 *                     selection listener.

 * @returns Sum of all text fragments legths (ie. expected plain text

 *          length).

 *

 * @remark When aLinkTargets item is empty string, the aTextFragments

 *         item is considered to be non-active fragment.

 *         So active fragments are only those which have non-empty

 *         string in aLinkTargets array.

 */

TInt CSwtLink::BuildFragmentListL(

    const CDesCArray* aTextFragments,

    const CDesCArray* aLinkTargets)

{

    TInt actualTextLength = 0;

    iLinkFragmentsDescriptors.ResetAndDestroy();

    TInt fragmentCount = aTextFragments->Count();

    TInt targetCount = 0;

    for (TInt i = 0; i < fragmentCount; ++i)

    {

        if ((*aLinkTargets)[i].Length())

        {

            iLinkFragmentsDescriptors.AppendL(

                CSwtLinkFragmentDescriptor::NewL(

                    actualTextLength,

                    (*aTextFragments)[i].Length(),

                    (*aLinkTargets)[i]));

            targetCount++;

        }

        else

        {

            iLinkFragmentsDescriptors.AppendL(

                CSwtLinkFragmentDescriptor::NewL(

                    actualTextLength,

                    (*aTextFragments)[i].Length()));

        }

        actualTextLength += (*aTextFragments)[i].Length();

    }

    if (targetCount > 1)

    {

        iMultipleTargets = ETrue;

    }

    else

    {

        iMultipleTargets = EFalse;

    }

    return actualTextLength;

}

/**

 * Assembles control's plain text from text fragments.

 *

 * @param aTextFragments Array of string which will be concatenated to form

 *                      control's plain text.

 * @param aTextLength Expected length of the resulting string.

 */

void CSwtLink::AssembleLinkTextL(

    const CDesCArray* aTextFragments,

    TInt aTextLength)

{

    iText.Close();

    iText.CreateL(aTextLength);

    TInt numberOfLines = 1;

    for (TInt i = 0; i < aTextFragments->Count(); ++i)

    {

        TPtrC fragment = (*aTextFragments)[i];

        iText.Append(fragment);

        const TInt offset = fragment.Locate('\n');

        if (KErrNotFound != offset)

        {

            numberOfLines++;

        }

    }

    iTextLineCount = numberOfLines;

}

/**

 * Builds drawable fragment list from control's text and given

 * rectangle.

 *

 */

void CSwtLink::BuildDrawableFragmentsListL(const TRect& aRect)

{

    iDrawableLinkFragments.ResetAndDestroy();

    if (!iText.Length() || aRect.IsEmpty())

    {

        return;

    }

    const CFont& font(GetFont()->Font());

    const CGraphicsContext::TTextAlign alignment = GetAligment();

    const CFont::TMeasureTextInput::TFlags order = GetVisualOrder();

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

    const TInt ARRAY_GRANULARITY = 4;

    CArrayFixFlat<TPtrC>* linesArray =

        new(ELeave) CArrayFixFlat<TPtrC>(ARRAY_GRANULARITY);

    CleanupStack::PushL(linesArray);

    //Wrap text to lines

    WrapTextL(font, aRect, *linesArray);

    //If there are no lines or no formatted text, return

    if (!linesArray->Count() || !iFormattedText.Length())

    {

        return;

    }

    TInt currentLineIndex = 0;

    TInt currentLinePosition = 0;

    TInt currentTextPosition = 0;

    //Get Y offset so the text is centered vertically in the control.

    const TInt lineYOffset = GetLineYOffset(linesArray->Count(), aRect);

    //Here we will map fragment descriptors to wrapped text and create

    //drawable fragments which then will be drawn.

    for (TInt fragmentIndex = 0;

            fragmentIndex < iLinkFragmentsDescriptors.Count();

            ++fragmentIndex)

    {

        //get length of the text in current fragment descriptor

        TInt remainingFragmentLength =

            iLinkFragmentsDescriptors[fragmentIndex]->Length();

        while (remainingFragmentLength > 0 &&

                currentLineIndex < linesArray->Count())

        {

            TPtrC currentLine = linesArray->At(currentLineIndex);

            TInt remainingLineLength =

                currentLine.Length() - currentLinePosition;

            //Get width of the line in pixels and calculate X offset

            //for current aligment

            const TInt wholeLineWidth =

                AknBidiTextUtils::MeasureTextBoundsWidth(font,

                        currentLine, order);

            const TInt lineXOffset = GetLineXOffset(alignment,

                                                    wholeLineWidth, aRect.Width());

            //Determine how many characters will be used from

            //current text line

            TInt charsConsumed = remainingFragmentLength;

            if (remainingFragmentLength > remainingLineLength)

            {

                //Some chracters will be left for next text line

                charsConsumed = remainingLineLength;

            }

            //Calculate position to which current portion of text

            //should be drawn.

            TRect currentRect = GetDrawableFragmentRectangle(font,

                                currentLine, currentLinePosition,

                                charsConsumed, aRect.Width(),

                                lineXOffset, lineYOffset,

                                currentLineIndex);

            //Add new drawable fragment

            iDrawableLinkFragments.AppendL(

                CSwtDrawableLinkFragment::NewL(

                    currentLine.Mid(currentLinePosition, charsConsumed),

                    currentRect,

                    font,

                    iLinkFragmentsDescriptors[fragmentIndex]));

            if (remainingFragmentLength > remainingLineLength)

            {

                //Move to the next line

                ++currentLineIndex;

                currentTextPosition += remainingLineLength;

                currentLinePosition = 0;

                //Wrapping text strips trailing spces at the end of each line

                //Get correction for this.

                TInt correction = DoTrailingWhitespaceCorrection(

                                      currentTextPosition);

                currentTextPosition += correction;

                //Update number of characters remaining in current

                //fragment descriptor

                remainingFragmentLength -= charsConsumed + correction;

            }

            else

            {

                //Stay on current line

                currentTextPosition += charsConsumed;

                currentLinePosition += charsConsumed;

                remainingLineLength -= charsConsumed;

                remainingFragmentLength = 0;

            }

        }

    }

    linesArray->Reset();

    CleanupStack::PopAndDestroy(linesArray);

}

/**

 * Calculates rectangle for drawable fragment.

 * @param aFont Font.

 * @param aText Text to be drawn.

 * @param aLinePosition Position in iFormattedText.

 * @param aLength Length the text to be drawn.

 * @param aAvailableWidth Width available for drawing.

 * @param aXOffset X offset of the rectangle.

 * @param aYOffset Y offset of the rectangle.

 * @param aCurrentLineIndex Index of current line.

 * @returns Rectnagle into which the drawable fragment should be drawn.

 */

TRect CSwtLink::GetDrawableFragmentRectangle(const CFont& aFont,

        const TDesC& aText, const TInt aLinePosition,

        const TInt aLength, const TInt aAvailableWidth,

        const TInt aXOffset, const TInt aYOffset,

        const TInt aCurrentLineIndex) const

{

    CFont::TMeasureTextInput::TFlags order = GetVisualOrder();

    // Try to determine text directionality

    TBool found = EFalse;

    TInt directionality = TBidiText::TextDirectionality(aText, &found);

    if (found)

    {

        switch (directionality)

        {

        case TBidiText::ERightToLeft:

            order = CFont::TMeasureTextInput::EFVisualOrderRightToLeft;

            break;

        default:

            order = CFont::TMeasureTextInput::EFVisualOrder;

            break;

        }

    }

    const TInt leftX = AknBidiTextUtils::MeasureTextBoundsWidth(

                           aFont, aText.Left(aLinePosition), order);

    const TInt rightX = AknBidiTextUtils::MeasureTextBoundsWidth(

                            aFont, aText.Left(aLinePosition + aLength), order);

    TInt tlX = 0;

    TInt brX = 0;

    if (IsRtl())

    {

        tlX = aAvailableWidth - rightX;

        brX = aAvailableWidth - leftX;

    }

    else

    {

        tlX = aXOffset + leftX;

        brX = aXOffset + rightX;

    }

    TRect currentRect(

        tlX,

        aYOffset + aCurrentLineIndex *(iLineHeight + iLineGap),

        brX,

        aYOffset + (aCurrentLineIndex + 1) *(iLineHeight + iLineGap));

    return currentRect;

}

/**

 * Returns number of white spaces from the given position to

 * next non-white space character in formatted control's text.

 *

 * @param aCurrentTextPosition Current position in the formatted text

 * @returns Number of white spaces between aCurrentTextPosition and next

 *          non-white space character.

 * @remark This method is used to coerce position in iText while

 *          moving to the next line, because text wrapping strips

 *          trailing line spaces in the lines.

 */

TInt CSwtLink::DoTrailingWhitespaceCorrection(

    const TInt aCurrentTextPosition) const

{

    TInt correction = 0;

    const TInt textLen = iText.Length();

    if (aCurrentTextPosition < textLen)

    {

        TChar c(iText[aCurrentTextPosition]);

        while (c.IsSpace()

                && (aCurrentTextPosition + correction + 1) < textLen)

        {