/*

* 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 "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:  Avkon text wrapper implementation

*                This class is used by AknTextUtils and AknBidiTextUtils.

*

*/

// INCLUDE FILES

#include "AknTextWrapper.h"

#include "aknenv.h"

#include "AknBidiTextUtils.h"

#include <gdi.h>

#include <uikon.hrh>

#include <bidi.h>

#include <bidivisual.h>

// CONSTANTS

// line feed, carriage return, line separator, paragraph separator

_LIT( KSeparators, "\x000a\x000d\x2028\x2029" );

const TText KLineFeed               = 0x000A;

const TText KCarriageReturn         = 0x000D;

const TText KLineSeparator          = 0x2028;

const TText KParagraphSeparator     = 0x2029;

const TText KZeroWidthSpace         = 0x200B;

const TText KFirstThaiCharacter     = 0x0E01;

const TText KLastThaiCharacter      = 0x0E5B;

enum

    {

    EWrapToArray = 0,

    EChopToArrayAndClip = 1

    };

const TText KAknLocVariantSeparator = 0x0001;

// Helper classes for User::QuickSort.

NONSHARABLE_CLASS(TMyKey) : public TKey

    {

    // From TKey

    private:

        TInt Compare( TInt aLeft, TInt aRight ) const;

        TAny* At( TInt aIndex ) const;

    };

TInt TMyKey::Compare( TInt aLeft, TInt aRight ) const

    {

    const TAknLocVariant* ptr = static_cast<const TAknLocVariant*>( iPtr );

    TInt leftLength = ptr[aLeft].iEnd - ptr[aLeft].iStart;

    TInt rightLength = ptr[aRight].iEnd - ptr[aRight].iStart;

    return rightLength - leftLength;

    }

TAny* TMyKey::At( TInt aIndex ) const

    {

    const TAknLocVariant* ptr = static_cast<const TAknLocVariant*>( iPtr );

    return (TAny*)( &ptr[aIndex] );

    }

NONSHARABLE_CLASS(TMySwap) : public TSwap

    {

    // Constructor

    public:

        inline TMySwap( TAknLocVariant* aVariants ) : iVariants( aVariants ) {}

    // From TSwap

    private:

        void Swap( TInt aLeft, TInt aRight ) const;

    // Data

    private: 

        TAknLocVariant* iVariants;

    };

void TMySwap::Swap( TInt aLeft, TInt aRight ) const

    {

    TAknLocVariant temp = iVariants[aLeft];

    iVariants[aLeft] = iVariants[aRight];

    iVariants[aRight] = temp;

    }

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

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

// TAknTextWrapper::TAknTextWrapper

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

// might leave.

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

//

TAknTextWrapper::TAknTextWrapper( 

    TDes& aStringToWrap,

    const CArrayFix<TInt>* aLineWidthArray, 

    const CFont& aFont,

    CArrayFix<TPtrC>& aWrappedArray,

    TInt aLineWidth,

    TInt aFlags,

    AknBidiTextUtils::TParagraphDirectionality aDirectionality ) :

        iSourceString( aStringToWrap ),

        iLineWidthArray( aLineWidthArray ),

        iFont( aFont ),

        iResultArray( aWrappedArray ),

        iLineWidth( aLineWidth ),

        iFlags( aFlags ),

        iDirectionality( aDirectionality ),

        iSeparators( KSeparators() ),

        iText( NULL, 0 )

    {

    }

// Destructor

TAknTextWrapper::~TAknTextWrapper()

    {

    }

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

// TAknTextWrapper::WrapToArrayL

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

//

HBufC* TAknTextWrapper::WrapToArrayL()

    {

    return DoOperationL( EWrapToArray );

    }

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

// TAknTextWrapper::ChopToArrayAndClipL

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

//

HBufC* TAknTextWrapper::ChopToArrayAndClipL()

    {

    return DoOperationL( EChopToArrayAndClip );

    }

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

// TAknTextWrapper::DoOperationL

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

//

HBufC* TAknTextWrapper::DoOperationL( TInt aOp )

    {

    iResultArray.Reset();

    if ( !iSourceString.Length() )

        {

        if ( iFlags & EReserveVisualBuffer )

            {

            return HBufC::NewL( 0 );

            }

        else

            {

            return NULL;

            }

        }

    HBufC* ret = NULL;

    TAknLocVariant variants[KAknMaxLocVariants];

    TInt numVariants = GetLocVariants( iSourceString, variants );

    iFlags &= ~EFits;

    TInt i = 0;

    HBufC* backupBuf = iSourceString.AllocLC();

    for ( ; i < numVariants && !(iFlags & EFits); i++ )

        {

        delete ret;

        ret = NULL;

        TInt start = variants[i].iStart;

        iSourceString.Copy( 

            backupBuf->Mid( start, variants[i].iEnd - start ) );

        iFlags |= EFits;

        // Clears EFits if truncated.

        if ( aOp == EWrapToArray )

            {

            ret = DoWrapToArrayL();

            }

        else

            {

            ret = DoChopToArrayAndClipL();

            }

        }

    CleanupStack::PopAndDestroy(); // backupBuf

    return ret;

    }

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

