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

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

#include <eikfpne.h>

#include <eswtcore.rsg>

#include <avkon.hrh>

#include "swtcontrolhelper.h"

#include "swtconstrainedtext.h"

#include "swtedwin.h"

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

// CSwtConstrainedText::CSwtConstrainedText

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

//

inline CSwtConstrainedText::CSwtConstrainedText(MSwtDisplay& aDisplay,

        TSwtPeer aPeer,

        MSwtComposite& aParent,

        TInt aStyle)

        : CSwtTextBase(aDisplay, aPeer, aParent, aStyle)

        , iTextLimit(MSwtText::ETextLimit)

{

    // Set decimal separator according to the current locale.

    // Note: decimal separators other than ',' and '.' are currently not supported

    TLocale loc;

    iDecimalSeparator = loc.DecimalSeparator();

    if (iDecimalSeparator != ',')

    {

        iDecimalSeparator = '.';

    }

}

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

// CSwtConstrainedText::~CSwtConstrainedText

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

//

CSwtConstrainedText::~CSwtConstrainedText()

{

}

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

// CSwtConstrainedText::NewL

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

//

CSwtConstrainedText* CSwtConstrainedText::NewL(MSwtDisplay& aDisplay,

        TSwtPeer aPeer,

        MSwtComposite& aParent,

        TInt aStyle)

