/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

// INCLUDE FILES

#include <E32KEYS.H>

#include <E32STD.H>

#include <ptidefs.h>

#include "nw_fbox_CEpoc32InputBox.h"

#include "nw_fbox_WmlFormatHandler.h"

#include "nw_fbox_formboxutils.h"

#include "nw_fbox_WmlFormattedEditor.h"

#include "nw_wml1x_wml_1_3_tokens.h"

#include <aknenv.h>

#include <akneditstateindicator.h>

#include <aknindicatorcontainer.h>

#include <aknutils.h>

#include <barsread.h>       // for resource reader

#include <webkit.rsg>

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#include <eikseced.h>       // for secret editor

#include <eikrted.h>

#include <txtrich.h>

#include <aknnotedialog.h>

#include <gulbordr.h>

#include "NW_Fbox_InputBox.h"

#include "NW_Fbox_inputskini.h"

#include "NW_Fbox_InputSkin.h"

#include "NW_Fbox_Epoc32InputSkin.h"

#include "NW_Fbox_textareabox.h"

#include "BrsrStatusCodes.h"

#include "eikon.hrh"

//#include <aknedsts.h>

//#include <FEPBASE.H>

// CONSTANTS

static const TInt KNumberOfLines = 1000;

// ================= STATIC FUNCTIONS =======================

TInt CEpoc32InputBox::RefreshContents( TAny* aParam )

{

  CEpoc32InputBox* epoc32InputBox= (CEpoc32InputBox* )aParam ;

  epoc32InputBox->iEditor->DrawContents();

  epoc32InputBox->iActiveSchedulerWait.AsyncStop();

  return 0;

}

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

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

// might leave.

//

CEpoc32InputBox::CEpoc32InputBox( CCoeControl* aParent,

                                  void* aOocInputSkin,

                                  const TInt aInitialWrapWidth,

                                  const TInt aMaxLength,

                                  const CFont& aFont,

                                  const TInt aLayoutMode) :

    iOocInputSkin ( aOocInputSkin ),

    iFont( aFont ),

    iMaxLength( aMaxLength ),

    iParent( aParent ),

    iWrapWidth( aInitialWrapWidth ),

    iLayoutMode(aLayoutMode)

    {

    // ignore negative values, and max possible value (it means that maxlength is not specified)

    if ( iMaxLength < 0 )

        {

        iMaxLength = 0;

        }

    }

// Initialize format mask handler

//

void CEpoc32InputBox::InitFormatHandlerL( const TDesC& aFormat,

                                          const TBool aIsSecret,

                                          TBool& aT9Allowed,

                                          TInt& aMaxLength,

                                          const NW_FBox_Validator_EmptyOk_t aIsEmptyOk,

                                          const NW_Uint32 aDocPublicId )

    {

    // T9 is not allowed for password boxes (or touch)

    aT9Allowed = (!aIsSecret && !iPenEnabled);

    // get TWapDocType from aDocPublicId

    TWapDocType wapDocType;

    switch ( aDocPublicId )

        {

        case NW_Wml_1_0_PublicId:

            wapDocType = EWmlDocType_Wml_1_0;

            break;

        case NW_Wml_1_1_PublicId:

            wapDocType = EWmlDocType_Wml_1_1;

            break;

        case NW_Wml_1_2_PublicId:

            wapDocType = EWmlDocType_Wml_1_2;

            break;

        case NW_Wml_1_3_PublicId:

            wapDocType = EWmlDocType_Wml_1_3;

            break;

        default:

            wapDocType = EWmlDocType_Unknown;

            break;

        }

    if ( aFormat.Length() )  // is FORMAT specified?

        {

        // create format handler

        iHandler = CWmlFormatHandler::NewL( aFormat, wapDocType );

        // Is it other than "*f" or "nf" where f is not "n" or "N" ?

        if ( aFormat.Length() != 2 || !iHandler->PostFix().AlphaAllowed() )

            {

            aT9Allowed = EFalse;

            }

        }

    TInt formatMax( iHandler ? iHandler->MaxLength() : KInfiniteLength );

    if ( iMaxLength && formatMax != KInfiniteLength ) // both are specified

        {

        aMaxLength = Min( formatMax, iMaxLength );

        }

    else

        {

        aMaxLength = iMaxLength;

        }

  if ( aIsEmptyOk == NW_FBox_Validator_EmptyOk_True )

    {

    iEmptyOk = ETrue;

    }

  else if ( aIsEmptyOk == NW_FBox_Validator_EmptyOk_False )

        {

        iEmptyOk = EFalse;

        }

    else

        {

        // emptyok is not specified.

        // if there is no iHandler value, there is no format specified, too

        // so use a default format - *m, which implies emptyok=true

        if ( !iHandler || wapDocType == EWmlDocType_Unknown )

            {

            iEmptyOk = ETrue;

            }

        if ( iHandler )     // Is format attribute specified?

            {

            iEmptyOk = !iHandler->MinLength() &&   // Does it allow empty input?

                         (wapDocType == EWmlDocType_Wml_1_3 || wapDocType == EWmlDocType_Unknown);    // Is it WML 1.3?

            }        // for unknown documents (like XHTML) iEmptyOk will be true

    }

    }