// TAknTextWrapper::DoWrapToArrayL

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

//

HBufC* TAknTextWrapper::DoWrapToArrayL()

    {

    iResultArray.Reset();

    // TBidiLogicalToVisual crashes with length 0 text so we check that case here

    if ( !iSourceString.Length() )

        {

        if ( iFlags & EReserveVisualBuffer )

            {

            return HBufC::NewL( 0 );

            }

        else

            {

            return NULL;

            }

        }

    TInt index( 0 );

    TInt lineIndex( 0 );

    TInt maxLines( KMaxTInt );

    if ( iLineWidthArray && !( iFlags & EWrapAllText ) )

        {

        maxLines = iLineWidthArray->Count();

        }

    while ( index < iSourceString.Length() && iResultArray.Count() < maxLines )

        {

        TInt lineWidth = iLineWidth;

        if ( iLineWidthArray )

            {

            TInt givenWidths = iLineWidthArray->Count();

            TInt usedLineWidthIndex = lineIndex;

            if ( lineIndex >= givenWidths )

                {

                usedLineWidthIndex = givenWidths - 1;

                }

            lineWidth = (*iLineWidthArray)[usedLineWidthIndex];

            }

        iText.Set( iSourceString.Right( iSourceString.Length() - index ) );

        TInt fitsInLine = iFont.TextCount( iText, lineWidth );

        // If the line width is constant and no characters fit in it, stop.

        if ( !fitsInLine && 

           (!iLineWidthArray || lineIndex >= iLineWidthArray->Count()) )

            {

            break;

            }

        // Is there an explicit line break in the part that fits in line

        TInt newLine = FindLineBreak( iText.Left( fitsInLine ) );

        if ( newLine != KErrNotFound )

            {

            iNextLineStart = newLine;

            PassLineBreak(); // updates iNextLineStart

            if ( iNextLineStart == iText.Length() )

                {

                AppendToArrayL( iText.Left( newLine ) );

                break;

                }

            }

        // All remaining text fits in line?

        else if ( iText.Length() == fitsInLine )

            {

            AppendToArrayL( iText );

            break;

            }

        TInt wrapIndex( 0 );

        // Last line? If so, clip it if required...

        if ( iFlags & EClip && lineIndex == maxLines - 1 )

            {

            if ( newLine != KErrNotFound )

                {

                iText.Set( iText.Left( newLine ) );

                }

            // This actually inserts ellipsis in text only if logical to

            // visual conversion is not used.

            wrapIndex = InsertEllipsis( iText, lineWidth );

            // This flag informs logical to visual conversion to insert

            // truncation character

            iFlags |= EClipRequired;

            iFlags &= ~EFits;

            AppendToArrayL( iText.Left( wrapIndex ) );

            break;

            }

        // Not last line, so no clipping required yet

        if ( newLine != KErrNotFound )

            {

            wrapIndex = newLine;

            }

        // No explicit line break in the part that fits in line,

        // find wrapping potision

        else

            {

            if ( GetWrappingPosition( iText, fitsInLine, lineWidth, ETrue ) )

                {

                wrapIndex = iBreakPos;

                }

            else

                {

                // No legal wrapping position found => illegal line breaking.

                // Put all that fits in line.

                wrapIndex = fitsInLine;

                iNextLineStart = fitsInLine;

                }

            PassLineBreak(); // updates iNextLineStart

            }

        AppendToArrayL( iText.Left( wrapIndex ) );

        index += iNextLineStart;

        // next line to be wrapped

        lineIndex++;

        }

    return ConvertToVisualIfRequiredL();

    }

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

// TAknTextWrapper::DoChopToArrayAndClipL

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

//

