/*

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

*       Defines implementation of CUniSlideLoader class methods.

*

*/

// INCLUDE FILES

#include "UniSlideLoader.h"

#include <mtclbase.h>

#include <eikrted.h>

#include <data_caging_path_literals.hrh> 

#include <barsread.h>

#include <AknUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <AknsConstants.h>

#include <AknBitmapAnimation.h>

#include <AudioPreference.h>

#include <MsgEditorView.h>

#include <MsgEditorCommon.h>

#include <MsgBaseControl.h>

#include <MsgBodyControl.h>

#include <msgasynccontrol.h>

#include <msgxhtmlbodycontrol.h>

#include <MsgMediaInfo.h>

#include <MsgMimeTypes.h>

#include <fileprotectionresolver.h>

#include <DRMCommon.h>

#include <DRMNotifier.h>

#include <mmsconst.h>

#include <uniutils.mbg>

#include <UniUtils.rsg>

#include <uniobject.h>

#include <unidatamodel.h>

#include <unimodelconst.h>

#include <unimimeinfo.h>

#include <unidrminfo.h>

#include <unitextobject.h>

#include <msgmediacontrol.h>

#include <msgaudiocontrol.h>

#include <msgimagecontrol.h>

#include <msgvideocontrol.h>

#ifdef RD_SVGT_IN_MESSAGING

#include <msgsvgcontrol.h>

#endif

#include "UniUtils.h"

#include "UniEditorLogging.h"

// ==========================================================

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KViewerAnimationLoopCount = -1;

const TInt KEditorAnimationLoopCount = 1;

// MACROS

// LOCAL CONSTANTS AND MACROS

enum TUniIconType

    {

    EUniIconNoRightsSendable,     // no rights and can be sent

    EUniIconNoRightsNotSendable,  // no rights but cannot be sent

    EUniIconDrmSendable,          // drm protected content and can be sent

    EUniIconDrmNotSendable,        // drm protected content and cannot be sent

    EUniIconCorrupted

    };

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// CUniSlideLoader::CUniSlideLoader

//

// Constructor.

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

//

