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

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

#include <AknLayoutFont.h>

#include <AknsControlContext.h>

#include <AknsDrawUtils.h>

#include <avkon.rsg>

#include <AknUtils.h>

#include <AknDef.h>

#ifdef RD_JAVA_S60_RELEASE_9_2

#include <AknPriv.hrh>

#endif

#include <swtlaffacade.h>

#if defined( RD_SCALABLE_UI_V2 )

#include <swtbuttonproxy.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include <fepbase.h>

#endif // RD_SCALABLE_UI_V2

#include "swteditindicator.h"

#include "swtfont.h"

#include "swtdateeditor.h"

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

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

// CSwtDateEditor::NewL

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

//

CSwtDateEditor* CSwtDateEditor::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                                     MSwtComposite& aParent, TInt aStyle)

{

    CSwtDateEditor* self = new(ELeave) CSwtDateEditor(aDisplay, aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtDateEditor::CSwtDateEditor

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

//

CSwtDateEditor::CSwtDateEditor(MSwtDisplay& aDisplay,

                               TSwtPeer aPeer,

                               MSwtComposite& aParent,

                               TInt aStyle)

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

        , iCurrentFieldLength(0)

        , iCurrentFieldDecimalPlacesCount(0)

        , iLastField(0)

{

}

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

// CSwtDateEditor::~CSwtDateEditor

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

//

CSwtDateEditor::~CSwtDateEditor()

{

    delete iEditor;

    delete iIndicator;

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

    }

#ifdef _lint

    iEditor      = NULL;

    iDefaultFont = NULL;

#endif

}

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

// CSwtDateEditor::ConstructL

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

//

void CSwtDateEditor::ConstructL()

{

    ASSERT(iParent);

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

    SetContainerWindowL(coeParent);

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

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

    SetComponentsToInheritVisibility(ETrue);

    CSwtEditIndicatorRedictor* redirector = MopGetObject(redirector);

    if (redirector)

    {

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

    }

    // Read the Java Epoc date in the resource file

    HBufC* minDateString = iEikonEnv->AllocReadResourceLC(R_SWT_DATEEDITOR_MIN_DATE);

    iEpocDateInMicroSec = TTime(minDateString->Des()).Int64();

    CleanupStack::PopAndDestroy(minDateString);

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

}

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

// CSwtDateEditor::RetrieveDefaultFontL

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

//

void CSwtDateEditor::RetrieveDefaultFontL()

{

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    // Not same but similar to Text's font. Height most probably the same.

    const CFont* font = AknLayoutUtils::FontFromId(CSwtLafFacade::GetFontId(

                            CSwtLafFacade::EFont2MidpTimePaneT1Font));

    ASSERT(font);

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), *font);

    if (!iFont)

    {

        // to avoid the default font of CEikEdwin

        ProcessFontUpdate();

    }

}

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

// CSwtDateEditor::ProcessFontUpdate

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

//

void CSwtDateEditor::ProcessFontUpdate()

{

    const MSwtFont* swtFont=GetFont();

    ASSERT(swtFont);

    const CFont& font = (swtFont->Font());

    iEditor->SetFont(&font);

}

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

// CSwtDateEditor::PrepareForFocusChangeL

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

//

void CSwtDateEditor::PrepareForFocusChangeL()

{

    if (IsFocused())

    {

        iEditor->PrepareForFocusGainL();

    }

    else

    {

        iEditor->PrepareForFocusLossL();

        if (iIndicator)

        {

            iIndicator->SetState(EStateNone);

        }

    }

}

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

// CSwtDateEditor::CountComponentControls

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

//

TInt CSwtDateEditor::CountComponentControls() const

{

    TInt count(0);

    if (iEditor)

    {

        count = 1;

        if (iIndicator)

        {

            count++;

        }

    }

    return count;

}

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

// CSwtDateEditor::ComponentControl

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

//

CCoeControl* CSwtDateEditor::ComponentControl(TInt aIndex) const

{

    ASSERT(iEditor);

    if (aIndex == 0)

    {

        return iEditor;

    }

    return iIndicator->IndicatorContainer();

}

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

// CSwtDateEditor::FocusChanged

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

//

void CSwtDateEditor::FocusChanged(TDrawNow aDrawNow)

{

    if (iEditor)

    {

        TRAP_IGNORE(PrepareForFocusChangeL());

        iEditor->SetFocus(IsFocused());

    }

    HandleFocusChanged(aDrawNow);

}

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

// CSwtDateEditor::MakeVisible

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

//

void CSwtDateEditor::MakeVisible(TBool aVisible)

