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

 * 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 <eikedwin.h>

#include <txtglobl.h>

#include <AknsUtils.h>

#include <swtlaffacade.h>

#include <AknUtils.h>

#include <AknDef.h>

#ifdef RD_JAVA_S60_RELEASE_9_2

#include <AknPriv.hrh>

#endif

#include <aknappui.h>

#include <akntouchpane.h>

#include "swtscrollbar.h"

#include "swtfont.h"

#include "swttextbase.h"

#include "swtcaptionedcontrol.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefconst.h>

#endif

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

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

// CSwtTextBase::CSwtTextBase

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

//

CSwtTextBase::CSwtTextBase(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

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

{

}

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

// CSwtTextBase::~CSwtTextBase

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

//

CSwtTextBase::~CSwtTextBase()

{

    // Own

    delete iEditor;

    iEditor = NULL;

    delete iIndicator;

    iIndicator = NULL;

    // Not own.

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    if (iCharFormatLayer)

    {

        delete iCharFormatLayer;

        iCharFormatLayer = NULL;

    }

}

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

// CSwtTextBase::ConstructL

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

//

void CSwtTextBase::ConstructL()

{

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

    SetContainerWindowL(coeParent);

    CSwtEditIndicatorRedictor* redirector = MopGetObject(redirector);

    if (redirector)

    {

        iIndicator = CSwtEditIndicator::NewL(CoeControl());

    }

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

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

    SetComponentsToInheritVisibility(ETrue);

    // Although the background is drawn already natively, this fixes

    // problems with srollbar back when custom back color set.

    SetBackground(this);

}

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

// CSwtTextBase::SetEditor

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

//

void CSwtTextBase::SetEditor(CEikEdwin* aEditor)

{

    ASSERT(!iEditor);

    iEditor = aEditor;

}

#if defined( RD_SCALABLE_UI_V2)

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

// CSwtTextBase::InputCapabilities

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

//

TCoeInputCapabilities CSwtTextBase::InputCapabilities() const

{

    // Override CCoeControl behaviour to provide MCoeCaptionRetrieverForFep.

    const TCoeInputCapabilities& capabilities = CAknControl::InputCapabilities();

    return TCoeInputCapabilities(capabilities.Capabilities(),

                                 capabilities.FepAwareTextEditor(),

                                 (MCoeCaptionRetrieverForFep*)this);

}

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

// CSwtTextBase::GetCaptionForFep

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

//

void CSwtTextBase::GetCaptionForFep(TDes& aCaption) const

{

    // If we are inside a CaptionedControl, return the CaptionedControl text.

    // It will be shown in thumb keypad

    MSwtCaptionedControl* captionedControl = iParent->Control()->CaptionedControlInterface();

    if (captionedControl)

    {

        const TDesC* text = captionedControl->GetText();

        if (!text)

        {

            aCaption = KNullDesC;

        }

        else

        {

            const TInt maximumLength = aCaption.MaxLength();

            if (text->Length() > maximumLength)

            {

                aCaption = text->Left(maximumLength);

            }

            else

            {

                aCaption = *text;

            }

        }

    }

    else

    {

        aCaption=KNullDesC;

    }

}

void CSwtTextBase::MCoeCaptionRetrieverForFep_Reserved_1()

{}

void CSwtTextBase::MCoeCaptionRetrieverForFep_Reserved_2()

{}

#endif //RD_SCALABLE_UI_V2

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

// CSwtTextBase::RetrieveDefaultFontL

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

//

void CSwtTextBase::RetrieveDefaultFontL()

{

    ASSERT(iEditor);

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    // Not same but similar to DateEditor's font. Height most probably be same.

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), *AknLayoutUtils::FontFromId(

                                      CSwtLafFacade::GetFontId(CSwtLafFacade::EFont2MidpTextPaneT1Font, 0, 0), NULL));

    if (!iFont)

    {

        // to avoid the default font of CEikEdwin

        ProcessFontUpdateL();

    }

}

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

// CSwtTextBase::ProcessFontUpdate

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

//

void CSwtTextBase::ProcessFontUpdateL()

