/*

* Copyright (c) 2000 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 "NW_Unicode_LetterOther.h"

#include "NW_Unicode_LetterChina.h"

#include "NW_Unicode_LetterThai.h"

// CONSTANTS

static const TUint KWmlFormatNone = 0;

static const TUint KWmlFormatA = 'A';

static const TUint KWmlFormata = 'a';

static const TUint KWmlFormatn = 'n';

static const TUint KWmlFormatN = 'N';

static const TUint KWmlFormatX = 'X';

static const TUint KWmlFormatx = 'x';

static const TUint KWmlFormatm = 'm';

static const TUint KWmlFormatM = 'M';

static const TUint KWmlFormatStatic = '\\';

static const TUint KWmlFormatMultiplier = '*';

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

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

// might leave.

//

TWmlFormatChar::TWmlFormatChar( TUint aChar, TUint aStatic )

	: iChar( aChar )

	{

	iStatic = ( aChar == KWmlFormatStatic ) ? aStatic : 0;

	}

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

// TWmlFormatChar::ForcedCase

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

//

TWmlFormatChar::TWmlCase TWmlFormatChar::ForcedCase() const

	{

	TWmlCase result;

	switch( iChar )

		{

		case KWmlFormatA :

		case KWmlFormatX :

			result = EWmlUpperCase;

			break;

		case KWmlFormata :

		case KWmlFormatx :

			result = EWmlLowerCase;

			break;

		case KWmlFormatn :

		case KWmlFormatN :

			result = EWmlNumericCase;

			break;

		default:

			result = EWmlNone;

			break;

		}

	return result;

	}

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

// TWmlFormatChar::SuggestedCase

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

//

TWmlFormatChar::TWmlCase TWmlFormatChar::SuggestedCase() const

	{

	TWmlCase result;

	switch( iChar )

		{

		case KWmlFormatA :

		case KWmlFormatX :

		case KWmlFormatM :

			result = EWmlUpperCase;

			break;

		case KWmlFormata :

		case KWmlFormatx :

		case KWmlFormatm :

			result = EWmlLowerCase;

			break;

		case KWmlFormatn :

		case KWmlFormatN :

			result = EWmlNumericCase;

			break;

		default:

			result = EWmlNone;

			break;

		}

	return result;

	}

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

// TWmlFormatChar::AlphaAllowed

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

//

TBool TWmlFormatChar::AlphaAllowed() const

	{

	TBool result;

	switch( iChar )

		{

		case KWmlFormatA :

		case KWmlFormata :

		case KWmlFormatX :

		case KWmlFormatx :

		case KWmlFormatM :

		case KWmlFormatm :

		case KWmlFormatStatic :

			result = ETrue;

			break;

		default:

			result = EFalse;

			break;

		}

	return result;

	}

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

// TWmlFormatChar::NumericAllowed

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

//

TBool TWmlFormatChar::NumericAllowed() const

	{

	TBool result;

	switch( iChar )

		{

		case KWmlFormatX :

		case KWmlFormatx :

		case KWmlFormatM :

		case KWmlFormatm :

		case KWmlFormatn :

		case KWmlFormatN :

		case KWmlFormatStatic :

			result = ETrue;

			break;

		default:

			result = EFalse;

			break;

		}

	return result;

	}

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

// TWmlFormatChar::SpecialAllowed

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

//

TBool TWmlFormatChar::SpecialAllowed() const

	{

	TBool result;

	switch( iChar )

		{

		case KWmlFormatA :

		case KWmlFormata :

		case KWmlFormatX :

		case KWmlFormatx :

		case KWmlFormatM :

		case KWmlFormatm :

		case KWmlFormatn :

		case KWmlFormatStatic :

			result = ETrue;

			break;

		default:

			result = EFalse;

			break;

		}

	return result;

	}

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

// TWmlFormatChar::Char

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

//

TUint TWmlFormatChar::Char() const

	{

	return iChar;

	}

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

// TWmlFormatChar::Static()

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

//

TUint TWmlFormatChar::Static() const

	{

	return iStatic;

	}

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

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

// might leave.

//

TKStaticChar::TKStaticChar( TUint aChar, TInt aPos )

	: iChar( aChar )

	, iPos( aPos )

	{

	}

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

// TStaticChar::Char

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

//

TUint TKStaticChar::Char() const

	{

	return iChar;	

	}

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

// TStaticChar::Pos

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

//

TInt TKStaticChar::Pos() const

	{

	return iPos;	

	}

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

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

// might leave.

//

CWmlFormatHandler::CWmlFormatHandler()

	: iPostFix( KWmlFormatNone )

    {

	}

// EPOC default constructor can leave.

void CWmlFormatHandler::ConstructL

	( const TDesC& aFormatString, TWapDocType aWapDocType )

    {

    if ( aWapDocType != EWmlDocType_Wml_1_0 &&

		 aWapDocType != EWmlDocType_Wml_1_1 &&

		 aWapDocType != EWmlDocType_Wml_1_2 )

		{

		// handle unknown types as WML1.3

		aWapDocType = EWmlDocType_Wml_1_3;

		}

	CArrayFixFlat<TInt>* statics = new( ELeave )CArrayFixFlat<TInt>( 3 );

	CleanupStack::PushL( statics );

	// collect the indexes of static characters

	TBool mark = EFalse;

	TInt length = aFormatString.Length();

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

		{

		if ( mark )	// was the previous character prefix?

			{

			mark = EFalse;

			statics->AppendL( i );

			}

		else

			{		// is it prefix?

			mark = ( aFormatString[ i ] == KWmlFormatStatic );

			}

		}

	TInt numberOfStatics = statics->Count();

	iMinLength = length - numberOfStatics;

	iMaxLength = iMinLength;

	// *f and nf handling	

	if ( length > 1 &&				// longer than one character

		 ( !numberOfStatics ||		// there are no statics, or it isn't static

		   statics->At( numberOfStatics - 1 ) != length - 2 ) )

		{

		if ( aFormatString[ length - 2 ] == KWmlFormatMultiplier )	// *f?

			{

			iPostFix = aFormatString[ ( --length )-- ];

			iMinLength = length - numberOfStatics;

			iMaxLength = KInfiniteLength;

			}

		else

			{

			TChar n( aFormatString[ length - 2 ] );

			if ( n.IsDigit() && n != '0' )	// nf?

				{

                                TInt adjustLength = length;

				iPostFix = aFormatString[ ( --adjustLength )-- ];

				iMaxLength = adjustLength - numberOfStatics + n.GetNumericValue();

				// WML1.0, WML1.1: entry of n characters

				// WML1.2, WML1.3: entry of up to n characters

				iMinLength = aWapDocType > EWmlDocType_Wml_1_1

					? adjustLength - numberOfStatics + 1 : iMaxLength;

				}

			}

		}

	// allocate memory for members

	iMask = HBufC::NewL( length);	

	iStatic = new( ELeave )CArrayFixFlat<TKStaticChar>( 3 );

	// copy aFormatString to iMask except static text

	TInt nextStatic = 0;

	for ( TInt j = 0; j < length; j++ )

		{

		if ( nextStatic < numberOfStatics &&

			 j == statics->At( nextStatic ) )	// is it static?

			{

				nextStatic++;

				iStatic->AppendL

					( TKStaticChar( aFormatString[ j ], j - nextStatic ) );

			}

		else

			{

			iMask->Des().Append( aFormatString[ j ] );

			}

		}

	iDynamic = HBufC::NewL( iMinLength );

	CleanupStack::PopAndDestroy();	// statics

    }

// Two-phased constructor.

CWmlFormatHandler* CWmlFormatHandler::NewLC

	( const TDesC& aFormatString, TWapDocType aWapDocType )

    {

	CWmlFormatHandler* self = new( ELeave )CWmlFormatHandler;

	CleanupStack::PushL( self );

    self->ConstructL( aFormatString, aWapDocType );

	return self;

    }

// Two-phased constructor.

CWmlFormatHandler* CWmlFormatHandler::NewL

	( const TDesC& aFormatString, TWapDocType aWapDocType )

    {

    CWmlFormatHandler* self = NewLC( aFormatString, aWapDocType );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CWmlFormatHandler::~CWmlFormatHandler()

    {

	delete iMask;

	delete iStatic;

	delete iDynamic;

    }

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

// CWmlFormatHandler::GetTextOnly

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

//

HBufC* CWmlFormatHandler::GetTextOnlyL( )

    {

    HBufC* newText = HBufC::NewL( iDynamic->Length() );

    TPtr ptr = iDynamic->Des();

    newText->Des().Copy( ptr );

    return newText;

    }

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

// CWmlFormatHandler::SetTextL

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

//

TBool CWmlFormatHandler::SetTextL( const TDesC& aText, TBool aNoValidation )

	{

	iDynamic->Des().SetLength( 0 );	// ignore previous text

	if(AknLayoutUtils::PenEnabled())

	    {

	    // ignore validation if VKB is in use

	    // validation will be done on exit

	    aNoValidation = ETrue; 

	    }

	// insert chars while they are valid

	TInt j( 0 );

	TInt textLength( aText.Length() );

	for ( ;

		  j < textLength &&

		  ( aNoValidation || ValidateChar( aText[ j ], GetFormat( j ) ) );

		  j++ )

		{

		if ( !GetFormat( j ).Static() )

			{

		    InsertL( j, aText[ j ] );	// insert non-static chars

			}

		}

	return j == textLength;

	}

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

// CWmlFormatHandler::TextLC

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

//

HBufC* CWmlFormatHandler::TextLC( TBool aReadable ) const

	{

	HBufC* text = StaticTextLC();	// get static text

	TInt staticLength = text->Length();

	TInt dynamicLength = iDynamic->Length();

	TInt dynamicPtr( 0 );

	TInt staticPtr( 0 );

	TInt staticCounter( 0 );

	TInt numberOfStatics( iStatic->Count() );

	// insert dynamic text into the static text as many as possible

	for ( ; dynamicPtr < dynamicLength; ++dynamicPtr, ++staticPtr )

		{

		// find the next non-static position

		while ( staticCounter < numberOfStatics &&

				iStatic->At( staticCounter ).Pos() == staticPtr )

			{

			++staticCounter;

			++staticPtr;

			}

		if ( staticPtr < staticLength )	// is there place for it?

			{

            /*lint -e{111} Assignment to const object */

			text->Des()[ staticPtr ] = aReadable ? ( *iDynamic )[ dynamicPtr ]

												 : KObscuringChar()[ 0 ];

			}

		else

			{

			break;

			}

		}

	if ( dynamicPtr < dynamicLength )	// append the remaining dynamic text

		{

		HBufC* newText = text->ReAllocL

			( staticLength + dynamicLength - dynamicPtr + 1 );

		CleanupStack::Pop();			// text

		CleanupStack::PushL( newText );	// newText

		text = newText;

		if ( aReadable )

			{

			for ( ; dynamicPtr < dynamicLength; dynamicPtr++ )

				{

				text->Des().Append( ( *iDynamic )[ dynamicPtr ] );

				}

			}

		else

			{

			for ( ; dynamicPtr < dynamicLength; dynamicPtr++ )

				{

				text->Des().Append( KObscuringChar );

				}

			}

		}

	text->Des().ZeroTerminate();

	return text;

	}

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