// EPOC default constructor can leave.

//

void CEpoc32InputBox::ConstructL( const TRect& aInitialRectangle,

                                  const TMargins8& aMargins,

                                  const TDesC& aInitialText,

                                  const TDesC& aFormat,

                                  const NW_FBox_Validator_Mode_t aMode,

                                  const TBool aIsSecret,

                                  const NW_FBox_Validator_EmptyOk_t aIsEmptyOk,

                                  const NW_Uint32 aDocPublicId,

                                  const TInt aMaxLength )

    {

    TBool t9Allowed;

    TInt maxLength = aMaxLength;

    TWmlMode mode;

    iContainer = NULL;

    iPenEnabled = AknLayoutUtils::PenEnabled();

    // if password input box, create the secret editor for it

    if ( aIsSecret )

        {

        TInt pwLength = aMaxLength;

        iContainer = new (ELeave) CEikSecretEditor;

        iContainer->SetMopParent(this);

        iContainer->AknSetFont( iFont );

        iContainer->SetBorder( TGulBorder::ESingleBlack );

        iEikonEnv->AddFepObserverL( *this );

        // add ourselves to the controls stack, so that we'll recieve key events

        iEikonEnv->EikAppUi()->AddToStackL( this );

        iEikonEnv->AddFocusObserverL(*this);

        CreateWindowL( iParent );

        TResourceReader reader;

        iCoeEnv->CreateResourceReaderLC(reader, R_WMLBROWSER_SECRET_EDITOR);

        iContainer->SetContainerWindowL(*this);

        iContainer->ConstructFromResourceL(reader);

        CleanupStack::PopAndDestroy();  // Resource reader

        ActivateL();

        if (pwLength == KInfiniteLength || pwLength < 0 || pwLength > CEikSecretEditor::EMaxSecEdSecArrayLength )

            {

            pwLength = CEikSecretEditor::EMaxSecEdSecArrayLength;

            }

        iContainer->SetMaxLength( pwLength );

        InitFormatHandlerL( aFormat,

                            aIsSecret,

                            t9Allowed,

                            pwLength,

                            aIsEmptyOk,

                            aDocPublicId );

        TRect adjustedRect;

        adjustedRect.iTl.iX = aInitialRectangle.iTl.iX;

        adjustedRect.iTl.iY = aInitialRectangle.iTl.iY;

        adjustedRect.iBr.iX = aInitialRectangle.iBr.iX;

        adjustedRect.iBr.iY = aInitialRectangle.iBr.iY;

        adjustedRect.Shrink(1, 1);

        iContainer->SetRect(adjustedRect);

        iRect = adjustedRect;

        iFocusObserverAdded= ETrue;

        if (aFormat.Length() > 0 && (aFormat[0] == 'n' || aFormat[0] == 'N'))

            {

            iContainer->SetDefaultInputMode(EAknEditorNumericInputMode);

            }

        else

            {

            iContainer->SetDefaultInputMode(EAknEditorSecretAlphaInputMode);

            }

        iContainer->SetText( aInitialText.Left( pwLength ) );

        iEditor = NULL;

        AllowEditingL( ETrue );

        ActivateVKB();

        return;

        }

    else

        {

        SetContainerWindowL( *iParent );

        }

    // Create formatted editor

    iEditor = new( ELeave )CWmlFormattedEditor(aIsSecret);

    // Create/Get the Avkon FEP repository

    CRepository* aknFepRepository = CRepository::NewL( KCRUidAknFep );

    User::LeaveIfNull( aknFepRepository );

    // Read the predictive text setting

#ifdef RD_INTELLIGENT_TEXT_INPUT

    TPtiKeyboardType keyboardType( EPtiKeyboardNone );

    TInt predTxtMask( 0 );

    aknFepRepository->Get( KAknFepPhysicalKeyboards, (TInt&)keyboardType );

    aknFepRepository->Get( KAknFepPredTxtFlagExtension, predTxtMask );

    switch( keyboardType )

        {

        case EPtiKeyboardNone:

            // No hardware keyboard

            break;

        case EPtiKeyboard12Key:

            // ITU-T keyboard predictive text bit mask enabled

            predTxtMask &= 0x01; // EKeyboardStyle12Key define missing in AknFepInternalCRKeys.h

            break;

        case EPtiKeyboardQwerty4x12:

        case EPtiKeyboardQwerty4x10:

        case EPtiKeyboardQwerty3x11:

        case EPtiKeyboardHalfQwerty:

        case EPtiKeyboardCustomQwerty:

            // qwerty keyboard predictive text bit mask enabled

            predTxtMask &= 0x02; // EKeyboardStyleQwerty define missing in AknFepInternalCRKeys.h

            break;

        default:

            break;

        }

    iPredictiveTextOn = ( predTxtMask ? 1 : 0);

#else

        // Check repository for predictive text enable flag

        aknFepRepository->Get( KAknFepPredTxtFlag, iPredictiveTextOn );

#endif

    // Delete the repository

    delete aknFepRepository;

    aknFepRepository = NULL;

    // create format handler and get t9allowed and maxLength

    InitFormatHandlerL( aFormat,

                        aIsSecret,

                        t9Allowed,

                        maxLength,

                        aIsEmptyOk,

                        aDocPublicId );

    // initialize formatted editor

    iEditor->ConstructL( iParent,

                         KNumberOfLines,

                         maxLength,

                         CEikEdwin::ENoAutoSelection );

    iEditor->AddFlagToUserFlags ( CEikEdwin::EJustAutoCurEnd );

    iEditor->EnableT9( t9Allowed, aIsSecret );

    switch ( aMode )

    {

        case NW_FBox_Validator_Mode_Alphabet:

            mode = EWmlModeAlphabet;

            break;

        case NW_FBox_Validator_Mode_Numeric:

            mode = EWmlModeNumeric;

            break;

        case NW_FBox_Validator_Mode_Hiragana:

            mode = EWmlModeHiragana;

            break;

        case NW_FBox_Validator_Mode_Katakana:

            mode = EWmlModeKatakana;

            break;

        case NW_FBox_Validator_Mode_Hankakukana:

            mode = EWmlModeHankakukana;

            break;

        default:

            mode = EWmlModeNone;

            break;

        }

    iEditor->InitializeL( iHandler, aIsSecret, mode );

    iEditor->SetBorderViewMargins( aMargins );

    iEditor->SetBorder( TGulBorder::ESingleBlack );

      // set ourselves to be observer of the formatted editor

    iEditor->SetEdwinObserver( this );

    iEikonEnv->AddFepObserverL(*this);

    // add ourselves to the controls stack, so that we'll recieve key events

    iEikonEnv->EikAppUi()->AddToStackL( this );

    iEditCommitFlag  = EFalse;

    const NW_Object_t* object = NW_FBox_InputSkin_GetInputBox ((NW_FBox_Epoc32InputSkin_t *)iOocInputSkin);

    if (!NW_Object_IsClass(object, &NW_FBox_TextAreaBox_Class))

        {   // if NOT textarea box...

        SetRect( aInitialRectangle );

    iEditor->AddFlagToUserFlags (CEikEdwin::ENoLineOrParaBreaks|EEikEdwinNoWrap);

    iEditor->SetFocus(ETrue);

    iEditor->SetRect(aInitialRectangle);

        iEikonEnv->AddFocusObserverL(*this);

        iFocusObserverAdded= ETrue;

    }

    else

        {  // if textarea box...

        iEditor->AddFlagToUserFlags (CEikEdwin::ENoHorizScrolling);

        iEditor->ActivateL();

        SetRectAndWrap( aInitialRectangle, iWrapWidth );

        iFocusObserverAdded= EFalse;

        }

    // replace all NW_TEXT_UCS2_LF with NW_TEXT_UCS2_PARASEP

    TInt pos;

    HBufC* buf = aInitialText.AllocLC();

    TPtr ptr = buf->Des();

    while ( (pos=ptr.Locate(TChar(NW_TEXT_UCS2_LF))) != KErrNotFound )

       {

       ptr[pos] = NW_TEXT_UCS2_PARASEP;

       if ( pos > 0 && ptr[pos-1] == NW_TEXT_UCS2_CR )

           {

           ptr.Delete(pos-1,1);

           }

       }

    // replace all NW_TEXT_UCS2_TAB with ' '

    ptr = buf->Des();

    while ( (pos=ptr.Locate(TChar(NW_TEXT_UCS2_TAB))) != KErrNotFound )

       {

       ptr[pos] = ' ';

       }

    // set initial text

    SetInitialTextL( buf->Des() );

    CleanupStack::PopAndDestroy(); // buf

    iEditor->SetAllowUndo( EFalse );

    // start editing

    AllowEditingL( ETrue );

    UpdateTextCounterL();

    ActivateVKB();

    }

