/*

* Copyright (c) 2004-2005 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:  Implementation of TtsCommon 

*

*/

// INCLUDE FILES

#include "srsfbldvariant.hrh"

#include "ttscommonbody.h"

#include "nssttscommon.h"

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

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

// CTtsParsedTextBody::CTtsParsedTextBody

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

// might leave.

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

//

CTtsParsedTextBody::CTtsParsedTextBody() :

    iText( NULL ),

    iPhonemeSequence( NULL ),

    iPhonemeNotation( NULL )

    {

    // nothing

    }

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

// CTtsParsedTextBody::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTtsParsedTextBody::ConstructL(

    const TDesC& aText, 

    const TDesC8& aPhonemeSequence, 

    const TDesC& aPhonemeNotation )

    {

    if ( aText != KNullDesC )

        {

        // copy text 

        iText = HBufC::NewL( aText.Length() );

        TPtr tempPtr( iText->Des() );

        tempPtr = aText;

        }

    if ( aPhonemeSequence != KNullDesC8 )

        {

        // copy phoneme sequence

        iPhonemeSequence = HBufC8::NewL( aPhonemeSequence.Length() );

        TPtr8 tempPtr8( iPhonemeSequence->Des() );

        tempPtr8 = aPhonemeSequence;

        }

    if ( aPhonemeNotation != KNullDesC )

        {

        // copy phoneme notation 

        iPhonemeNotation = HBufC::NewL( aPhonemeNotation.Length() );

        TPtr tempPtr( iPhonemeNotation->Des() );

        tempPtr = aPhonemeNotation;

        }

    }

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

// CTtsParsedTextBody::NewL

// Two-phased constructor.

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

//

