/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Defines a custom editor window for Text editor component.

*

*/

// INTERNAL INCLUDES

#include "CMIDTextEditorEdwin.h"

#include "CMIDEdwinUtils.h"

#include "CMIDTextEditorEdwinCustomDraw.h"

#include "CMIDEditingStateIndicator.h"

#include "CMIDDisplayable.h"

// EXTERNAL INCLUDES

#include <MMIDTextEditor.h> // MMIDTextEditorObserver

#include <aknextendedinputcapabilities.h>

#include <AknSettingCache.h>

#include <eikedwob.h>

#include <j2me/jdebug.h>

#ifdef RD_JAVA_S60_RELEASE_9_2

#include <AknPriv.hrh>

#endif // RD_JAVA_S60_RELEASE_9_2

const TInt KColorOpaque = 255;

const TInt KCharMinus   = 0x2d;

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

// CMIDTextEditorEdwin::CMIDTextEditorEdwin

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

//

CMIDTextEditorEdwin::CMIDTextEditorEdwin(CMIDEdwinUtils& aEdwinUtils)

        : CEikEdwin(),

        iMultiline(EFalse),

        iCursorPosForAction(KErrNotFound),

        iEdwinUtils(aEdwinUtils)

{

    DEBUG("CMIDTextEditorEdwin::CMIDTextEditorEdwin +");

#ifdef RD_JAVA_S60_RELEASE_9_2

    iPartialVKBOpen = EFalse;

    iDisplayable = NULL;

    iJavaAppUi = NULL;

#endif // RD_JAVA_S60_RELEASE_9_2

    // Set margins to zero

    TMargins8 margins;

    margins.SetAllValuesTo(0);

    SetBorderViewMargins(margins);

    // Set layout

    CAknEnv::Static()->GetCurrentLayoutId(iDirection);

    // Set visible content height

    iVisibleContentHeight = 0;

    // Set border to zero

    SetBorder(TGulBorder::ENone);

    SetFocusing(ETrue);

    DEBUG("CMIDTextEditorEdwin::CMIDTextEditorEdwin -");

}

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

// CMIDTextEditorEdwin::~CMIDTextEditorEdwin

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

//

CMIDTextEditorEdwin::~CMIDTextEditorEdwin()

{

    DEBUG("CMIDTextEditorEdwin::~CMIDTextEditorEdwin");

}

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

// CMIDTextEditorEdwin::ConstructL

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::ConstructL(

    TInt aEdwinFlags,

    TInt aWidthInChars,

    TInt aTextLimit,

    TInt aNumberOfLines)

{

    DEBUG("CMIDTextEditorEdwin::ConstructL +");

    CEikEdwin::ConstructL(

        aEdwinFlags, aWidthInChars, aTextLimit, aNumberOfLines);

    // Supress all background drawing of CEikEdwin so that this editor

    // can draw the correct custom color to the background.

    SetSuppressBackgroundDrawing(ETrue);

    // No background control context. This way it is possible to change the

    // background color of the text editor. By default, it is white.

    SetSkinBackgroundControlContextL(NULL);

    // Observer events in the editor. Note that this must be done in order

    // to avoid resulting incorrect content in numeric and decimal editors

    SetEdwinObserver(this);

    // To have the line where cursor is properly displayed.

    if (iLayout)

    {

        iLayout->RestrictScrollToTopsOfLines(EFalse);

    }

    DEBUG("CMIDTextEditorEdwin::ConstructL -");

}

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

// CMIDTextEditorEdwin::OfferKeyEventL

// (other items were commented in the header file)

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

//

TKeyResponse CMIDTextEditorEdwin::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType)

