/*

* 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:   CUniEditorInsertOperation.

*

*/

// ========== INCLUDE FILES ================================

#include <apmstd.h>

#include <mmsconst.h>

#include <MmsConformance.h>

#include <MsgMediaInfo.h>

#include <MsgImageInfo.h>

#include <MsgVideoInfo.h>

#include <MsgMimeTypes.h>

#include <msgimagecontrol.h>

#include <msgvideocontrol.h>

// DRM

#include <fileprotectionresolver.h>

#include "unislideloader.h"

#include "UniClientMtm.h"

#include "UniEditorEnum.h"

#include "UniEditorDocument.h"

#include "UniEditorProcessImageOperation.h"

#include "UniEditorChangeSlideOperation.h"

#include "UniEditorConvertVideoOperation.h"

#include "UniEditorInsertOperation.h"

// ========== CONSTANTS ====================================

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

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

// CUniEditorInsertOperation::NewL

//

// Two-phased constructor.

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

//

CUniEditorInsertOperation* CUniEditorInsertOperation::NewL( 

        MUniEditorOperationObserver& aOperationObserver,

        CUniEditorDocument& aDocument,

        CUniEditorHeader& aHeader,

        CUniSlideLoader& aSlideLoader,

        CMsgEditorView& aView,

        RFs& aFs )

    {

    CUniEditorInsertOperation* self = new ( ELeave ) CUniEditorInsertOperation(

            aOperationObserver,

            aDocument,

            aHeader,

            aSlideLoader,

            aView,

            aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUniEditorInsertOperation::CUniEditorInsertOperation

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

//

CUniEditorInsertOperation::CUniEditorInsertOperation(

        MUniEditorOperationObserver& aOperationObserver,

        CUniEditorDocument& aDocument,

        CUniEditorHeader& aHeader,

        CUniSlideLoader& aSlideLoader,

        CMsgEditorView& aView,

        RFs& aFs ) :

    CUniEditorOperation( aOperationObserver, aDocument, aFs, EUniEditorOperationInsert ),

    iHeader( aHeader ),

    iSlideLoader( aSlideLoader ),

    iView( aView ),

    iInsertedSlide( -1 ),

    iPreviousSlide( -1 )

    {

    }

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

// CUniEditorInsertOperation::ConstructL

// 2nd phase constructor

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

//

void CUniEditorInsertOperation::ConstructL()

    {

    BaseConstructL();

    }

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

// CUniEditorInsertOperation::~CUniEditorInsertOperation

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

//

CUniEditorInsertOperation::~CUniEditorInsertOperation()

    {

    Cancel();

    delete iOldInfo;

    delete iNewInfo;

    delete iImageOperation;

    delete iVideoOperation;

    delete iChangeSlideOperation;

    }

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

// CUniEditorInsertOperation::Insert

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

//

void CUniEditorInsertOperation::Insert( CMsgMediaInfo* aInfo, 

                                        TBool aAddSlide, 

                                        TBool aAddAsAttachment )

    {

    ResetErrors();

    iInsertedSlide = -1;

    iInsertedObject = NULL;

    iOldInfo = aInfo;

    iAddSlide = aAddSlide;

    if ( aInfo &&

         aInfo->Protection() & EFileProtDrm2 )

        {

        // DRM 2 content is always added as an attachment.

        iAddAsAttachment = ETrue;

        }

    else

        {

        iAddAsAttachment = aAddAsAttachment;

        }   

    //Coverty fix : Forward Null http://ousrv057/cov.cgi?cid=35696

    if ( aInfo && aInfo->MediaType() == EMsgMediaImage )

        {

        iOperationState = EUniInsertCheckMode;

        }

    else if ( aInfo && aInfo->MimeType() == KMsgMimeVideoMp4 )

        {

        iOperationState = EUniInsertConvertVideo;

        }

    else    

        {

        iOperationState = EUniInsertCopyAttachment;

        }

    CompleteSelf( KErrNone );

    }

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

// CUniEditorInsertOperation::RunL

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

//

void CUniEditorInsertOperation::RunL()

    {

    PrintOperationAndState();

    if ( iStatus.Int() != KErrNone )

        {

        SetError( iStatus.Int() );

        iOperationState = EUniInsertError;

        }

    switch ( iOperationState )

        {

        case EUniInsertCheckMode:

            {

            DoCheckModeL();

            break;

            }

        case EUniInsertProcessImage:

            {

            DoStartProcessImageL();

            break;

            }

       case EUniInsertConvertVideo:

            {

            DoStartConvertVideoL();

            break;    

            }

        case EUniInsertCheckSize:

            {

            DoCheckSizeL();

            break;

            }

        case EUniInsertCopyAttachment:

            {

            iObserver.EditorOperationEvent( EUniEditorOperationInsert,

                                            EUniEditorOperationProcessing );

            DoStartCopyAttachmentL();

            break;

            }

        case EUniInsertLoad:

            {

            DoStartLoadL();

            break;

            }

        case EUniInsertReady:

            {

            iObserver.EditorOperationEvent( EUniEditorOperationInsert,

                                            EUniEditorOperationComplete );

            break;

            }

        case EUniInsertError:

            {

            DoErrorWithoutStateChangeL();

            break;

            }

        case EUniInsertErrorReload:

            {

            DoStartReloadL();

            break;

            }

        case EUniInsertErrorReport:

            {

            iObserver.EditorOperationEvent( EUniEditorOperationInsert,

                                            EUniEditorOperationError );

            break;

            }

        default:

            {

            SetError( KErrUnknown );

            iObserver.EditorOperationEvent( EUniEditorOperationInsert,

                                            EUniEditorOperationError );

            break;

            }

        }

    }

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

// CUniEditorInsertOperation::DoCancelCleanup

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

//

void CUniEditorInsertOperation::DoCancelCleanup()

    {

    if ( iImageOperation )

        {

        iImageOperation->Cancel();

        }

    if ( iVideoOperation )

        {

        iVideoOperation->Cancel();

        }    

    if ( iInsertedObject )

        {

        iInsertedObject->Cancel();

        }

    if ( iChangeSlideOperation )

        {

        iChangeSlideOperation->Cancel();

        }

    iSlideLoader.Cancel();

    }

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

// CUniEditorInsertOperation::DoStartProcessImageL

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

//

void CUniEditorInsertOperation::DoStartProcessImageL()

    {

    if ( iAddSlide )

        {

        // If there is an image with same name added on the current slide, it must be closed that

        // inserting would succeed. Insert attachment fails in Symbian messaging otherwise.

        // If error occurs after this, current slide must be realoded again

        CMsgImageControl* imageControl= static_cast<CMsgImageControl*> ( iView.ControlById( EMsgComponentIdImage ) );

        if ( imageControl )

            {

            imageControl->SetImageFileClosed();

            }

        }

    if ( !iImageOperation )

        {

        iImageOperation = CUniEditorProcessImageOperation::NewL( *this, iDocument, iFs );

        }

    iImageOperation->Process( static_cast<CMsgImageInfo*>( iOldInfo ), KMsvNullIndexEntryId, iDocument.MessageSize( ETrue ) );

    SetPending();

    }

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

// CUniEditorInsertOperation::DoStartConvertVideoL

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

//

void CUniEditorInsertOperation::DoStartConvertVideoL()

    {

    if ( CUniEditorConvertVideoOperation::IsImplementedL() )

        {

        if ( !iVideoOperation )

            {

            iVideoOperation = CUniEditorConvertVideoOperation::NewL( *this, iDocument, iFs );

            }

        iVideoOperation->Process( static_cast<CMsgVideoInfo*>( iOldInfo ), KMsvNullIndexEntryId, iDocument.MaxMessageSize() );   

        SetPending();

        }

    else

        {

        iOperationState = EUniInsertCopyAttachment;

        CompleteSelf( KErrNone );

        }

    }

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

// CUniEditorInsertOperation::DoStartCopyAttachmentL

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

//

void CUniEditorInsertOperation::DoStartCopyAttachmentL()

    {

    TInt slide = iDocument.CurrentSlide();

    if ( iAddSlide )

        {

        iPreviousSlide = slide;

        slide++;

        iDocument.DataModel()->SmilModel().AddSlideL( slide );

        iInsertedSlide = slide;

        }   

    if ( iNewInfo )

        {

        TMsvAttachmentId attaId;

        if ( iImageOperation )

            {

            iImageOperation->DetachAttachmentId( attaId );

            }

        else

            {

            iVideoOperation->DetachAttachmentId( attaId );

            }

        if ( iAddAsAttachment )

            {

            iInsertedObject = iDocument.DataModel()->AddStoredAttachmentL( attaId, iNewInfo );

            }

        else

            {

            iInsertedObject = iDocument.DataModel()->SmilModel().AddStoredObjectL( slide, attaId, iNewInfo );

            }

        iNewInfo = NULL;

        CompleteSelf( KErrNone );        

        }

    else

        {

        if ( iAddAsAttachment )

            {

            iInsertedObject = iDocument.DataModel()->AddAttachmentL( *this, iOldInfo );            

            }

        else

            {

            iInsertedObject = iDocument.DataModel()->SmilModel().AddObjectL( *this, slide, iOldInfo );

            }

        iOldInfo = NULL; // Ownership transferred

        SetPending();

        }

    if ( iAddAsAttachment )

        {

        iOperationState = EUniInsertReady;

        }

    else

        {

        iDocument.SetBodyModified( ETrue );

        iOperationState = EUniInsertLoad;

        }

    }

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

// CUniEditorInsertOperation::DoStartLoadL

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

//

void CUniEditorInsertOperation::DoStartLoadL()

    {

    if ( iAddSlide )

        {

        if ( !iChangeSlideOperation )

            {

            iChangeSlideOperation = CUniEditorChangeSlideOperation::NewL( *this,

                                                                          iDocument,

                                                                          iHeader,

                                                                          iSlideLoader,

                                                                          iView,

                                                                          iFs );            

            }

        iChangeSlideOperation->ChangeSlide( iInsertedSlide );

        }

    else

        {        

        iSlideLoader.LoadObject( *this, iInsertedObject );

        }

    SetPending();

    iOperationState = EUniInsertReady;

    }

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

// CUniEditorInsertOperation::DoStartReloadL

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

//

void CUniEditorInsertOperation::DoStartReloadL()

    {

    TInt CurrSlide = iDocument.CurrentSlide();

    TInt slide = (iPreviousSlide!= -1)?iPreviousSlide:CurrSlide;

    if ( iPreviousSlide != ( -1 ) || CurrSlide == 0 )

        {

        if ( !iChangeSlideOperation )

            {

            iChangeSlideOperation = CUniEditorChangeSlideOperation::NewL( *this,

                                                                          iDocument,

                                                                          iHeader,

                                                                          iSlideLoader,

                                                                          iView,

                                                                          iFs );            

            }

        iChangeSlideOperation->ChangeSlide( slide );

        SetPending();

        }

    iOperationState = EUniInsertErrorReport;

    }

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

// CUniEditorInsertOperation::DoCheckSizeL

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

//

void CUniEditorInsertOperation::DoCheckSizeL()

    {

    if ( CheckSizeForInsertL() )

        {

        iOperationState = EUniInsertCopyAttachment;

        }

    else

        {

        iOperationState = EUniInsertError;

        }

    CompleteSelf( KErrNone );

    }

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

// CUniEditorInsertOperation::DoCheckModeL

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

//

void CUniEditorInsertOperation::DoCheckModeL()

    {

    if ( CheckModeForInsert( ETrue ) )

        {

        iOperationState = EUniInsertProcessImage;

        }

    else

        {

        iOperationState = EUniInsertError;

        }

    CompleteSelf( KErrNone );

    }

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

// CUniEditorInsertOperation::CheckModeForInsertL

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

//

TBool CUniEditorInsertOperation::CheckModeForInsert( TBool aBeforeProcessing )

    {

    CMsgMediaInfo* info;

    if ( iNewInfo )

        {

        info = iNewInfo;

        }

    else

        {

        info = iOldInfo;

        }    

    TMmsConformance conformance = 

        iDocument.DataModel()->MmsConformance().MediaConformance( *info );

    TUint32 confStatus = conformance.iConfStatus;

    if ( aBeforeProcessing &&  

         iDocument.CreationMode() != EMmsCreationModeRestricted )

        {

        return ETrue;

        }

    // In "free" mode user can insert images that are larger by dimensions than allowed by conformance

    if ( iDocument.CreationMode() != EMmsCreationModeRestricted )

        {

        TInt i = EMmsConfNokFreeModeOnly | EMmsConfNokScalingNeeded | EMmsConfNokTooBig;

        TInt j = ~( EMmsConfNokFreeModeOnly | EMmsConfNokScalingNeeded | EMmsConfNokTooBig );

        // If user answers yes to Guided mode confirmation query he/she moves to free mode

        if ( ( confStatus & i ) &&

             !( confStatus & j ) )

            {

            if ( info->Protection() & EFileProtSuperDistributable )

                {

                // SuperDistribution not checked here

                // Mask "FreeModeOnly" and "ScalingNeeded" away in free mode