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

 * 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 <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 "swthyperlink.h"

// The scheme prefixes used by the scheme handler to recognise the content type

_LIT(KSwtHyperLinkMail, "mailto:");

_LIT(KSwtHyperLinkTel, "tel:");

_LIT(KSwtHyperLinkHttp, "http://");

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

CSwtHyperLink* CSwtHyperLink::NewL(MSwtDisplay&   aDisplay,

                                   TSwtPeer       aPeer,

                                   MSwtComposite& aParent,

                                   TInt           aStyle)

{

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

            aPeer,

            aParent,

            aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

CSwtHyperLink::~CSwtHyperLink()

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif // RD_TACTILE_FEEDBACK

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    iFormattedText.Close();

    iOriginalText.Close();

}

CSwtHyperLink::CSwtHyperLink(MSwtDisplay&   aDisplay,

                             TSwtPeer       aPeer,

                             MSwtComposite& aParent,

                             TInt           aStyle)

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

        , iFormat(MSwtHyperLink::EInvalid)

{

}

void CSwtHyperLink::ConstructL()

{

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

    SetContainerWindowL(coeParent);

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

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

    UpdateDefaultFontL();

    iFormattedText.CreateL(KNullDesC);

    iOriginalText.CreateL(KNullDesC);

    UpdateSkinColor();

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

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#endif // RD_TACTILE_FEEDBACK

    ActivateL();

}

void CSwtHyperLink::SwtHandleResourceChangeL(TInt aType)

{

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        UpdateDefaultFontL();

    }

    else if (aType == KAknsMessageSkinChange)

    {

        if (!iCustomTextColor)

        {

            UpdateSkinColor();

        }

    }

}

void CSwtHyperLink::DrawText(CWindowGc& aGc,

                             const CFont* aFont,

                             const TDesC& aText,

                             const TRect& aTextRect,

                             const CGraphicsContext::TTextAlign& aAlignment) const

{

    if (!aFont)

    {

        return;

    }

    // Vertically center the text inside the text rect

    const TInt excessSpace = aTextRect.Height() - aFont->FontMaxHeight();

    const TInt baseLineY = (excessSpace / 2) + aFont->FontMaxAscent();

    TPtrC textToDraw(aText.Ptr(), aText.Length());

    RBuf convertedText;

    TInt error = convertedText.Create(aText.Length() + KAknBidiExtraSpacePerLine);

    if (error == KErrNone)

    {

        TInt availableWidth(aTextRect.Width());

        TBool clipped = AknBidiTextUtils:: ConvertToVisualAndClip(

                            aText,

                            convertedText,

                            *aFont,

                            availableWidth,

                            availableWidth);

        textToDraw.Set(convertedText.Ptr(), convertedText.Length());

    }

    CFont::TMeasureTextInput::TFlags order = CFont::TMeasureTextInput::EFVisualOrder;

    if (AknLayoutUtils::LayoutMirrored())

    {

        order = CFont::TMeasureTextInput::EFVisualOrderRightToLeft;

    }

    TInt textWidth = AknBidiTextUtils::MeasureTextBoundsWidth(*aFont,

                     textToDraw,

                     order);

    TInt alignmentSpace = aTextRect.Width() - textWidth;

    TPoint textLocation(aTextRect.iTl.iX, aTextRect.iTl.iY + baseLineY);

    if (aAlignment == CGraphicsContext::ECenter)

    {

        textLocation.iX += (alignmentSpace / 2);

    }

    else if (aAlignment == CGraphicsContext::ERight)

    {

        textLocation.iX += alignmentSpace;

    }

    TRgb textColor = iLinkColor;

    // Same background highlight as that of Link

    if (iPressed || (iDisplay.UiUtils().NaviKeyInput() && IsFocused()))

    {

        textColor = iHighlightedLinkColor;

        aGc.SetPenStyle(CGraphicsContext::ENullPen);

        aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

        aGc.SetBrushColor(iHighlightColor);

        aGc.DrawRect(TRect(TPoint(textLocation.iX, textLocation.iY - aFont->FontMaxAscent()),

                           TSize(textWidth, aFont->FontLineGap())));

    }

    aGc.UseFont(aFont);

    aGc.SetPenStyle(CGraphicsContext::ESolidPen);

    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

    aGc.SetUnderlineStyle(EUnderlineOn);

    aGc.SetPenColor(textColor);

    aGc.DrawText(textToDraw, textLocation);

    convertedText.Close();

}