CTtsParsedTextBody* CTtsParsedTextBody::NewL(

    const TDesC& aText, 

    const TDesC8& aPhonemeSequence, 

    const TDesC& aPhonemeNotation )

    {

    CTtsParsedTextBody* self = new( ELeave ) CTtsParsedTextBody;

    CleanupStack::PushL( self );

    self->ConstructL( aText, 

                      aPhonemeSequence, 

                      aPhonemeNotation );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CTtsParsedTextBody::~CTtsParsedTextBody()

    {

    delete iText;

    delete iPhonemeSequence;

    delete iPhonemeNotation;

    iSegmentArray.Reset();

    }

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

// CTtsParsedTextBody::AddSegmentL

// Add new segment to array

// (other items were commented in a header).

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

//

void CTtsParsedTextBody::AddSegmentL( 

    const TTtsSegment& aSegment,

    TInt aIndex )

    {

    if ( aIndex < 0  )

        {

        User::Leave( KErrArgument ); // The index is negative

        }

    else if ( aIndex >= iSegmentArray.Count() )

        {

        // added to end

        User::LeaveIfError( iSegmentArray.Append( aSegment ) );

        }

    else

        {

        // added into middle

        User::LeaveIfError( iSegmentArray.Insert( aSegment, aIndex ) );

        }

    }

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

// CTtsParsedTextBody::DeleteSegment

// Delete segment

// (other items were commented in a header).

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

//

void CTtsParsedTextBody::DeleteSegmentL( 

    TInt aIndex )

    {

    if ( aIndex < 0 || aIndex >= iSegmentArray.Count() )

        {

        User::Leave( KErrArgument ); // The index is out of bounds.

        }

    iSegmentArray.Remove( aIndex );

    }

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

// CTtsParsedTextBody::IsValid

// Checks that segments do not overlap or pointer outside.

// (other items were commented in a header).

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

//

TInt CTtsParsedTextBody::IsValid() const

    {

    TInt index( 0 );

    if ( iPhonemeSequence == NULL &&

        iText == NULL &&

        iSegmentArray.Count() > 0 )

        {

        // no phoneme sequence and no text but segments still exist

        return EFalse;

        }

    // check phoneme sequence part 

    if ( iPhonemeSequence )

        {

        const TUint8* beginPhSeqPtr = iPhonemeSequence->Ptr();

        const TUint8* endPhSeqPtr = iPhonemeSequence->Ptr() 

            + iPhonemeSequence->Length() - 1;   

        for ( index = 0; index < iSegmentArray.Count(); index++ )

            {

            // check that pointers do not point outside

            const TTtsSegment& segment = iSegmentArray[index];

            const TDesC8& phSeq = segment.PhonemeSequencePtr();

            if ( phSeq != KNullDesC8 )

                {

                const TUint8* phSeqPtr = phSeq.Ptr();

                if ( phSeqPtr < beginPhSeqPtr || 

                    phSeqPtr > endPhSeqPtr ||

                    phSeqPtr + phSeq.Length() - 1 > endPhSeqPtr )

                    {

                    return EFalse;

                    }

                // check order and overlapping

                if ( index > 0 )

                    {

                    const TDesC8& prevPhSeq

                        = iSegmentArray[index - 1].PhonemeSequencePtr();

                    if ( prevPhSeq == KNullDesC8 )

                        {

                        // all pointer must point to either null or valid data

                        return EFalse;

                        }

                    const TUint8* prevEndPhSeqPtr 

                        = prevPhSeq.Ptr() + prevPhSeq.Length() - 1;    

                    if ( prevEndPhSeqPtr >= phSeqPtr )

                        {

                        return EFalse;

                        }

                    }

                }

            }

        }

    // check phoneme sequence part 

    if ( iText )

        {

        const TUint16* beginTextPtr = iText->Ptr();

        const TUint16* endTextPtr = iText->Ptr() + iText->Length() - 1;

        for ( index = 0; index < iSegmentArray.Count(); index++ )

            {

            // check that pointers do not point outside

            const TTtsSegment& segment = iSegmentArray[index];

            const TDesC& text = segment.TextPtr();

            if ( text != KNullDesC )

                {

                const TUint16* textPtr = text.Ptr();

                if ( textPtr < beginTextPtr || 

                    textPtr > endTextPtr ||

                    textPtr + text.Length() - 1 > endTextPtr )

                    {

                    return EFalse;

                    }

                // check order and overlapping

                if ( index > 0 )

                    {

                    const TDesC& prevText = iSegmentArray[index - 1].TextPtr();

                    if ( prevText == KNullDesC )

                        {

                        // all pointer must point to either null or valid data

                        return EFalse;

                        }

                    const TUint16* prevEndTextPtr 

                        = prevText.Ptr() + prevText.Length() - 1;    

                    if ( prevEndTextPtr >= textPtr )

                        {

                        return EFalse;

                        }

                    }

                }

            }

        }

    // all checks passed

    return ETrue;

    }

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

// CTtsParsedTextBody::NumberOfSegments

// Return number of segments

// (other items were commented in a header).

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

//

TInt CTtsParsedTextBody::NumberOfSegments() const

    {

    return iSegmentArray.Count();

    }

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

// CTtsParsedTextBody::PhonemeNotation

// Returns phoneme notation

// (other items were commented in a header).

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

//

const TDesC& CTtsParsedTextBody::PhonemeNotation() const

    {

    if ( iPhonemeNotation )

        {

        // Phoneme sequence has been set

        return *iPhonemeNotation;

        }

    return KNullDesC;   

    }

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

// CTtsParsedTextBody::PhonemeSequence

// Returns phoneme sequence

// (other items were commented in a header).

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

//

const TDesC8& CTtsParsedTextBody::PhonemeSequence() const

    {

    if ( iPhonemeSequence )

        {

        // Phoneme sequence has been set

        return *iPhonemeSequence;

        }

    return KNullDesC8;

    }

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

// CTtsParsedTextBody::SegmentL

// Returns segment of given index

// (other items were commented in a header).

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

//

const TTtsSegment& CTtsParsedTextBody::SegmentL( 

    TInt aIndex ) const

    {

    if ( aIndex < 0 || aIndex >= iSegmentArray.Count() )

        {

        User::Leave( KErrArgument );

        }

    return iSegmentArray[aIndex];

    }

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

// CTtsParsedTextBody::SetPhonemeNotationL

// Sets phoneme notation

// (other items were commented in a header).

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

//

void CTtsParsedTextBody::SetPhonemeNotationL( 

    const TDesC& aPhonemeNotation )

    {

    if ( !iPhonemeNotation )

        {

        // copy phoneme notation 

        iPhonemeNotation = HBufC::NewL( aPhonemeNotation.Length() );

        TPtr tempPtr( iPhonemeNotation->Des() );

        tempPtr = aPhonemeNotation;

        }   

    else

        {

        TPtr bufferPtr( iPhonemeNotation->Des() );

        if ( aPhonemeNotation.Length() > bufferPtr.MaxLength() )

            {

            // new buffer does not fit into old one

            iPhonemeNotation->ReAllocL( aPhonemeNotation.Length() );   

            bufferPtr.Set( iPhonemeNotation->Des() );

            }

        bufferPtr = aPhonemeNotation;

        }

    }

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

// CTtsParsedTextBody::SetPhonemeSequenceL

// Sets phoneme sequence

// (other items were commented in a header).

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

//

void CTtsParsedTextBody::SetPhonemeSequenceL( 

    const TDesC8& aPhonemeSequence )

    {

    if ( !iPhonemeSequence )

        {

        // create new phoneme sequence

        iPhonemeSequence = HBufC8::NewL( aPhonemeSequence.Length() );

        TPtr8 tempPtr8( iPhonemeSequence->Des() );

        tempPtr8 = aPhonemeSequence;

        }

    else

        {

        TPtr8 bufferPtr( iPhonemeSequence->Des() );

        if ( aPhonemeSequence.Length() > bufferPtr.MaxLength() )

            {

            // new buffer does not fit into old one

            iPhonemeSequence = iPhonemeSequence->ReAllocL( aPhonemeSequence.Length() );

            bufferPtr.Set( iPhonemeSequence->Des() );

            }

        bufferPtr = aPhonemeSequence;

        }

    }

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

// CTtsParsedTextBody::SetTextL

// Sets text

// (other items were commented in a header).

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

//

void CTtsParsedTextBody::SetTextL( 

    const TDesC& aText )

    {

    if ( !iText )

        {

        // create new text 

        iText = HBufC::NewL( aText.Length() );

        TPtr tempPtr( iText->Des() );

        tempPtr = aText;

        }

    else 

        {

        TPtr bufferPtr( iText->Des() );

        if ( aText.Length() > bufferPtr.MaxLength() )

            {

            // new buffer does not fit into old one

            iText = iText->ReAllocL( aText.Length() ); 

            bufferPtr.Set( iText->Des() );

            }

        bufferPtr = aText;

        }

    }

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

// CTtsParsedTextBody::Text

// Returns text

// (other items were commented in a header).

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

//

const TDesC& CTtsParsedTextBody::Text() const

    {

    if ( iText )

        {

        // text has been set

        return *iText;

        }

    return KNullDesC;

    }

//  End of File