{

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

            aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtConstrainedText::Draw

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

//

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

{

    if (GetShell().UrgentPaintControl() == this)

        return;

    CEikEdwin& editor(Editor());

    if (editor.TextView() == NULL)

    {

        return;

    }

    // Update editor's visibility, otherwise text will be drawn

    // when performing clipboard operations on invisible control.

    const TBool visible = GetVisibleRecursively();

    if (visible != editor.IsVisible())

    {

        editor.MakeVisible(visible);

    }

    // Update custom clipping, otherwise edwin will draw outside of

    // its parent control.

    TRect clipRect(ClipToVisibleRect(editor.TextView()->ViewRect()));

    if (clipRect != iLastViewVisibleRect)

    {

        switch (iConstraint)

        {

        case ENumeric:

            ((CSwtIntegerEdwin*)&editor)->SetClippingRect(clipRect);

            break;

        case EDecimal:

            ((CSwtFloatingPointEdwin*)&editor)->SetClippingRect(clipRect);

            break;

        case EPhoneNumber:

            ((CSwtEdwin*)&editor)->SetClippingRect(clipRect);

            break;

        default:

            ASSERT(EFalse);

            break;

        }

        iLastViewVisibleRect = clipRect;

    }

}

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

//  Checks the content will remain valid if the specified text replaces

//       the given range.

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

//

inline TInt CSwtConstrainedText::LooseCheckReplacementL(TInt aStart,

        TInt aEnd,

        const TDesC& aText) const

{

    return CheckReplacementL(aStart, aEnd, aText, EFalse);

}

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

//   Checks the content will remain valid if the specified character replaces

//         the given range.

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

TInt CSwtConstrainedText::LooseCheckReplacementL(TInt aStart,

        TInt aEnd,

        TInt aChar) const

{

    TBuf<1> buf;

    buf.Append(aChar);

    return LooseCheckReplacementL(aStart, aEnd, buf);

}

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

//   Checks the content will remain valid if the specified text replaces

//         the current selection.

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

inline TInt CSwtConstrainedText::StrictCheckReplacementL(const TDesC& aText) const

{

    const TCursorSelection sel(Editor().Selection());

    return CheckReplacementL(sel.LowerPos(), sel.HigherPos(), aText, ETrue);

}

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

//  Checks the content will remain valid if the specified text replaces

//         the given range.

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

TInt CSwtConstrainedText::CheckReplacementL(TInt aStart,

        TInt aEnd,

        const TDesC& aText,

        TBool aStrict) const

{

    ASSERT(aStart <= aEnd);

    const TInt selLength = aEnd - aStart;

    const TInt bufLength = Editor().TextLength() + Max(0, aText.Length() - selLength);

    HBufC* buf = HBufC::NewLC(bufLength);

    TPtr ptr(buf->Des());

    Editor().GetText(ptr);

    ptr.Delete(aStart, selLength);

    ptr.Insert(aStart, aText);

    TInt result = (aStrict) ? StrictValidateText(*buf) : LooseValidateText(*buf);

    CleanupStack::PopAndDestroy(buf);

    return result;

}

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

// CSwtConstrainedText::LooseValidateText

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

//

TInt CSwtConstrainedText::LooseValidateText(const TDesC& aText) const

{

    switch (iConstraint)

    {

    case ENumeric:

        return LooseValidateNumeric(aText);

    case EDecimal:

        return LooseValidateDecimal(aText);

    case EPhoneNumber:

        return ValidatePhoneNumber(aText);

    default:

        ASSERT(EFalse);

        return KErrNone;

    }

}

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

// CSwtConstrainedText::StrictValidateText

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

//

TInt CSwtConstrainedText::StrictValidateText(const TDesC& aText) const

{

    switch (iConstraint)

    {

    case ENumeric:

        return StrictValidateNumeric(aText);

    case EDecimal:

        return StrictValidateDecimal(aText);

    case EPhoneNumber:

        return ValidatePhoneNumber(aText);

    default:

        ASSERT(EFalse);

        return KErrNone;

    }

}

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

//  Checks whether a given text is an acceptable NUMERIC. It must be

//  made of digits only and an optional leading minus sign. If the

//  maximum text size is 1, then no minus sign is allowed.

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

//

TInt CSwtConstrainedText::LooseValidateNumeric(const TDesC& aText) const

{

    const TText* ptr = aText.Ptr();

    // Likely text will be appended, so we perform checking backwards for faster execution

    for (TInt pos=aText.Length(); pos>0;)

    {

        TChar ch(ptr[--pos]);

        if (!ch.IsDigit() && !(ch == '-' && (pos == 0 && iTextLimit != 1)))

        {

            return KErrArgument;

        }

    }

    return KErrNone;

}

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

//  Strict version of the NUMERIC check. Same as the loose one except a "-" is

//  no longer accepted.

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

//

TInt CSwtConstrainedText::StrictValidateNumeric(const TDesC& aText) const

{

    _LIT(KMinus, "-");

    if (aText.Compare(KMinus) == 0)

    {

        return KErrArgument;

    }

    return LooseValidateNumeric(aText);

}

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

//  Checks whether a text is an acceptable DECIMAL. It consists of an

//  optional minus sign '-', followed by one or more whole-number

//  decimal digits, followed by an optional fraction separator,

//  followed by zero or more decimal fraction digits. The whole-number

//  decimal digits may be omitted if the fraction separator and one or

//  more decimal fraction digits are present.

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

//

TInt CSwtConstrainedText::LooseValidateDecimal(const TDesC& aText) const

{

    TInt len = aText.Length();

    TInt pos = 0;

    const TText* ptr = aText.Ptr();

    if (len == 0)

    {

        return KErrNone;

    }

    // '-' is allowed only in the begining of the text and limit>1

    if (ptr[0] == '-')

    {

        pos = 1;

        //'.' is not allowed when first character is '-' and limit is 2

        if ((pos<len && (TChar(ptr[pos]) == iDecimalSeparator) && iTextLimit == 2))

        {

            return KErrArgument;

        }

    }

    for (TInt pos1=aText.Length(); pos1>0;)

    {

        TChar ch(ptr[--pos1]);

        //'-', '.' is not allowed when limit is 1

        if (((ch == '-' || ch == iDecimalSeparator) && (pos1 == 0 && iTextLimit == 1)))

        {

            return KErrArgument;

        }

    }

    // allows all digits, and allow only one '.'

    TBool valid = ETrue;

    while (pos<len && (TChar(ptr[pos]).IsDigit() ||

                       (TChar(ptr[pos]) == iDecimalSeparator && valid)))

    {

        if (TChar(ptr[pos]) == iDecimalSeparator)

        {

            valid = EFalse;

        }

        ++pos;

    }

    return (pos == len) ? KErrNone : KErrArgument;

}

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

//  Strict version of the DECIMAL check. Same as the loose one except "-", "."

//  and "-." are no longer accepted.

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

//

TInt CSwtConstrainedText::StrictValidateDecimal(const TDesC& aText) const

{

    _LIT(KMinus, "-");

    TBuf<1> point;

    point.Append(iDecimalSeparator);

    TBuf<2> minusPoint;

    minusPoint.Append(KMinus);

    minusPoint.Append(iDecimalSeparator);

    if (aText.Compare(KMinus) == 0 || aText.Compare(point) == 0 ||

            aText.Compare(minusPoint) == 0)

    {

        return KErrArgument;

    }

    return LooseValidateDecimal(aText);

}

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

//  Checks if a character is acceptable in a phone number

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

//

TBool CSwtConstrainedText::IsPhoneNumberChar(const TChar &aChar,

        const TDesC& aAllowedChars)

{

    // Well, digits and space: of course

    if (aChar.IsDigit() || aChar==' ')

    {

        return ETrue;

    }

    // Is it one of the other allowed chars

    TInt len = aAllowedChars.Length();

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

    {

        if (aChar == TChar(aAllowedChars[i]))

        {

            return ETrue;

        }

    }

    // Not a phone number character

    return EFalse;

}

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

//  Checks if a text is a correct PHONENUMBER. Checks it contains only

//  allowed characters, no syntax checking.

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

//

TInt CSwtConstrainedText::ValidatePhoneNumber(const TDesC& aText)

{

    _LIT(KDefaultSpecialChars, "*#+ABCD,T!@;IiGg>()wpWP");

    // Load the list of allowed chars from resource

    const TDesC* allowed = &KDefaultSpecialChars;

    // Likely text will be appended, so we perform checking backwards for faster execution

    const TText* ptr = aText.Ptr();

    for (TInt i=aText.Length(); i>0;)

    {

        if (!IsPhoneNumberChar(ptr[--i], *allowed))

        {

            return KErrArgument;

        }

    }

    return KErrNone;

}

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

// Converts decimal point, if any, to a localized decimal separator.

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

//

HBufC* CSwtConstrainedText::ConvertToLocalizedDecimalLC(const TDesC& aText)

{

    HBufC* buf = aText.AllocLC();

    TPtr text = buf->Des();

    TInt pos = buf->Length();

    for (; pos>0;)

    {

        TText& ch = text[--pos];

        if (ch == '.')

            ch = (TText)iDecimalSeparator;

    }

    return buf;

}

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

// Converts localized decimal separator, if any, to a decimal point.

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

//

void CSwtConstrainedText::ConvertFromLocalizedDecimal(HBufC* buf) const

{

    TPtr text = buf->Des();

    TInt pos = buf->Length();

    for (; pos>0;)

    {

        TText& ch = text[--pos];

        if (ch == (TText)iDecimalSeparator)

            ch = '.';

    }

}

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

//    CSwtConstrainedText::IsNavigationKey

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

//

TBool CSwtConstrainedText::IsNavigationKey(const TKeyEvent& aKeyEvent) const

{

    switch (aKeyEvent.iScanCode)

    {

    case EStdKeyDownArrow:

    case EStdKeyUpArrow:

    case EStdKeyLeftArrow:

    case EStdKeyRightArrow:

    case EStdKeyEscape:

    case EStdKeyPageUp:

    case EStdKeyPageDown:

    case EStdKeyHome:

    case EStdKeyEnd:

        return ETrue;

    default:

        return EFalse;

    }

}

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

//    CSwtConstrainedText::IsHotKeyL

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

//

TBool CSwtConstrainedText::IsHotKeyL(const TKeyEvent& aKeyEvent) const

{

    switch (HotKeyL(aKeyEvent))

    {

    case CEikEdwin::EHotKeyCut:

    case CEikEdwin::EHotKeyCopy:

    case CEikEdwin::EHotKeyPaste:

    case CEikEdwin::EHotKeyUndo:

    case CEikEdwin::EHotKeyFind:

    case CEikEdwin::EHotKeyInsertChar:

        return ETrue;

    default:

        return EFalse;

    }

}

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

// Virtual methods from CCoeControl

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

//

TKeyResponse CSwtConstrainedText::OfferKeyEventL(const TKeyEvent& aKeyEvent,

        TEventCode aType)

{

    TBool traversalDoIt = ETrue;

    // Set the traversal do-it default to false for the following cases:

    // Escape

    if (aKeyEvent.iCode == EKeyEscape)

    {

        traversalDoIt = EFalse;

    }

    // Left and Right arrows : do not allow traversal

    else if (aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyRightArrow)

    {

        traversalDoIt = EFalse;

    }

    return CSwtTextBase::HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// Virtual methods from MSwtControl

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

//

void CSwtConstrainedText::ProcessKeyEventL(const TKeyEvent& aKeyEvent,

        TEventCode aType)

{

    if (aType != EEventKey)

    {

        return;

    }

    // Read-only: CEikEdwin displays a message and leaves. We want the message

    // but not the leaving, hence the trap.

    if (iStyle & KSwtStyleReadOnly)

    {

        TRAP_IGNORE(ForwardKeyEventL(aKeyEvent, aType));

        return;

    }

    // We're single-line: enter not consumed, translated to default selection event

    if (aKeyEvent.iCode == EKeyEnter)

    {

        iDisplay.PostDefaultSelectionEventL(iPeer);

        return;

    }

    const TInt modifiers = aKeyEvent.iModifiers & ECtrlFuncShiftMask;

    const TCursorSelection selection(Editor().Selection());

    const TInt selStart  = selection.LowerPos();

    const TInt selEnd    = selection.HigherPos();