/*

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

*       CUniSmilModel, Storage for Smil presentation data.

*

*

*/

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

#include <e32def.h>

#include <eikenv.h>

#include <eikfutil.h>               // CopyFile

#include <mtclbase.h>   // for CBaseMtm

#include <msvstd.h>     // for TMsvId

#include <msvids.h>     // for KMsvTempIndexEntryId

#include <msvstore.h>

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#include <cmsvattachment.h>

#include <bautils.h>                // NearestLanguageFile

#include <coemain.h>

// LAF

/*

#include <AknUtils.h>

#include <AknLayoutScalable_Avkon.cdl.h>

#include <AknLayoutScalable_Apps.cdl.h>

#include <LayoutMetadata.cdl.h>

*/

// DOM

#include <gmxmldocument.h>

#include <gmxmlnode.h>

#include <gmxmlelement.h>

// MsgMedia

#include <MsgMedia.hrh>

#include <MsgMediaInfo.h>

#include <MmsConformance.h>

#include <mmsversion.h>

#include <MsgTextInfo.h>

// MsgDataUTILS

#include <UniDataModel.rsg>         // Viewer/Editor Mimetype strings

#include "UniModelConst.h"              // Definitions and enums

#include "UniDataUtils.h"

#include "UniSmilSlide.h"

#include "UniSmilModel.h"

#include "UniObjectList.h"

#include "UniObject.h"

#include "UniTextObject.h"

#include "UniMimeInfo.h"

#include "UniSmilUtils.h"

#include "UniSmilParams.h"

#include "fileprotectionresolver.h"     //     EFileProtDrm2

#include "MsgMimeTypes.h"

// Logging

//#include "//MsgDataUTILSLOGGing.h"

// ========== EXTERNAL DATA STRUCTURES =====================

// ========== EXTERNAL FUNCTION PROTOTYPES =================

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

// ========== MACROS =======================================

// ========== LOCAL CONSTANTS AND MACROS ===================

_LIT( KSmilIntFormat, "%d" );

_LIT( KSmilMsecFormat, "%dms" );

const TUint KSlideArrayGranularity( 16 );

// SMIL size estimates

const TInt KSizeMandatorySmilTags = 148;

const TInt KSizeHeadOneRegion = 85;

const TInt KSizeHeadTwoRegions = 170;

const TInt KSizeEmptyPar = 27;

const TInt KSizeNonEmptyPar = 41;

const TInt KSizeAudioTag = 38;

const TInt KSizeImageTag = 52;

const TInt KSizeTextTag = 51;

const TInt KSizeVideoTag = 53;

const TInt KSizeLowResHeight = 208;

const TInt KSizeLowResWidth = 176;

// ========== MODULE DATA STRUCTURES =======================

// ========== LOCAL FUNCTION PROTOTYPES ====================

// ========== LOCAL FUNCTIONS ==============================

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

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

// CUniSmilModel::NewL

//

// Factory method.

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

//