{

    DEBUG_INT("CMIDTextEditorEdwin::OfferKeyEventL +, aType=%d", aType);

    TKeyResponse response = EKeyWasNotConsumed;

    if ((aType == EEventKey) &&

            (aKeyEvent.iCode == EKeyEnter) &&

            (!iMultiline ||

             iConstraints & MMIDTextField::EPassword ||

             !IsConstraintSet(MMIDTextField::EAny)))

    {

        // Enter key for single-line editor, password and other than any

        // editors is simply passed on.

        DEBUG("CMIDTextEditorEdwin::OfferKeyEventL -, ignoring enter");

        return response;

    }

    // Offer key event to editor window if it is set focused and visible.

    // If the editor is set hidden, OfferKeyEventL will update the content

    // in the editor and draw it. So the editor content CANNOT be modified

    // if it is not visible and focused.

    if (IsFocused() && IsVisible())

    {

        DEBUG("CMIDTextEditorEdwin::OfferKeyEventL, focused=true");

        // Edwin does not report cursor movements with text updates

        // Store the current position here for future use.

        iCursorPosForAction = CursorPos();

        // Try handling special characters.

        response = HandleSpecialKeyEventsL(aKeyEvent, aType);

        // Not handled, try with CEikEdwin

        // Consume down and up type of keyevents

        {

            response = EKeyWasConsumed;

        }

        else

        {

            // Old text is needed if the new content is not valid for the

            // given set of constraints. This validation is made because

            // CEikEdwin and FEP seem to input text that is not always

            // valid for the given Java-specific constraints. No very

            // optimized solution to allocate heap here but at least this

            // solution is bulletproof and prevents illegal contents.

            // This also prevents that the implementation does not ignore

            // special characters such as navigation and hotkeys.

            HBufC* oldContent = GetTextInHBufL();

            CleanupStack::PushL(oldContent);

            response = CEikEdwin::OfferKeyEventL(aKeyEvent, aType);

                // Validate new content and undo if not valid.

                if (!iEdwinUtils.ConstraintsValidForText(

                            Read(), iConstraints, EFalse))

                {

                    CEikEdwin::SetTextL(oldContent);

                    // Notify about text change.

                    HandleTextChangedL();

                    // Restore cursor's original position.

                    SetCursorPosL(iCursorPosForAction, EFalse);

                }

            }

            else

                {

                    response = EKeyWasConsumed;

                }

            }

            CleanupStack::PopAndDestroy(oldContent);

        }

        // Update current selection.

        iSelection = Selection();

        // Draw now so that background gets updated. Otherwise the

        // content may not be updated (e.g. cursor may be visible

        // if a line is deleted from the editor.

        // Transparency needs whole redraw of the editor's content.

        if (IsTransparent())

        {

            iParent->DrawNow(Rect());

        }

        else

        {

            DrawDeferred();

        }

    }

    DEBUG("CMIDTextEditorEdwin::OfferKeyEventL -");

    return response;

}

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

// CMIDTextEditorEdwin::Traverse

// (other items were commented in the header file)

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

//

TBool CMIDTextEditorEdwin::Traverse(const TKeyEvent& aEvent)

{

    TInt cursorPos = 0;

    TBool traverse = EFalse;

    if ((aEvent.iCode == EKeyDownArrow) ||

            (aEvent.iScanCode == EStdKeyDownArrow))

    {

        cursorPos = CursorPos();

        if (TextLength() == cursorPos)

        {

            traverse = ETrue;

        }

    }

    else if ((aEvent.iCode == EKeyUpArrow) ||

             (aEvent.iScanCode == EStdKeyUpArrow))

    {

        cursorPos = CursorPos();

        if (cursorPos == 0)

        {

            traverse = ETrue;

        }

    }

    return traverse;

}

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

// CMIDTextEditorEdwin::Draw

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::Draw(const TRect& aRect) const

{

    DEBUG("CMIDTextEditorEdwin::Draw +");

    // Part of transparency workaround. Set drawing active.

    iDrawInvoked = ETrue;

    // Background color is drawn before other content.

    // Note that in order this to work, the background drawing of CEikEdwin

    // needs to be suppressed. Custom drawer cannot be used due to flickering

    // problems. Currently it just handles the selection color.

    CWindowGc& gc = SystemGc();

    // If scaling is on, clip to canvas rect is needed.

    if (iIsScalingOn)

    {

        gc.SetClippingRect(iOnScreenCanvasRect);

    }

    // Draw background with alpha.

    gc.SetBrushColor(iBackgroundColor);

    gc.Clear(aRect);

    // Now draw the content of the editor.

    CEikEdwin::Draw(aRect);

    // cancel of clip

    if (iIsScalingOn)

    {

        gc.CancelClippingRect();

    }

    // Part of transparency workaround. Set drawing not active.

    iDrawInvoked = EFalse;

    DEBUG("CMIDTextEditorEdwin::Draw -");

}

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

// CMIDTextEditorEdwin::DrawOngoing

// Part of transparency workaround. Returns the current draw status

// of this editor window.

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

//

TBool CMIDTextEditorEdwin::DrawOngoing() const

{

    return iDrawInvoked;

}

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

// CMIDTextEditorEdwin::Redraw

// Part of transparency workaround. Returns the current draw status

// of this editor window.

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

//

void CMIDTextEditorEdwin::Redraw() const

{

    // Do not redraw if draw is already ongoing.

    if (iDrawInvoked || !iParent)

    {

        return;

    }

    // If the editor has a transaprent background, the parent

    // needs to be redrawn in that case. Note that DrawNow

    // is not applicable here because this is used from the

    // custom draw which may invoke this method during CTextView

    // redraw causing a panic to occur.

    if (IsTransparent())

    {

        iParent->DrawDeferred();

    }

    else

    {

        // No transparency. Draw this control only.

        DrawDeferred();

    }

}

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

// CMIDTextEditorEdwin::IsTransparent

// (other items were commented in the header file)

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

//

TBool CMIDTextEditorEdwin::IsTransparent() const

{

    return (iBackgroundColor.Alpha() < KColorOpaque);

}

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

// CMIDTextEditorEdwin::FocusChanged

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::FocusChanged(TDrawNow aDrawNow)