{

    // Close VKB. Do it here instead of FocusChange to avoid split input flicker.

    {

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

        if (fep)

        {

            fep->HandleDestructionOfFocusedItem();

        }

    }

    CCoeControl::MakeVisible(aVisible);

    FocusabilityChanged();

}

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

// CSwtDateEditor::SetBackgroundL

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

//

void CSwtDateEditor::SetBackgroundL(const MSwtColor* aColor)

{

    ASwtControlBase::DoSetBackgroundL(aColor);

    TRgb color((aColor) ? aColor->RgbValue() : iEikonEnv->Color(EColorControlBackground));

    iEditor->OverrideColorL(EColorControlBackground, color);

    // While background color is set, the editor's control context must be null,

    // otherwise there will be ugly background drawing problems while typing.

    // It looks like there is no need to override FocusBackgroundPolicy,

    // SetUseOverrideColors causes the editor to ignore the skin back.

    // If a foreground color has been set, cannot go back to skin colors yet.

    if (!iFgColorIsCustom)

    {

        if (aColor)

        {

            iEditor->SetUseOverrideColors(ETrue);

        }

        else

        {

            iEditor->SetUseOverrideColors(EFalse);

        }

    }

    if (aColor)

    {

        iBgColorIsCustom = ETrue;

    }

    else

    {

        iBgColorIsCustom = EFalse;

    }

    Redraw();

}

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

// CSwtDateEditor::SetForegroundL

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

//

void CSwtDateEditor::SetForegroundL(const MSwtColor* aColor)

{

    ASwtControlBase::DoSetForegroundL(aColor);

    TRgb color((aColor) ? aColor->RgbValue() : iEikonEnv->Color(EColorControlText));

    iEditor->OverrideColorL(EColorControlText, color);

    // If a back color has been set, cannot go back to skin colors yet.

    if (!iBgColorIsCustom)

    {

        if (aColor)

        {

            iEditor->SetUseOverrideColors(ETrue);

        }

        else

        {

            iEditor->SetUseOverrideColors(EFalse);

        }

    }

    if (aColor)

    {

        iFgColorIsCustom = ETrue;

    }

    else

    {

        iFgColorIsCustom = EFalse;

    }

    Redraw();

}

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

// CSwtDateEditor::OfferKeyEventL

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

//

TKeyResponse CSwtDateEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

{

    TBool traversalDoIt = ETrue;

    if (iEditor)

    {

        switch (aKeyEvent.iCode)

        {

        case EKeyUpArrow:

            traversalDoIt = ETrue;

            break;

        case EKeyDownArrow:

            traversalDoIt = ETrue;

            break;

        case EKeyRightArrow:

            traversalDoIt = ((iEditor->CurrentField() == iEditor->NumFields()-1) &&

                             (GetShell().FindTraversalTargetL(ESwtTraverseArrowNext, *this)));

            break;

        case EKeyLeftArrow:

            traversalDoIt = (iEditor->CurrentField() == 0 &&

                             GetShell().FindTraversalTargetL(ESwtTraverseArrowNext, *this));

            break;

        default:

            traversalDoIt = ETrue;

        }

    }

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

}

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

// CSwtDateEditor::ProcessKeyEventL

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

//

void CSwtDateEditor::ProcessKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    if (!iEditor)

    {

        return;

    }

    if (aType != EEventKey)

        return;

    TInt code = aKeyEvent.iCode;

    TBool amPmField = IsFieldAmPmField(iEditor->CurrentField());

    TBool offsetStyleField = IsFieldOffsetStyleField(iEditor->CurrentField());

    TBool isFieldNumeric = !amPmField && !offsetStyleField;

    TBool wasFieldChangedAlready = IsCurrentFieldChanged(isFieldNumeric);

    UpdateFieldCounters(isFieldNumeric, wasFieldChangedAlready);

    iEditor->OfferKeyEventL(aKeyEvent, aType);

    //MSK label update may be needed.

    if (AknLayoutUtils::MSKEnabled())

    {

        MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

        if (commandArranger)

        {

            commandArranger->UpdateMSKLabelL();

        }

    }

    // End MSK

    if (aKeyEvent.iCode == EKeyEnter)

    {

        iDisplay.PostDefaultSelectionEventL(iPeer);

    }

    TBool isModifyEventAllowed = IsModifyEventAllowed(code, wasFieldChangedAlready);

    if (isModifyEventAllowed || amPmField || offsetStyleField)

    {

        iDisplay.PostModifyEventL(iPeer);

    }

}

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