// Two-phased constructor.

CEpoc32InputBox* CEpoc32InputBox::NewL( CCoeControl* aParent,

                                        void* aOocInputSkin,

                                        const TRect& aInitialRectangle,

                                        const TMargins8& aMargins,

                                        const TInt aInitialWrapWidth,

                                        const TDesC& aInitialText,

                                        const TDesC& aFormat,

                                        const NW_FBox_Validator_Mode_t aMode,

                                        const TBool aIsSecret,

                                        const NW_FBox_Validator_EmptyOk_t aIsEmptyOk,

                                        const NW_Uint32 aDocPublicId,

                                        const TInt aMaxLength,

                                        const CFont& aFont,

                                        const TInt aLayoutMode)

    {

    CEpoc32InputBox* thisObj = new( ELeave )CEpoc32InputBox( aParent,

                                                             aOocInputSkin,

                                                             aInitialWrapWidth,

                                                             aMaxLength,

                                                             aFont,

                                                             aLayoutMode);

    CleanupStack::PushL( thisObj );

    thisObj->ConstructL( aInitialRectangle,

                         aMargins,

                         aInitialText,

                         aFormat,

                         aMode,

                         aIsSecret,

                         aIsEmptyOk,

                         aDocPublicId,

                         aMaxLength );

    CleanupStack::Pop(); // thisObj

    return thisObj;

    }