void CSwtHyperLink::UpdateSkinColor()

{

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(),

                              iLinkColor,

                              KAknsIIDQsnHighlightColors,

                              EAknsCIQsnHighlightColorsCG3);

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(),

                              iHighlightColor,

                              KAknsIIDQsnHighlightColors,

                              EAknsCIQsnHighlightColorsCG2);

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(),

                              iHighlightedLinkColor,

                              KAknsIIDQsnTextColors,

                              EAknsCIQsnTextColorsCG24);

}

void CSwtHyperLink::UpdateDefaultFontL()

{

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), iDisplay.Device().GetSystemFont()->Font());

}

void CSwtHyperLink::LaunchHandler()

{

    TPtrC scheme;

    scheme.Set(Scheme());

    RBuf textForHandler;

    TInt err = textForHandler.Create(scheme.Length() + iFormattedText.Length());

    if (err != KErrNone)

    {

        ASSERT(EFalse);

        return;

    }

    textForHandler.Append(scheme);

    textForHandler.Append(iFormattedText);

    CSwtBrowserSchemeHandler* handler = NULL;

    TRAP(err, handler = CSwtBrowserSchemeHandler::NewL(textForHandler));

    if (err != KErrNone)

    {

        ASSERT(EFalse);

    }

    else

    {

        TRAP(err, handler->HandleUrlStandaloneL());

        if (err != KErrNone)

        {

            ASSERT(EFalse);

        }

        delete handler;

        handler = NULL;

    }

    textForHandler.Close();

}

TPtrC CSwtHyperLink::Scheme()

{

    TPtrC scheme;

    switch (iFormat)

    {

    case MSwtHyperLink::EPhone:

        scheme.Set(KSwtHyperLinkTel);

        break;

    case MSwtHyperLink::EUrl:

        scheme.Set(KSwtHyperLinkHttp);

        break;

    case MSwtHyperLink::EEmail:

        scheme.Set(KSwtHyperLinkMail);

        break;

    default:

        ASSERT(EFalse);

        break;

    }

    return scheme;

}

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

// From class CCoeControl.

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

//

TKeyResponse CSwtHyperLink::OfferKeyEventL(const TKeyEvent& aKeyEvent,

        TEventCode       aType)

