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

 * 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 <EIKCOCTL.rsg>

#include <AknsUtils.h>

#include <swtlaffacade.h>

#include <AknUtils.h>

#include <AknDef.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);

    }

    // when we set the new font color also changes. So we have to set the color again.

    if (!iTextColor)

    {

        TRgb color;

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

                                  KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6);

        charFormat.iFontPresentation.iTextColor = color;

        charMask.SetAttrib(EAttColor);

    }

    else

    {

        charFormat.iFontPresentation.iTextColor = GetForeground();

        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);

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

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

    if (iEditor)

    {

        TCharFormat charFormat;

        TCharFormatMask charMask;

        charFormat.iFontPresentation.iTextColor=color;

        charMask.SetAttrib(EAttColor);

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

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

        iTextColor = ETrue;

    }

    Redraw();

}

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

// 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);

        availableLen = iTextLimit;

        if (availableLen <= 0)

        {

            return EFalse;

        }

    }

    // Clear selection if any

    iEditor->ClearSelectionL();

    // If a text limit is set, append as much as the available space permits,

    // otherwise append the entire text.

    TInt textToInsertLen = aText.Length();

    if (availableLen != KErrNotFound

            && textToInsertLen > availableLen)

    {

        TPtrC des = aText.Left(availableLen);

        iEditor->SetTextL(&des);

    }

    else

    {

        iEditor->SetTextL(&aText);

    }

    iEditor->HandleTextChangedL();

    // Restore carret

    iEditor->SetSelectionL(0, 0);

    /* Workaround for junit tests. Copy and paste functions crash, when

     * Text is not visible. There is some optimalization in CEikEdwin,

     * that updates selection (and cursos position) after Text is drawn.

     */

    iEditor->TextView()->SetSelectionL(TCursorSelection(0, 0));

    return ETrue;

}

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

// CSwtTextBase::AppendL

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

//

TBool CSwtTextBase::AppendL(const TDesC& aText)

{

    ASSERT(iEditor);

    // 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 textToInsertLen = aText.Length();

    TInt editorTextLen = iEditor->TextLength();

    TInt availableLen = KErrNotFound;

    if (iTextLimit)

    {

        ASSERT(editorTextLen <= iTextLimit);

        availableLen = iTextLimit - editorTextLen;

        if (availableLen <= 0)

        {

            return EFalse;

        }

    }

    // Clear selection if any

    iEditor->ClearSelectionL();

    // If a text limit is set, append as much as the available space permits,

    // otherwise append the entire text.

    CPlainText* plainText = iEditor->Text();

    if (availableLen != KErrNotFound

            && textToInsertLen > availableLen)

    {

        plainText->InsertL(editorTextLen, aText.Left(availableLen));

    }

    else

    {

        plainText->InsertL(editorTextLen, aText);

    }

    iEditor->HandleTextChangedL();

    // Restore carret

    editorTextLen = iEditor->TextLength();

    iEditor->SetSelectionL(editorTextLen, editorTextLen);

    return ETrue;

}

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

// CSwtTextBase::InsertL

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

//

TBool CSwtTextBase::InsertL(const TDesC& aText)

{

    ASSERT(iEditor);

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

    // remove the char that is just being typed.

    iEditor->CancelFepTransaction();

    const TCursorSelection selection(iEditor->Selection());

    const TInt selStart = selection.LowerPos();

    TInt textToInsertLen = aText.Length();

    // Return if there is nothing to delete

    if (textToInsertLen == 0 && selection.Length() == 0)

    {

        return EFalse;

    }

    iEditor->ClearSelectionL();

    // Update selection to be sure selection is valid after text removal

    iEditor->SetSelectionL(selStart, selStart);

    iEditor->TextView()->SetSelectionL(TCursorSelection(selStart, selStart));

    // Remove selected text

    CPlainText* plainText = iEditor->Text();

    plainText->DeleteL(selStart, selection.Length());

    // 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)