// CSwtDateEditor::IsFieldChanged

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

//

TBool CSwtDateEditor::IsCurrentFieldChanged(TBool aIsFieldNumeric)

{

    TBool isFieldChangedAlready = ETrue;

    if (aIsFieldNumeric)

    {

        isFieldChangedAlready = CEikMfneField::EInverseVideo !=

                                iEditor->Field(iEditor->CurrentField())->HighlightType();

    }

    return isFieldChangedAlready;

}

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

// CSwtDateEditor::IsFieldChanged

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

//

void CSwtDateEditor::UpdateFieldCounters(TBool aIsFieldNumeric, TBool aIsFieldChanged)

{

    if (aIsFieldNumeric)

    {

        if (!aIsFieldChanged)

        {

            TBuf<16> actualText;

            actualText.AppendNum(

                static_cast<CEikMfneNumber*>(iEditor->Field(iEditor->CurrentField()))->Value());

            iCurrentFieldDecimalPlacesCount = actualText.Length();

            iCurrentFieldLength = 0;

        }

    }

    else

    {

        iCurrentFieldLength = 0;

        iCurrentFieldDecimalPlacesCount = 0;

    }

}

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

// CSwtDateEditor::IsModifyEventAllowed

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

//

TBool CSwtDateEditor::IsModifyEventAllowed(TInt aKeyCode, TBool aWasFieldChangedAlready)

{

    TInt fieldMinimumValue = 0;

    TInt fieldMaximumValue = 0;

    CEikMfneNumber* currentField = static_cast<CEikMfneNumber*>(iEditor->Field(iEditor->CurrentField()));

    currentField->GetMinimumAndMaximum(fieldMaximumValue, fieldMaximumValue);

    TBuf<16> minText;

    minText.AppendNum(fieldMinimumValue);

    TBuf<16> maxText;

    maxText.AppendNum(fieldMaximumValue);

    TInt maxDigits = Max(2, Max(minText.Length(), maxText.Length()));

    TBool isZeroChar = 0 == (aKeyCode - TText(currentField->DigitType()));

    TBool raiseEvent = ETrue;

    TBool isArrowKey = (aKeyCode == EKeyLeftArrow) || (aKeyCode == EKeyRightArrow);

    TChar ch = TChar(aKeyCode);

    if (iEditor->CurrentField() != iLastField || isArrowKey)

    {

        iCurrentFieldLength = 0;

        iCurrentFieldDecimalPlacesCount = 0;

        if (isArrowKey && !aWasFieldChangedAlready)

        {

            raiseEvent = EFalse;

        }

    }

    else if (EKeyBackspace == aKeyCode)

    {

        if (!aWasFieldChangedAlready)

        {

            iCurrentFieldLength = maxDigits;

        }

        iCurrentFieldLength--;

        iCurrentFieldDecimalPlacesCount--;

        if (iCurrentFieldDecimalPlacesCount < 1)

        {

            raiseEvent = EFalse;

        }

    }

    else if (ch.IsDigit())

    {

        iCurrentFieldLength++;

        if (iCurrentFieldLength >= maxDigits)

        {

            iCurrentFieldLength = 0;

            iCurrentFieldDecimalPlacesCount = 0;

        }

        else

        {

            raiseEvent = !isZeroChar || (iCurrentFieldDecimalPlacesCount > 0);

        }

        if (!aWasFieldChangedAlready)

        {

            iCurrentFieldDecimalPlacesCount = 0;

        }

        if (!isZeroChar || (iCurrentFieldDecimalPlacesCount > 0 && isZeroChar))

        {

            iCurrentFieldDecimalPlacesCount++;

        }

    }

    else

    {

        raiseEvent = false;

    }

    iLastField = iEditor->CurrentField();

    return raiseEvent;

}

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

// CSwtDateEditor::IsFieldAmPmField

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

//

TBool CSwtDateEditor::IsFieldAmPmField(TInt fieldIndex) const

{

    // current field is am/pm field if it accepts something else than positive integers

    TBool amPmField = (iDateEditorStyle == MSwtDateEditor::ESwtTime ||

                       iDateEditorStyle == MSwtDateEditor::ESwtDateTime)  &&

                      (iEditor->Field(fieldIndex)->InputCapabilities().Capabilities() &

                       ~TCoeInputCapabilities::EWesternNumericIntegerPositive);

    return amPmField;

}

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

// CSwtDateEditor::IsFieldOffsetStyleField

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

//

TBool CSwtDateEditor::IsFieldOffsetStyleField(TInt fieldIndex) const