{

    TBool traversalDoIt(ETrue);

    if (aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter)

    {

        traversalDoIt = EFalse;

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// From class CCoeControl.

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

//

void CSwtHyperLink::HandleResourceChange(TInt aType)

{

    CAknControl::HandleResourceChange(aType);

    TRAP_IGNORE(SwtHandleResourceChangeL(aType));

}

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

// From class CCoeControl.

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

//

TTypeUid::Ptr CSwtHyperLink::MopSupplyObject(TTypeUid aId)

{

    return ASwtControlBase::SwtMopSupplyObject(aId);

}

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

// From class CCoeControl.

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

//

void CSwtHyperLink::SizeChanged()

{

    HandleSizeChanged();

}

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

// From class CCoeControl.

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

//

void CSwtHyperLink::PositionChanged()

{

    HandlePositionChanged();

}

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

// From class CCoeControl.

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

//

void CSwtHyperLink::FocusChanged(TDrawNow aDrawNow)

{

    HandleFocusChanged(aDrawNow);

}

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

// From class CCoeControl.

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

//

void CSwtHyperLink::Draw(const TRect& /*aRect*/) const

{

    CGraphicsContext::TTextAlign alignment;

    if (iStyle & KSwtStyleCenter)

    {

        alignment = CGraphicsContext::ECenter;

    }

    else if (iStyle & KSwtStyleTrail)

    {

        if (AknLayoutUtils::LayoutMirrored())

        {

            alignment = CGraphicsContext::ELeft;

        }

        else

        {

            alignment = CGraphicsContext::ERight;

        }

    }

    else // default is left

    {

        if (AknLayoutUtils::LayoutMirrored())

        {

            alignment = CGraphicsContext::ERight;

        }

        else

        {

            alignment = CGraphicsContext::ELeft;

        }

    }

    TRect textRect(Rect());

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

    textRect.iTl.iX += padding.iLeft;

    textRect.iTl.iY += padding.iTop;

    textRect.iBr.iX -= padding.iRight;

    textRect.iBr.iY -= padding.iBottom;

    DrawText(SystemGc(),

             &GetFont()->Font(),

             iFormattedText,

             textRect,

             alignment);

}

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

// From class MSwtControl.

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

//

CCoeControl& CSwtHyperLink::CoeControl()

{

    return *this;

}

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

// From class MSwtControl.

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

//

const CCoeControl& CSwtHyperLink::CoeControl() const

{

    return *this;

}

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

// From class MSwtControl.

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

//

void CSwtHyperLink::ProcessKeyEventL(const TKeyEvent& aKeyEvent,

                                     TEventCode       aType)

{

    if (aType == EEventKey &&

            (aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter))

    {

        LaunchHandler();

    }

}

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

// From class MSwtControl.

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

//

void CSwtHyperLink::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    switch (aPointerEvent.iType)

    {

    case TPointerEvent::EButton1Down:

    {

        iPressed = ETrue;

#ifdef RD_TACTILE_FEEDBACK

        if (iFeedback)

        {

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

            iFeedback->InstantFeedback(ETouchFeedbackSensitiveButton);

#else

            iFeedback->InstantFeedback(ETouchFeedbackBasic);

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

        }

#endif //RD_TACTILE_FEEDBACK

        Redraw();

        break;

    }

    case TPointerEvent::EDrag:

    {

        TBool pressed = iPressed;

        if (Rect().Contains(aPointerEvent.iPosition))

        {

            iPressed = ETrue;

        }

        else

        {

            iPressed = EFalse;

        }

        if (pressed != iPressed)

        {

            Redraw();

        }

        break;

    }

    case TPointerEvent::EButton1Up:

    {

        TBool pressed = iPressed;

        iPressed = EFalse;

        if (!iDisplay.RevertPointerEvent() && Rect().Contains(aPointerEvent.iPosition))

        {

            LaunchHandler();

        }

        if (pressed != iPressed)

        {

            Redraw();

        }

        break;

    }

    default:

        break;

    }

}

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

// From class MSwtControl.

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

//

void CSwtHyperLink::SetForegroundL(const MSwtColor* aColor)

{

    ASwtControlBase::DoSetForegroundL(aColor);

    aColor ? iCustomTextColor = ETrue : iCustomTextColor = EFalse;

    if (iCustomTextColor)

    {

        TRgb rgb;

        TBool overrideColorSet(GetColor(EColorControlText, rgb));

        ASSERT(overrideColorSet);

        iLinkColor = rgb;

    }

    else

    {

        UpdateSkinColor();

    }

    Redraw();

}

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

// From class MSwtControl.

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

//

TSize CSwtHyperLink::ComputeSizeL(TInt aWHint, TInt aHHint)

{

    const MSwtFont* font = GetFont();

    ASSERT(font);

    TSize res(font->TextWidthInPixels(iFormattedText), font->Font().FontMaxHeight());

    if (font == &DefaultFont())

    {

        res.iHeight = Max(iDisplay.UiUtils().InlineReferenceFontHeight(), res.iHeight);

    }