CUniSmilModel* CUniSmilModel::NewLC( RFs& aFs,

                                             CBaseMtm& aMtm,

                                             CUniDataUtils& aData,

                                             CUniObjectList& aObjectList )

    {

    CUniSmilModel* self = new ( ELeave )

        CUniSmilModel( aFs, aMtm, aData, aObjectList );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CUniSmilModel::NewL

//

// Factory method.

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

//

CUniSmilModel* CUniSmilModel::NewL( RFs& aFs,

                                            CBaseMtm& aMtm,

                                            CUniDataUtils& aData,

                                            CUniObjectList& aObjectList )

    {

    CUniSmilModel* self = NewLC( aFs, aMtm, aData, aObjectList );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUniSmilModel::CUniSmilModel

//

// Constructor.

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

//

CUniSmilModel::CUniSmilModel( RFs& aFs,

                             CBaseMtm& aMtm,

                             CUniDataUtils& aData,

                             CUniObjectList& aObjectList ) :

    iFs( aFs ),

    iMtm( aMtm ),

    iData( aData ),

    iObjectList( aObjectList ),

    iSlideLayout( EUniUndefinedLayout ),

    iSmilParams( 0 ),

    iScreenSize( 0, 0 ),

    iSizeEstimateUpToDate( EFalse ),

    iSizeEstimate( 0 )

    {

    }

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

// CUniSmilModel::~CUniSmilModel

//

// Destructor.

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

//

CUniSmilModel::~CUniSmilModel()

    {

    if (iSlideArray)

        {

        iSlideArray->ResetAndDestroy();

        }

    delete iSlideArray;

    delete iSmilParams;

    }

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

// CUniSmilModel::ParseL

//

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

//

TInt CUniSmilModel::ParseL( CMDXMLDocument* aDom )

    {

    //MsgDataUTILSLOGGER_ENTERFN( "CUniSmilModel::ParseL()" );

    Reset();

    if ( aDom )

        {

        TRAPD( error, DoPresentationFromDomL( aDom ) );

        if ( error )

            {

            Reset();

            User::Leave( error );

            }

        else

            {

            iParseResult |= EParsedFromSmil;

            }

        }

    else

        {

        //  No SMIL -> Do presentation from object list

        if ( IsMessageSlide() )

            {

            // Determine layout. Make slide.

            DoNoSmilOneSlideL();

            }

        else

            {

            // Do slide for each media object

            DoNoSmilManySlideL();

            }

        iParseResult |= EParsedFromList;

        }

    return iParseResult;

    }

//**********************************************************

//*

//* SMIL COMPOSING FUNCTIONS

//*

//**********************************************************

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

// CUniSmilModel::¨ComposeL

//

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

//

CMDXMLDocument* CUniSmilModel::ComposeL()

    {

    //MsgDataUTILSLOGGER_ENTERFN( "CUniSmilModel::ComposeL()" );

    // Reset region id's

    iTextRegionId.Set( KNullDesC );

    iImageRegionId.Set( KNullDesC );

    // Read default smil parameters

    if( !iSmilParams )

        {

        //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Creating smil parameter structures." );

        iSmilParams = CUniSmilParams::NewL( iFs );

        }

    //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Creating new DOM." );

    //delete iDom;

    //iDom = 0;

    CMDXMLDocument* dom = CMDXMLDocument::NewLC();

    // Create smil node

    TPtrC name( KSMILWREleSmil );

    CMDXMLElement* root = CMDXMLElement::NewLC( ETrue, dom, name );

    // Append

    dom->DocumentElement()->AppendChild( root ); // Ownership to dom

    CleanupStack::Pop( root );

    // Create Head

    CreateHeadL( dom, root );

    // Create Body

    CreateBodyL( dom, root );

    // TODO: Move to Document and to use smil list

    //iObjectList.CreateSmilAttachmentL( smilAttaId, iDom, iFs );

    CleanupStack::Pop( dom );

    return dom;

    }

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

// CUniSmilModel::RemoveEmptySlides

//

//

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

//

void CUniSmilModel::RemoveEmptySlides()

    {

    TInt count = iSlideArray->Count();

    // Must be done from end to beginning because

    // slides might be removed.

    while ( count-- )

        {

        if ( !iSlideArray->At( count )->ObjectCount() )

            {

            RemoveSlide( count );

            }

        }

    }

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

// CUniSmilModel::AddSlideL

//

//

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

//

void CUniSmilModel::AddSlideL( TInt aSlideNum )

    {

    DoAddSlideL( aSlideNum );

    }

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

// CUniSmilModel::RemoveSlide

//

//

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

//

void CUniSmilModel::RemoveSlide( TInt aSlideNum )

    {

    if ( !IsSlide( aSlideNum ) )

        {

        //__ASSERT_DEBUG( EFalse, DataUtilsPanic( EMmsNotASlide ) );

        return;

        }

    CUniSmilSlide* slide = iSlideArray->At( aSlideNum );

    if ( slide->ObjectCount() )

        {

        //__ASSERT_DEBUG( EFalse, DataUtilsPanic( EMmsSlideNotEmpty ) );

        return;

        }

    iSlideArray->Delete( aSlideNum );

    delete slide;

    //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Empty slide removed." );

    iSizeEstimateUpToDate = EFalse;

    }

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

// CUniSmilModel::MoveSlideL

//

//

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

//

void CUniSmilModel::MoveSlideL( TInt aSlideToMove, TInt aPlaceToMove )

    {

    TInt slideCount = iSlideArray->Count();

    if ( !slideCount

        || aSlideToMove < 0

        || aSlideToMove >= slideCount

        || aSlideToMove == aPlaceToMove )

        {

        return;

        }

    TInt place = Min( Max( 0, aPlaceToMove ), slideCount - 1 );

    CUniSmilSlide* slide = iSlideArray->At( aSlideToMove );

    iSlideArray->Delete( aSlideToMove );

    iSlideArray->InsertL( place, slide );

    iSizeEstimateUpToDate = EFalse;

    }

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

// SortSlidesL

//

// Sorts slides accoring to a separate comparison function

// called SortSlidesCompare().

//

// Insertion sort algorithm.

//

// Notice! Intended to be used with SendAs when there

// are multiple slides - each slide containing only

// one object

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

void CUniSmilModel::SortSlidesL()

    {

    TInt i = 1; // index 1, i.e. second slide

    TInt count = SlideCount();

    while ( i < count )

        {

        CUniSmilSlide* slide1 = iSlideArray->At( i );

        TInt j = i - 1;

        while ( j >= 0 )

            {

            CUniSmilSlide* slide2 = iSlideArray->At( j );

            if ( SortSlidesCompare( slide1, slide2 ) > 0 )

                {

                break;

                }

            j--;

            }

        j++;

        if ( j < i )

            {

            // slide1 was not in the right place

            iSlideArray->Delete( i );

            iSlideArray->InsertL( j, slide1 );

            }

        i++;

        }

    iSizeEstimateUpToDate = EFalse;

    }

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

// SortSlidesCompare

//

// Compares slides according to time. Most recent is greatest.

//

// Empty slides are greater than non-empty slides.

// If aSlide1 "is greater than" aSlide2 returns positive value.

// If aSlide1 "is smaller than" aSlide2 returns negative value.

// If aSlide1 and aSlide2 "are equal" returns zero.

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

//

TInt CUniSmilModel::SortSlidesCompare( CUniSmilSlide* aSlide1,

                                      CUniSmilSlide* aSlide2 )

    {

    if ( !aSlide1->ObjectCount() )

        {

        //if both are empty returns 0

        //if slide2 is non-empty -> slide1 "is greater"

        return aSlide2->ObjectCount();

        }

    else if ( !aSlide2->ObjectCount() )

        {

        //empty slide is always "greatest"

        return -1;

        }

    else

        {

        TTime time1;

        TTime time2;

        aSlide1->GetObjectByIndex( 0 )->MediaInfo()->ModificationTime( time1 );

        aSlide2->GetObjectByIndex( 0 )->MediaInfo()->ModificationTime( time2 );

        if ( time1 < time2 )

            {

            return -1;

            }

        else if ( time1 == time2 )

            {

            return 0;

            }

        else

            {

            return 1;

            }

        }

    }

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

// CUniSmilModel::IsSlide

//

//

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

//

TBool CUniSmilModel::IsSlide( TInt aSlideNum ) const

    {

    if( aSlideNum >= 0 &&

        aSlideNum < iSlideArray->Count() )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CUniSmilModel::AddTextObjectL

//

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

//

CUniTextObject* CUniSmilModel::AddTextObjectL(

    TInt aSlideNum,

    CEikRichTextEditor* aText )

    {

    CUniTextObject* obj = CUniTextObject::NewLC( iFs, iMtm, iData, aText );

    iObjectList.AddObjectL( obj );

    CleanupStack::Pop( obj );

    iSlideArray->At(aSlideNum)->AddObjectL( obj );

    iSizeEstimateUpToDate = EFalse;

    return obj;

    }

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

// CUniSmilModel::AddTempObjectL

//

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

//

/*

CUniObject* CUniSmilModel::AddTempObjectL( TInt aSlideNum,

                                            CMsgMediaInfo* aMedia )

    {

    if ( !IsSlide( aSlideNum ) )

        {

        User::Leave( KErrArgument );

        }

    CUniObject* obj = CUniObject::NewLC( iFs, iMtm, iData, aMedia );

    // Update model

    iObjectList.AddObjectL( obj );

    CleanupStack::Pop( obj );

    iSlideArray->At( aSlideNum )->AddObjectL( obj );

    SetLayoutFromObjectTypeL( obj->MediaType() );

    iSizeEstimateUpToDate = EFalse;

    return obj;

    }

*/

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

// CUniSmilModel::AddObjectL

//

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

//

CUniObject* CUniSmilModel::AddObjectL( MUniObjectSaveObserver& aObserver,

                                               TInt aSlideNum,

                                               CMsgMediaInfo* aMedia )

    {

    if ( !IsSlide( aSlideNum ) )

        {