// CWmlFormatHandler::InsertL

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

//

void CWmlFormatHandler::InsertL( TInt aPos, TChar aChar )

	{

	TBuf<1> buf;

	buf.Append( aChar );

	InsertL( aPos, buf );

	}

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

// CWmlFormatHandler::InsertL

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

//

void CWmlFormatHandler::InsertL( TInt aPos, const TDesC& aDes )

	{

	TInt newPos = PosExludingStatic( aPos );

	if ( -1 < newPos && newPos <= iDynamic->Length() )

		{

		// make sure there's enough space

		TInt newLength = iDynamic->Length() + aDes.Length();

		if ( iDynamic->Des().MaxLength() < newLength )

			{

			iDynamic = iDynamic->ReAllocL( newLength );

			}

		iDynamic->Des().Insert( newPos, aDes );

		}

	}

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

// CWmlFormatHandler::Delete

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

//

TBool CWmlFormatHandler::Delete( TInt aPos, TInt aLength )

    {

    TBool status = EFalse;

    TInt newPos = PosExludingStatic( aPos );

    if ( -1 < newPos && newPos <= iDynamic->Length() )

        {

        iDynamic->Des().Delete( newPos, aLength );

        status = ETrue;

        }

    return status;

    }

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

// CWmlFormatHandler::StaticTextLC

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