CUniSlideLoader::CUniSlideLoader(   MUniObjectObserver*         aUniObjectObserver,

                                    MMsgAsyncControlObserver& aControlObserver,

                                    CUniDataModel& aDataModel,

                                    CMsgEditorView& aView,

                                    TUniControlMode aControlMode ) : 

    CActive( EPriorityStandard ),

    iControlObserver( aControlObserver ),

    iDataModel( aDataModel ),

    iView( aView ),

    iControlMode( aControlMode ),

    iResourceLoader( *iView.ControlEnv() ),

    iUniObjectObserver ( aUniObjectObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CUniSlideLoader::ConstructL

//

//

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

//

void CUniSlideLoader::ConstructL()

    {

    if ( !iView.ControlEnv()->IsResourceAvailableL( R_UNUT_EDITOR_WAIT_ANIM ) )

        {

        TParse parse;

        parse.Set( KUniUtilsResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );

        TFileName fileName( parse.FullName() );

        iResourceLoader.OpenL( fileName );

        }

    }

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

// CUniSlideLoader::NewL

//

// Two-phased constructor.

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

//

EXPORT_C CUniSlideLoader* CUniSlideLoader::NewL(

        MMsgAsyncControlObserver& aControlObserver,

        CUniDataModel& aDataModel,

        CMsgEditorView& aView,

        TUniControlMode aControlMode )

    {

    return CUniSlideLoader::NewL( NULL, aControlObserver, aDataModel, aView, aControlMode );

    }

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

// CUniSlideLoader::NewL

//

// Two-phased constructor.

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

//

EXPORT_C CUniSlideLoader* CUniSlideLoader::NewL(

        MUniObjectObserver*         aUniObjectObserver,                            

        MMsgAsyncControlObserver&   aControlObserver,

        CUniDataModel&              aDataModel,

        CMsgEditorView&             aView,

        TUniControlMode             aControlMode )

    {

    CUniSlideLoader* self = new ( ELeave ) CUniSlideLoader( aUniObjectObserver,

                                                            aControlObserver, 

                                                            aDataModel, 

                                                            aView, 

                                                            aControlMode );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CUniSlideLoader::~CUniSlideLoader

//

// Destructor

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

//

CUniSlideLoader::~CUniSlideLoader()

    {

    Cancel();

    iResourceLoader.Close();

    RemoveObservers( );

    }

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

// CUniSlideLoader::LoadSlideL

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

EXPORT_C void CUniSlideLoader::LoadSlideL(

        MUniSlideLoaderObserver& aSlideObserver,

        TInt aSlideNum )

    {

    TInt slideCount = iDataModel.SmilModel().SlideCount();

    if ( slideCount && 

        ( aSlideNum < 0 || aSlideNum >= slideCount ) )

        {

        User::Leave( KErrArgument );

        }

    iSlideObserver = &aSlideObserver;

    iLoadedSlide = aSlideNum;

    iObjectNum = 0;

    iOperation = ELoadSlide;

    iError = KErrNone;

    CompleteSelf();

    }

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

// CUniSlideLoader::LoadObject

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

//

EXPORT_C void CUniSlideLoader::LoadObject( 

        MUniSlideLoaderObserver& aSlideObserver,

        CUniObject* aObject )

    {

    iSlideObserver = &aSlideObserver;

    iOperation = ELoadObject;

    iObjectNum = 1;

    iLoadedObject = aObject;

    iError = KErrNone;

    CompleteSelf();

    }

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

// CUniSlideLoader::ResetViewL

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

//

EXPORT_C void CUniSlideLoader::ResetViewL()

    {

    RemoveObservers( );

    // remove control from message text object

    CUniObject* obj = iDataModel.SmilModel().GetObject( iLoadedSlide, EUniRegionText );

    if ( obj && 

         ( obj->MediaType() == EMsgMediaText ||

           obj->MediaType() == EMsgMediaXhtml ) )

        {

        static_cast<CUniTextObject*>( obj )->SetText( NULL );

        }

    iView.DeleteControlL( EMsgComponentIdBody );

    iView.DeleteControlL( EMsgComponentIdImage );

    iView.DeleteControlL( EMsgComponentIdVideo );

    iView.DeleteControlL( EMsgComponentIdAudio );

#ifdef RD_SVGT_IN_MESSAGING     

    iView.DeleteControlL( EMsgComponentIdSvg );

#endif    

    }

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

// CUniSlideLoader::DoCancel

//

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

//

void CUniSlideLoader::DoCancel()

    {

    iSlideObserver->SlideLoadReady( KErrCancel );

    }

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

// CUniSlideLoader::RunL

//

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

//

void CUniSlideLoader::RunL()

    {

    if ( iOperation == ELoadSlide )

        {

        LoadSlideStepL();

        }

    else

        {

        LoadObjectStepL();

        }

    }

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

// CUniSlideLoader::RunError

//

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

//

TInt CUniSlideLoader::RunError( TInt aError )

    {

    iError = aError;

    CompleteSelf();

    return KErrNone;

    }

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

// CUniSlideLoader::CompleteSelf

//

// Completes current step of state machine

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

//

void CUniSlideLoader::CompleteSelf()

    {

    iStatus = KRequestPending;

    TRequestStatus* pStatus = &iStatus;

    SetActive();

    User::RequestComplete( pStatus, KErrNone );

    }

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

// CUniSlideLoader::SetSlideStepL

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

//

void CUniSlideLoader::LoadSlideStepL()

    {

    CUniObject* obj = iDataModel.SmilModel().GetObjectByIndex( iLoadedSlide, iObjectNum );

    // must be set before leaving

    iObjectNum++;

    if ( obj )

        {

        LoadObjectL( obj );

        }

    else

        {

        if (!iDataModel.SmilModel().GetObject( iLoadedSlide, EUniRegionText ) )

            {

            // Add empty text control

            LoadTextL( NULL );

            }

        iSlideObserver->SlideLoadReady( iError );

        }

    }

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

// CUniSlideLoader::SetObjectStepL

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

//

void CUniSlideLoader::LoadObjectStepL()

    {

    if ( iObjectNum )

        {

        // must be set before leaving

        iObjectNum--;

        LoadObjectL( iLoadedObject );

        }

    else

        {

        iSlideObserver->SlideLoadReady( iError );

        }

    }

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

// CUniSlideLoader::LoadObjectL

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

//

void CUniSlideLoader::LoadObjectL( CUniObject* aObject )

    {

    switch ( aObject->Region() )

        {

        case EUniRegionText:

            {

            LoadTextL( aObject );

            break;

            }

        case EUniRegionImage:

            {

            if ( aObject->MediaType() == EMsgMediaVideo ||

                 aObject->MediaTypeBySmilTag() == EMsgMediaVideo ) 

                {

                LoadVideoL( aObject );

                }

#ifdef RD_SVGT_IN_MESSAGING

            else if ( aObject->MediaType() == EMsgMediaSvg ||

                     aObject->MediaTypeBySmilTag() == EMsgMediaSvg )

                {

                LoadSvgL( aObject );

                }

#endif                

            else

                {

                LoadImageL( aObject );

                }

            break;

            }

        case EUniRegionAudio:

            {

            LoadAudioL( aObject );

            break;

            }

        case EUniRegionUnresolved:

        default:

            {

            break;

            }

        }

    if ( iStatus != KRequestPending )

        {

        CompleteSelf();

        }

    }

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

// CUniSlideLoader::LoadTextL

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

//

void CUniSlideLoader::LoadTextL( CUniObject* aObject )

    {

    if ( aObject && 

         aObject->MediaType() == EMsgMediaXhtml )

        {

        CMsgXhtmlBodyControl* textControl = CMsgXhtmlBodyControl::NewL( iView, this );

        CleanupStack::PushL( textControl );

        LoadControlL( *textControl, aObject );

        AddToViewL( textControl, EMsgComponentIdBody, EMsgMediaXhtml, aObject );

        CleanupStack::Pop( textControl );

        CUniTextObject* obj = static_cast<CUniTextObject*>( aObject );

        obj->SetText( &( textControl->Editor() ) );

        SetActive();

        iStatus= KRequestPending;

        }

    else

        {

        CMsgBodyControl* textControl = CMsgBodyControl::NewL( &iView );

        CleanupStack::PushL( textControl );

        textControl->SetControlId( EMsgComponentIdBody );

        if ( aObject )

            {        

            TUint attaCharset = aObject->MimeInfo()->Charset();

            if ( !attaCharset )

                {

                //assume US-ASCII - mandated by RFC 2046

                attaCharset = KMmsUsAscii;

                }

            TUint charconvCharsetID = 0;

            charconvCharsetID = iDataModel.DataUtils().MibIdToCharconvIdL( attaCharset );

            RFile file = CUniDataUtils::GetAttachmentFileL( iDataModel.Mtm(), aObject->AttachmentId() );

            CleanupClosePushL( file );

            RFileReadStream stream( file );

            CleanupClosePushL( stream );

            CPlainText::TImportExportParam param;

            param.iForeignEncoding = charconvCharsetID;

            param.iOrganisation = CPlainText::EOrganiseByParagraph; 

            CPlainText::TImportExportResult result;

            TRAPD( err, textControl->Editor().Text()->ImportTextL( 0, stream, param, result ) );

            if ( err != KErrNone )

                {

                textControl->Reset();

                User::Leave( err );

                }

            CleanupStack::PopAndDestroy( 2, &file );

            CUniTextObject* obj = static_cast<CUniTextObject*>( aObject );

            obj->SetText( &( textControl->Editor() ) );

            }

        else 

            {

            if ( iDataModel.Mtm().Body().DocumentLength() > 0 )

                {

                TRAPD( err, 

                       {

                       textControl->SetTextContentL( iDataModel.Mtm().Body() );

                       if ( !iDataModel.SmilModel().IsSlide( 0 ) )

                           {

                           // Add slide

                           iDataModel.SmilModel().AddSlideL( 0 );

                           }

                       iDataModel.SmilModel().AddTextObjectL( 0, &( textControl->Editor() ) );

                       } );

                if ( err != KErrNone )

                    {

                    textControl->Reset();

                    User::Leave( err );

                    }

                iDataModel.Mtm().Body().Reset();

                }

            }

        AddToViewL( textControl, EMsgComponentIdBody, EMsgMediaText, aObject );

        CleanupStack::Pop( textControl );

        }

    }

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

// CUniSlideLoader::LoadImageL

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

//

void CUniSlideLoader::LoadImageL( CUniObject* aObject )

    {

    CMsgImageControl* imageControl = CMsgImageControl::NewL( iView, this );

    CleanupStack::PushL( imageControl );

    if ( LoadControlL( *imageControl, aObject ) &&

         ConsumeDrmRights( aObject ) )

        {

        if ( iControlMode == EUniControlViewerMode )

            {

            imageControl->SetAnimationLoopCount( KViewerAnimationLoopCount );

            }

        else

            {

            imageControl->SetAnimationLoopCount( KEditorAnimationLoopCount );

            }

        imageControl->PlayL();    

        }

    UpdateControlIconL( *imageControl, aObject );