{

    TCharFormat charFormat;

    TCharFormatMask charMask;

    charFormat.iFontSpec = GetFont()->Font().FontSpecInTwips();

    charMask.SetAttrib(EAttFontTypeface);

    charMask.SetAttrib(EAttFontHeight);

    if (charFormat.iFontSpec.iFontStyle.StrokeWeight() == EStrokeWeightBold)

    {

        charMask.SetAttrib(EAttFontStrokeWeight);

    }

    if (charFormat.iFontSpec.iFontStyle.Posture() == EPostureItalic)

    {

        charMask.SetAttrib(EAttFontPosture);

    }

    TRgb color(0);

    TInt err(KErrNone);

    if (HasHighlight())

    {

        err = AknsUtils::GetCachedColor(AknsUtils::SkinInstance()

                                        , color

                                        , KAknsIIDQsnTextColors

                                        , KHighlightedTextColor);

        if (err == KErrNone)

        {

            charFormat.iFontPresentation.iTextColor = color;

            charMask.SetAttrib(EAttColor);

        }

    }

    else if (iTextColor)

    {

        charFormat.iFontPresentation.iTextColor = GetForeground();

        charMask.SetAttrib(EAttColor);

    }

    else

    {

        err = AknsUtils::GetCachedColor(AknsUtils::SkinInstance()

                                        , color

                                        , KAknsIIDQsnTextColors

                                        , KNonHighlightedTextColor);

        if (err == KErrNone)

        {

            charFormat.iFontPresentation.iTextColor = color;

            charMask.SetAttrib(EAttColor);

        }

    }

    if (iStyle & KSwtStyleSingle)

    {

        CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL(charFormat, charMask);

        // we are using CGlobalText for Single line. So SetGlobalCharFormat for Global text

        static_cast<CGlobalText*>(iEditor->Text())->SetGlobalCharFormat(charFormatLayer);

        if (iCharFormatLayer)

        {

            delete iCharFormatLayer;

        }

        iCharFormatLayer = charFormatLayer;

    }

    else

    {

        CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL(charFormat, charMask);

        // SetCharFormatLayer is for EText and RichText

        iEditor->SetCharFormatLayer(charFormatLayer);

    }

}

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

// CSwtTextBase::SetBackgroundL

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

//

void CSwtTextBase::SetBackgroundL(const MSwtColor* aColor)

{

    ASwtControlBase::DoSetBackgroundL(aColor);

    TRgb color(aColor ? aColor->RgbValue() :

               iDisplay.CoeEnv()->Color(EColorControlBackground));

    if (iEditor)

    {

        // Outside text view

        iEditor->SetBackgroundColorL(color);

        // Inside text view, outside paragraphs

        iEditor->TextView()->SetBackgroundColor(color);

        // Inside paragraphs

        CParaFormat* paraFormat = new(ELeave) CParaFormat();

        CleanupStack::PushL(paraFormat);

        paraFormat->iFillColor = color;

        TParaFormatMask paraMask;

        paraMask.SetAttrib(EAttFillColor);

        static_cast<CGlobalText*>(iEditor->Text())->ApplyParaFormatL(

            paraFormat, paraMask, 0, iEditor->TextLength());

        CleanupStack::PopAndDestroy(paraFormat);

    }

    Redraw();

}

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

// CSwtTextBase::SetForegroundL

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

//

void CSwtTextBase::SetForegroundL(const MSwtColor* aColor)

{

    ASwtControlBase::DoSetForegroundL(aColor);

    iTextColor = ETrue;

    if (!aColor)

    {

        iTextColor = EFalse;

    }

    else if (iEditor)

    {

        TCharFormat charFormat;

        TCharFormatMask charMask;

        charFormat.iFontPresentation.iTextColor = aColor->RgbValue();

        charMask.SetAttrib(EAttColor);

        static_cast<CGlobalText*>(iEditor->Text())->

        ApplyCharFormatL(charFormat, charMask, 0, iEditor->TextLength());

    }

    UpdateTextColor();

    Redraw();

}

void CSwtTextBase::SetBounds(const TRect& aRect)

{

    // Divert the job to UiUtils if this is an editor open for split view editing.

    MSwtUiUtils& utils = iDisplay.UiUtils();

    if (utils.SplitInputView() == this)

    {

        utils.SetSplitInputViewSize(aRect.Size());

        SetLocation(aRect.iTl);

    }

    else

    {

        ASwtScrollableBase::SetBounds(aRect);

    }

}

void CSwtTextBase::SetWidgetSize(const TSize& aSize)

{

    // Divert the job to UiUtils if this is an editor open for split view editing.

    MSwtUiUtils& utils = iDisplay.UiUtils();

    if (utils.SplitInputView() == this)

    {

        utils.SetSplitInputViewSize(aSize);

    }

    else

    {

        ASwtScrollableBase::SetWidgetSize(aSize);

    }

}

TSwtPeer CSwtTextBase::Dispose()

{

    // Close VKB.

    if (iEditor->IsFocused())

    {

        CCoeFep* fep = iDisplay.CoeEnv()->Fep();

        if (fep)

        {

            fep->HandleDestructionOfFocusedItem();

        }

    }

    return ASwtScrollableBase::Dispose();

}

TInt CSwtTextBase::PressBackgroundPolicy() const

{

    return EPressBackground;

}

void CSwtTextBase::UpdateTextColor()

