/*

* Copyright (c) 2006-2007 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:  

*

*/

// INCLUDE FILES

#include "vuicttsplayer.h"

#include "rubydebug.h"

// CONSTANTS

const TInt KMaxBasicSegments = 3;

const TInt KMaxEnhancedSegments = 3;

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

// CTTSPlayer::NewL

// Two-phased constructor.

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

//

CTTSPlayer* CTTSPlayer::NewL( MTtsClientUtilityObserver* aObserver )

    {

    CTTSPlayer* self = new (ELeave) CTTSPlayer( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }   

// Destructor       

CTTSPlayer::~CTTSPlayer()

    {

    RUBY_DEBUG0( "CTTSPlayer::~CTTSPlayer START" );

    Stop();

    RUBY_DEBUG0( "CTTSPlayer::~CTTSPlayer EXIT" );

    }

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

// CTTSPlayer::PlayL

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

//      

void CTTSPlayer::PlayL( const TDesC& aText, TInt aPosition,

                        TInt aMaxLength, const TDesC& aSegment )

    {

    RUBY_DEBUG_BLOCK( "CTTSPlayer::PlayL" );

    Stop();

    CreateSegmentsL( aText, aPosition, aMaxLength, aSegment );

    iTtsData->iParsedText->SetTextL( aText );

    // Opens and plays the parsed text

    iTtsData->iTts->OpenAndPlayParsedTextL( *iTtsData->iParsedText );    

    }

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

// CTTSPlayer::PlayL

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

//      

void CTTSPlayer::PlayL( const TDesC& aText, TInt aPosition,

                        TInt aMaxLength, const TDesC& aSegment,

                        const TDesC& aNewSegment1, const TDesC& aNewSegment2,

                        const TDesC& aNewSegment3  )

    {

    RUBY_DEBUG_BLOCK( "CTTSPlayer::PlayL" );

    Stop();

    HBufC* text = HBufC::NewLC( aText.Length() + aNewSegment1.Length() +

                                aNewSegment2.Length() + aNewSegment3.Length() );

    TPtr textPtr = text->Des();

    textPtr.Append( aText );

    CreateSegmentsL( *text, aPosition, aMaxLength, aSegment );

    for ( int i = KMaxBasicSegments; i < KMaxBasicSegments + KMaxEnhancedSegments; ++i )

        {

        iTtsData->iStyle[i] = new (ELeave) TTtsStyle();

        iTtsData->iStyleId[i] = new (ELeave) TTtsStyleID( 0 );

        iTtsData->iSegment[i] = new (ELeave) TTtsSegment( 0 );

        iTtsData->iStyle[i]->iLanguage = User::Language();

        *(iTtsData->iStyleId[i]) = iTtsData->iTts->AddStyleL( *(iTtsData->iStyle[i]) );

        iTtsData->iSegment[i]->SetStyleID( *(iTtsData->iStyleId[i]) );

        }

    TInt location = KErrNone;

    textPtr.Append( aNewSegment1 );

    iTtsData->iSegment[3]->SetTextPtr( text->Mid( location, aNewSegment1.Length() ) );

    iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[3]) );

    if ( aNewSegment2 != KNullDesC )

        {

        location = text->Length();

        textPtr.Append( aNewSegment2 );

        iTtsData->iSegment[4]->SetTextPtr( text->Mid( location, aNewSegment2.Length() ) );

        iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[4]) );

        }

    if ( aNewSegment3 != KNullDesC )

        {

        location = text->Length();

        textPtr.Append( aNewSegment3 );

        iTtsData->iSegment[5]->SetTextPtr( text->Mid( location, aNewSegment3.Length() ) );

        iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[5]) );

        }

    iTtsData->iParsedText->SetTextL( *text );

    // Opens and plays the parsed text

    iTtsData->iTts->OpenAndPlayParsedTextL( *iTtsData->iParsedText );

    CleanupStack::PopAndDestroy( text );

    }

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

// CTTSPlayer::Stop

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

//          