HBufC* TAknTextWrapper::DoChopToArrayAndClipL()

    {

    iResultArray.Reset();

    // First determine succifient amount of text lines for visual buffer.

    TInt maxLines = 0;

    if ( iLineWidthArray )

        {

        maxLines = iLineWidthArray->Count();

        }

    else

        {

        TInt length = iSourceString.Length();

        const TText* text = iSourceString.Ptr();

        // This counts 2 lines for lines ending to CR+LF but it does not

        // really matter as we are determining a succifient number of lines.

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

            {

            if ( iSeparators.Locate( text[i] ) != KErrNotFound )

                {

                maxLines++;

                }

            }

        maxLines++; // add one extra for the line after the last line break.

        }

    // Allocate visual buffer.

    HBufC* visualBuffer = HBufC::NewLC( 

        iSourceString.Length() + maxLines * KAknBidiExtraSpacePerLine );

    TInt index( 0 );        // index in iSourceString

    TInt lineIndex( 0 );    // line number

    TInt visualIndex( 0 );  // index in visualBuffer

    // We utilize wrapping functionality for each line to be chopped.

    // These temp arrays are for that purpose.

    CArrayFix<TInt>* tempLineWidthArray =

        new( ELeave ) CArrayFixFlat<TInt>( 1 );

    CleanupStack::PushL( tempLineWidthArray );

    tempLineWidthArray->AppendL( 0 );

    CArrayFix<TPtrC>* tempResultArray =

        new( ELeave ) CArrayFixFlat<TPtrC>( 1 );

    CleanupStack::PushL( tempResultArray );

    while ( index < iSourceString.Length() && iResultArray.Count() < maxLines )

        {

        iText.Set( iSourceString.Right( iSourceString.Length() - index ) );

        // Locate line break

        iNextLineStart = FindLineBreak( iText );

        if ( iNextLineStart == KErrNotFound )

            {

            iNextLineStart = iText.Length();

            }

        TInt flags( TAknTextWrapper::EClip );

        if ( iFlags & EConvertToVisual )

            {

            flags |= EConvertToVisual;

            }

        // chop the line in visual buffer

        TInt visualRemainingSpace = 

            visualBuffer->Des().MaxLength() - visualIndex;

        const TText* nextLine = visualBuffer->Ptr();

        nextLine += visualIndex;

        TPtr ptr( 

            const_cast<TText*>( nextLine ),

            visualRemainingSpace,

            visualRemainingSpace );

        ptr.Copy( iText.Left( iNextLineStart ) );

        // we only wrap 1 line

        (*tempLineWidthArray)[0] =

            iLineWidthArray ? (*iLineWidthArray)[lineIndex] : iLineWidth;

        TAknTextWrapper wrapper(

            ptr,

            tempLineWidthArray,

            iFont,

            *tempResultArray,

            0,

            flags,

            iDirectionality );

        wrapper.WrapToArrayL();

        if ( !wrapper.ResultFits() )

            {

            iFlags &= ~EFits;

            }

        TInt lineLength = 0;

        if ( tempResultArray->Count() )

            {

            lineLength = (*tempResultArray)[0].Length();

            }

        visualBuffer->Des().SetLength( visualIndex + lineLength );

        if ( iFlags & EReserveVisualBuffer )

            {

            AppendToArrayL( visualBuffer->Right( lineLength ) );

            }

        else

            {

            // Cannot use AppendToArrayL here, because iResultArray is set to point to iSourceString,

            // which does not contain the final visual text yet. This would screw up removing trailing spaces.

            // It is copied there in the end of this method.

            TPtrC currentLine = visualBuffer->Right( lineLength );

            TInt trailingSpaces = 0;

            TInt trailingIndex = currentLine.Length() - 1;

            // Count how many spaces there are in the end of the line.

            // Without removing them, text that is aligned to the end of line looks bad.

            while ( trailingIndex >= 0 && currentLine[trailingIndex] == ' ' )

                {

                trailingIndex--;

                trailingSpaces++;

                }

            iResultArray.AppendL( iSourceString.Mid( visualIndex, lineLength - trailingSpaces ) );

            }

        visualIndex += lineLength;

        PassLineBreak();

        index += iNextLineStart;

        // next line to be wrapped

        lineIndex++;

        }

    CleanupStack::PopAndDestroy( 2 ); // tempLineWidthArray, tempResultArray

    if ( iFlags & EReserveVisualBuffer )

        {

        CleanupStack::Pop();

        return visualBuffer;

        }

    else

        {

        iSourceString = *visualBuffer;

        CleanupStack::PopAndDestroy(); // visualBuffer;

        return NULL;

        }

    }

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

// TAknTextWrapper::InsertEllipsis

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

//

TInt TAknTextWrapper::InsertEllipsis( const TDesC& aText, TInt aLineWidth )

    {

    // place ellipsis in the last possible place so that

    // the line still fits

    TInt count = iFont.TextCount( aText,

        aLineWidth - iFont.CharWidthInPixels( KEllipsis ) );

    if ( !(iFlags & EConvertToVisual) )

        {

        TText* text = (TText*)( aText.Ptr() );

        text[ count ] = KEllipsis;

        return count + 1;

        }

    else

        {

        // ellipsis will be added in logical to visual conversion

        return count;

        }