{

    if (iEditor)

    {

        TCharFormat charFormat;

        TCharFormatMask charMask;

        TRgb color(0);

        TInt err(KErrNone);

        if (HasHighlight())

        {

            // Highlighted foreground color, overrides all others.

            err = AknsUtils::GetCachedColor(AknsUtils::SkinInstance()

                                            , color

                                            , KAknsIIDQsnTextColors

                                            , KHighlightedTextColor);

            if (err == KErrNone)

            {

                charFormat.iFontPresentation.iTextColor = color;

            }

        }

        else if (iTextColor)

        {

            // Custom foreground color, overrides the default.

            charFormat.iFontPresentation.iTextColor = GetForeground();

        }

        else

        {

            // Default foreground color.

            err = AknsUtils::GetCachedColor(AknsUtils::SkinInstance()

                                            , color

                                            , KAknsIIDQsnTextColors

                                            , KNonHighlightedTextColor);

            if (err == KErrNone)

            {

                charFormat.iFontPresentation.iTextColor = color;

            }

        }

        charMask.SetAttrib(EAttColor);

        TRAP_IGNORE(static_cast<CGlobalText*>(iEditor->Text())->

                    ApplyCharFormatL(charFormat, charMask, 0, iEditor->TextLength()));

    }

}

void CSwtTextBase::HandleHighlightChange()

{

    UpdateTextColor();

}

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

// CSwtTextBase::ComputeDelta

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

//

TSize CSwtTextBase::ComputeDelta() const

{

    ASSERT(iEditor);

    // Retrieve the various margins & borders

    TInt labels = 0;

    TInt cursor = 0;

    iEditor->TextView()->MarginWidths(labels, cursor);

    const TSize borderDelta(iEditor->Border().SizeDelta());

    const TSize marginDelta(iEditor->Margins().SizeDelta());

    const TSize ownBorderDelta(BorderSizeDelta());

    // The scrollbars

    const TSize sbDelta(SbOuterRect(TRect()).Size());

    // Add them all up

    // Note that marginDelta.iWidth is counted twice because CEikEdwin also

    // counts it twice ( in LayoutWidth(), margins are substracted from

    // ViewRect().Width() whereas this is already done when computing

    // ViewRect().Width() ). So this is a workaround to avoid unwanted

    // wrapping because of this defect in CEikEdwin.

    TSize totalDelta(ownBorderDelta.iWidth + borderDelta.iWidth

                     + 2 * marginDelta.iWidth  + sbDelta.iWidth

                     + labels + cursor + KEikDefaultCursorWidth,

                     ownBorderDelta.iHeight + borderDelta.iHeight

                     + marginDelta.iHeight + sbDelta.iHeight);

    if (iIndicator)

    {

        totalDelta.iHeight += KSWTEditIndicatorHeight;

    }

    return totalDelta;

}

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

// CSwtTextBase::HotKeyL

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

//

TInt CSwtTextBase::HotKeyL(const TKeyEvent& aKeyEvent) const

{

    ASSERT(iEditor);

    if (!(aKeyEvent.iModifiers & EModifierCtrl)

            || (aKeyEvent.iCode >= 100)

            || (aKeyEvent.iCode == ' '))

    {

        return -1;

    }

    HBufC* hkBuf;

    if (aKeyEvent.iModifiers & EModifierShift)

    {

        hkBuf = iCoeEnv->AllocReadResourceL(R_EIK_EDWIN_SHIFT_CTRL_HOTKEYS);

    }

    else

    {

        hkBuf = iCoeEnv->AllocReadResourceL(R_EIK_EDWIN_CTRL_HOTKEYS);

    }

    TInt hotkey = hkBuf->Locate(TChar(aKeyEvent.iCode + 'a' - 1));

    delete hkBuf;

    return hotkey;

}

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

// CSwtTextBase::SetEditable

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

//

void CSwtTextBase::SetEditable(TBool aEditable)

{

    // Update the style accordingly

    if (aEditable)

    {

        iStyle &= ~KSwtStyleReadOnly;

    }

    else

    {

        iStyle |= KSwtStyleReadOnly;

    }

    iEditor->SetReadOnly(!aEditable);

    iEditor->SetFocus(IsFocused());

}

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

// CSwtTextBase::SetTextL

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

//

TBool CSwtTextBase::SetTextL(const TDesC& aText)

{

    // This must be called before querying the length or selection as it can

    // remove the char that is just being typed.

    iEditor->CancelFepTransaction();

    // Get the remaining editing space available in editor if text limit set,

    // and return if no available space.

    TInt editorTextLen = iEditor->TextLength();

    TInt availableLen = KErrNotFound;

    if (iTextLimit)

    {

        ASSERT(editorTextLen <= iTextLimit);