/*

* Copyright (c) 2002-2004 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:

*

* Description:     Japanese user dictionary's editor form.

*

*/

// INCLUDE FILES

#include    "UdictFrm.h"

#include    "UdictView.h"

#include    "UdictElement.h"

#include    "UserDict.hrh"

#include    <UserDict.rsg>

#include    <avkon.hrh>

#include    <eikedwin.h>

// CONSTANTS

const TInt KNumOfInvalidFirstChar(12);

const TText KInvalidFirstChars[KNumOfInvalidFirstChar] =

    {

    0x3041, // small A

    0x3043, // small I

    0x3045, // small U

    0x3047, // small E

    0x3049, // small O

    0x3063, // small TU

    0x3083, // small YA

    0x3085, // small YU

    0x3087, // small YO

    0x3092, // WO

    0x3093, // N

    0x30fc  // prolonged sound mark

    };

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

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

// CUserDictForm::NewL

// Two-phased constructor.

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

//

CUserDictForm* CUserDictForm::NewL(const TUDictElement& aItem,

                                   CUserDictView& aView)

    {

    CUserDictForm* self = new(ELeave) CUserDictForm(aItem, aView);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

// Destructor

CUserDictForm ::~CUserDictForm ()

    {

    }

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

// CUserDictForm::CUserDictForm

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUserDictForm::CUserDictForm(const TUDictElement& aItem, CUserDictView& aView)

:iInitEntry(aItem), iView(aView)

    {

    }

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

// CUserDictForm::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUserDictForm::ConstructL()

    {

    CAknForm::ConstructL();

    }

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

// CUserDictForm::SaveL

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

//

TBool CUserDictForm::SaveL()

    {

    TBool res(ETrue);

    TUDictElement entry;

    GetData(entry);

    if (entry != iInitEntry)

        {

        if (IsValidReadingL(entry))

            {

            TRAPD(err, iView.SaveL(entry, iInitEntry));

            switch (err)

                {

                case KErrDiskFull: // No space to register

                    iView.ShowInformationNoteL(

                        R_UDICT_INFO_MEMORY_FULL_MESSAGE);

                    // if it's a new entry, returns EFalse

                    res = (iInitEntry.IsEmpty()) ? EFalse : ETrue;

                    break;

                case KErrAlreadyExists: // Already registered

                    iView.ShowInformationNoteL(R_UDICT_ALREADY_REG_MESSAGE);

                    res = EFalse;

                    break;

                default:

                    User::LeaveIfError(err);

                }

            }

        else

            {

            TryChangeFocusToL(EUserDictReadingEdwin);

            static_cast<CEikEdwin*>(

                Control(EUserDictReadingEdwin))->SetCursorPosL(0, EFalse);

            res = EFalse;

            }

        }

    return res;

    }

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

// CUserDictForm::GetData

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

//

void CUserDictForm::GetData(TUDictElement& aEntry) const

    {

    CPlainText*  text =

        static_cast<CEikEdwin*>(Control(EUserDictWordEdwin))->Text();

    TInt docLen = text->DocumentLength();

    if (docLen > EUseDictWordBuffer)

        {

        docLen = EUseDictWordBuffer;

        }

    TPtrC word(static_cast<CEikEdwin*>(

        Control(EUserDictWordEdwin))->Text()->Read(0, docLen));

    aEntry.SetWord(word);

    text = static_cast<CEikEdwin*>(Control(EUserDictReadingEdwin))->Text();

    TPtrC reading(text->Read(0, text->DocumentLength()));

    aEntry.SetReading(reading);

    }

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

// CUserDictForm::SetDataL

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

//

void CUserDictForm::SetDataL() const

    {

    TPtrC ptrWord(iInitEntry.Word());

    static_cast<CEikEdwin*>(

        Control(EUserDictWordEdwin))->SetTextL(&ptrWord);

    TPtrC ptrReading(iInitEntry.Reading());

    static_cast<CEikEdwin*>(

        Control(EUserDictReadingEdwin))->SetTextL(&ptrReading);

    }

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

// CUserDictForm::IsBlank

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

//

TBool CUserDictForm::IsBlank() const

    {

    return (((static_cast<CEikEdwin*>(

                Control(EUserDictWordEdwin))->TextLength() <= 0)

        || (static_cast<CEikEdwin*>(

                Control(EUserDictReadingEdwin))->TextLength() <= 0)

        ) ? ETrue : EFalse);

    }

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

// CUserDictForm::IsValidReadingL

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

//

TBool CUserDictForm::IsValidReadingL(const TUDictElement& aItem) const

    {

    TBool valid(ETrue);

    const TDesC& reading = aItem.Reading();

    if (reading.Length() <= 0)

        return EFalse;

    // If the reading has a invalid first character,

    // it shows the information note.

    for (TInt i(0); i < KNumOfInvalidFirstChar && valid; i++)

        {

        if (reading[0] == KInvalidFirstChars[i])

            {

            iView.ShowInformationNoteL(R_UDICT_INVALID_1STCHAR_MESSAGE);

            valid = EFalse;

            }

        }

    return valid;

    }

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

// CUserDictForm::PreLayoutDynInitL

// From CEikDialog

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

//

void CUserDictForm::PreLayoutDynInitL()

    {

    SetDataL();

    // if the form edits a new word, "Done" softkey is hidden.

    if (iInitEntry.IsEmpty())

        {

        ButtonGroupContainer().SetCommandSetL( R_UDICT_SOFTKEYS_EMPTY_CANCEL_EMPTY );

        ButtonGroupContainer().DrawNow();

        iSoftkeyResource = R_UDICT_SOFTKEYS_EMPTY_CANCEL_EMPTY;

        }

    }

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

// CUserDictForm::OkToExitL

// From CEikDialog

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

//

TBool CUserDictForm::OkToExitL(TInt aKeycode)

    {

    TBool ret = ETrue;

    switch (aKeycode)

        {

        case EAknSoftkeyDone:

            ret = SaveL();

            break;

        case EAknSoftkeyEmpty:

            ret = EFalse;

            break;

        case EAknSoftkeyCancel:

        default:

            break;

        }

    return ret;

    }

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

// CUserDictForm::HandleControlStateChangeL

// From MCoeControlObserver

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

//

void CUserDictForm::HandleControlStateChangeL(TInt aControlId)

    {

    // If the entry fields are blank, "Done" softkey is hidden.

    if (aControlId == EUserDictWordEdwin

       || aControlId == EUserDictReadingEdwin)

        {

        TUint res = 0;

        if (IsBlank())

            {

            res = R_UDICT_SOFTKEYS_EMPTY_CANCEL_EMPTY;

            }

        else

            {

            res = R_UDICT_SOFTKEYS_DONE_CANCEL_DONE;

            }

        if (iSoftkeyResource != res)

            {

            ButtonGroupContainer().SetCommandSetL( res );

            ButtonGroupContainer().DrawDeferred();

            iSoftkeyResource = res;

            }

        }

    CAknForm::HandleControlStateChangeL(aControlId);

    }

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

// CUserDictForm::OfferKeyEventL

// From CCoeControl

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

//

TKeyResponse CUserDictForm::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    TKeyResponse res(EKeyWasConsumed);

    if (aType == EEventKey && aKeyEvent.iCode == EKeyOK)

        {

        if (aKeyEvent.iRepeats <= 0 && !IsBlank())

            {

            TryExitL(EAknSoftkeySelect);

            }

        }

    else

        {

        res = CAknForm::OfferKeyEventL(aKeyEvent, aType);

        }

    return res;

    }

//  End of File