{

    DEBUG("CMIDTextEditorEdwin::FocusChanged +");

    CEikEdwin::FocusChanged(aDrawNow);

    // Apply initial input mode change when the editor has been focused.

    // Note that initial input mode change must be applied only when

    // an editing session starts (according to MIDP specification).

    // See CMIDEdwin::HandleCurrentL()

    if (IsFocused() &&

            (IsConstraintSet(MMIDTextField::EAny) ||

             IsConstraintSet(MMIDTextField::EMailAddr) ||

             IsConstraintSet(MMIDTextField::EUrl)))

    {

        // Set current language.

        if (iInitialCurrentLanguage)

        {

            DEBUG("CMIDTextEditorEdwin::FocusChanged, \

applying current language");

            SetAknEditorLocalLanguage(iInitialCurrentLanguage);

            if (iInitialCurrentInputMode == 0)

            {

                DEBUG("CMIDTextEditorEdwin::FocusChanged, null input mode");

                // Clears any number mode used previously

                SetAknEditorCurrentInputMode(EAknEditorNullInputMode);

            }

        }

        // Set current input mode.

        if (iInitialCurrentInputMode)

        {

            DEBUG("CMIDTextEditorEdwin::FocusChanged, \

applying current input mode");

            SetAknEditorCurrentInputMode(iInitialCurrentInputMode);

        }

        // Set current case.

        if (iInitialCurrentCase)

        {

            DEBUG("CMIDTextEditorEdwin::FocusChanged, \

applying current case");

            TInt initialCurrentCase = iInitialCurrentCase;

            if ((iConstraints & MMIDTextField::EPassword ||

                    IsConstraintSet(MMIDTextField::EMailAddr) ||

                    IsConstraintSet(MMIDTextField::EUrl)) &&

                    iInitialCurrentCase == EAknEditorTextCase)

            {

                // Text case is not used in passwords, emailaddrs and urls

                initialCurrentCase = EAknEditorLowerCase;

            }

            SetAknEditorCurrentCase(initialCurrentCase);

            SetAknEditorCase(initialCurrentCase);

        }

    }

    DEBUG("CMIDTextEditorEdwin::FocusChanged -");

}

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

// CMIDTextEditorEdwin::PositionChanged

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::PositionChanged()

{

    DEBUG("CMIDTextEditorEdwin::PositionChanged +");

    CCoeControl::PositionChanged();

    // Text view may have not been created yet.

    if (iTextView)

    {

        // Adjust the view rect to the text view

        iTextView->SetViewRect(Rect());

    }

    DEBUG("CMIDTextEditorEdwin::PositionChanged -");

}

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

// CMIDTextEditorEdwin::PositionChanged

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::OverrideColorL(TInt aLogicalColor, TRgb aColor)

{

    CCoeControl::OverrideColorL(aLogicalColor, aColor);

    if (aLogicalColor == EColorControlBackground)

    {

        iBackgroundColor = aColor;

    }

    // Suppress background drawing if the editor is transparent.

    SetSuppressBackgroundDrawing(IsTransparent());

}

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

// CMIDTextEditorEdwin::CreateCustomDrawL

// (other items were commented in the header file)

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

//

CLafEdwinCustomDrawBase* CMIDTextEditorEdwin::CreateCustomDrawL()

{

    DEBUG("CMIDTextEditorEdwin::CreateCustomDrawL +");

    // First create the parent custom draw that handles the drawing of

    // text and other related components.

    const MFormCustomDraw* customDraw = CEikEdwin::CreateCustomDrawL();

    // Create text editor specific custom draw that handles the

    // setting of selection color.

    CLafEdwinCustomDrawBase* ret = new(ELeave)CMIDTextEditorEdwinCustomDraw(

        iEikonEnv->LafEnv(), *customDraw, *this);

    DEBUG("CMIDTextEditorEdwin::CreateCustomDrawL -");

    return ret;

}

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

// CMIDTextEditorEdwin::HandleTextPastedL

// (other items were commented in the header file)

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

//

void CMIDTextEditorEdwin::HandleTextPastedL(TInt aStartPos, TInt& aLength)

{

    DEBUG_INT2(

        "CMIDTextEditorEdwin::HandleTextPastedL +, aStartPos=%d, aLength=%d",

        aStartPos, aLength);

    HBufC* content = GetTextInHBufL(); // May return NULL

    if (!content)

    {

        // For guaranteeing that this method does not crash in any case.

        return;

    }

    CleanupStack::PushL(content);

    // Check that the pasted text is valid for the given set of constraints.

    if (!iEdwinUtils.ConstraintsValidForText(

                content->Des(), iConstraints, ETrue))

    {

        DEBUG("CMIDTextEditorEdwin::HandleTextPastedL, \

constraints not valid");

        // Remove pasted content from the text and set it back.

        iText->DeleteL(aStartPos, aLength);

        // Notify about the change.

        HandleTextChangedL();

    }

    // Convert breaks if needed if constraints that do not allow line breaks.

    // Note that numeric, decimal and phonenumber do not allow line breaks

    // and are checked before this so no need to check here again.