// Destructor

CEpoc32InputBox::~CEpoc32InputBox()

    {

    // remove ourselves from controls stack

    iEikonEnv->EikAppUi()->RemoveFromStack(this);

    if (iFocusObserverAdded)

      {

      iEikonEnv->RemoveFocusObserver(*this);

      }

    iEikonEnv->RemoveFepObserver(*this);

    if (iEditor)

      {

      iEditor->CancelFepTransaction();        // cancel inline editing

      }

    TRAP_IGNORE( AllowEditingL( EFalse ) );   // close editor

    if ( iEditor )

      {

      iEditor->SetVkbState(NULL);

      iEditor->FreePassword();  // must be called before destruction!!!!

      delete iEditor;

      }

    delete iInlineEditText;

    delete iDocumentText;

    delete iState;

    delete iHandler;

    delete iContainer;

    // release editor's rich text content

    delete iGlobalParaLayer;

    delete iGlobalCharLayer;

    }

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

// CEpoc32InputBox::ShowCursorL

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

void CEpoc32InputBox::ShowCursorL( TWmlCursorHandling aMode )

    {

    // get cursor co-ordinates

    TPoint cursorPos;

        iEditor->TextView()->DocPosToXyPosL( iEditor->CursorPos(), cursorPos );

    TInt width = iFont.MaxCharWidthInPixels();

    TInt height, ascent;

        iEditor->TextLayout()->GetFontHeightAndAscentL

            ( iFont.FontSpecInTwips(), height, ascent );