void CTTSPlayer::Stop()

    {

    RUBY_DEBUG0( "CTTSPlayer::Stop START" );

    if ( iTtsData )

        {

        if ( iTtsData->iTts )

            {

            iTtsData->iTts->Stop();

            iTtsData->iTts->Close();

            }

        delete iTtsData->iParsedText;

        iTtsData->iParsedText = NULL;

        delete iTtsData->iTts;

        iTtsData->iTts = NULL;

        for ( int i = 0; i < KMaxSegments; ++i )

            {

            delete iTtsData->iStyle[i];

            delete iTtsData->iStyleId[i];

            delete iTtsData->iSegment[i];

            }

        delete iTtsData;

        iTtsData = NULL;

        }

    RUBY_DEBUG0( "CTTSPlayer::Stop EXIT" );  

    }

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

// CTTSPlayer::CTTSPlayer

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

//              

CTTSPlayer::CTTSPlayer( MTtsClientUtilityObserver* aObserver )

 : iObserver( aObserver )

    {

    }

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

// CTTSPlayer::ConstructL

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

//           

void CTTSPlayer::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CTTSPlayer::ConstructL" );

    }

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

// CTTSPlayer::CreateSegmentsL

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

//      

void CTTSPlayer::CreateSegmentsL( const TDesC& aText, TInt aPosition,

                                  TInt aMaxLength, const TDesC& aSegment )

    {

    RUBY_DEBUG_BLOCK( "CTTSPlayer::CreateSegmentsL" );

    TInt leftLength = aText.Length();

    TInt midLength = KErrNone;

    TInt rightLength = KErrNone;

    TInt location = KErrNotFound;    

    if ( aSegment != KNullDesC )

        {

        location = aText.Right( aText.Length() - aPosition ).FindC( aSegment ) + aPosition;

        if ( location != aPosition )

            {

            location = aPosition + aMaxLength - aSegment.Length();

            }

        // Calculate segment lengths

        if ( location == KErrNone )

            {

            leftLength = aSegment.Length();

            rightLength = aText.Length() - aSegment.Length();

            }

        else if ( location + aSegment.Length() < aText.Length() )

            {

            leftLength = location;

            midLength = aSegment.Length();

            rightLength = aText.Length() - location - aSegment.Length();

            }

        else if ( location != KErrNotFound )

            {

            leftLength = aText.Length() - aSegment.Length();

            rightLength = aSegment.Length();

            }

        }

    iTtsData = new (ELeave) TTtsData;

    iTtsData->iTts = CTtsUtility::NewL( *iObserver );

    iTtsData->iParsedText = CTtsParsedText::NewL();

    for ( int i = 0; i < KMaxBasicSegments; ++i )

        {

        iTtsData->iStyle[i] = new (ELeave) TTtsStyle();

        iTtsData->iStyleId[i] = new (ELeave) TTtsStyleID( 0 );

        iTtsData->iSegment[i] = new (ELeave) TTtsSegment( 0 );

        iTtsData->iStyle[i]->iLanguage = User::Language();

        *(iTtsData->iStyleId[i]) = iTtsData->iTts->AddStyleL( *(iTtsData->iStyle[i]) );

        iTtsData->iSegment[i]->SetStyleID( *(iTtsData->iStyleId[i]) );

        }

    // Create segments

    iTtsData->iSegment[0]->SetTextPtr( aText.Left( leftLength ) );

    iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[0]) );

    if ( midLength != KErrNone )

        {

        iTtsData->iSegment[1]->SetTextPtr( aText.Mid( location, midLength ) );

        iTtsData->iSegment[2]->SetTextPtr( aText.Right( rightLength ) );

        iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[1]) );

        iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[2]) );

        }

    else if ( rightLength != KErrNone )

        {

        iTtsData->iSegment[1]->SetTextPtr( aText.Right( rightLength ) );

        iTtsData->iParsedText->AddSegmentL( *(iTtsData->iSegment[1]) );

        }

    }

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

// CTTSPlayer::TTtsData

// Initializes everything to zero.

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

//

CTTSPlayer::TTtsData::TTtsData() 

 : iTts( NULL ), iParsedText( NULL )

    {

    for ( int i = 0; i < KMaxSegments; ++i )

        {

        iStyle[i] = NULL;

        iStyleId[i] = NULL;

        iSegment[i] = NULL;

        }

    }

// End of File