1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *       CUniSmilModel, Storage for Smil presentation data.

    16 *

    17 *

    18 */

    19 

    20 

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

    22 

    23 

    24 #include <e32def.h>

    25 #include <eikenv.h>

    26 #include <eikfutil.h>               // CopyFile

    27 

    28 #include <mtclbase.h>   // for CBaseMtm

    29 #include <msvstd.h>     // for TMsvId

    30 #include <msvids.h>     // for KMsvTempIndexEntryId

    31 #include <msvstore.h>

    32 #include <mmsvattachmentmanager.h>

    33 #include <mmsvattachmentmanagersync.h>

    34 #include <cmsvattachment.h>

    35 

    36 #include <bautils.h>                // NearestLanguageFile

    37 

    38 #include <coemain.h>

    39 

    40 // LAF

    41 /*

    42 #include <AknUtils.h>

    43 #include <AknLayoutScalable_Avkon.cdl.h>

    44 #include <AknLayoutScalable_Apps.cdl.h>

    45 #include <LayoutMetadata.cdl.h>

    46 */

    47 

    48 // DOM

    49 #include <gmxmldocument.h>

    50 #include <gmxmlnode.h>

    51 #include <gmxmlelement.h>

    52 

    53 // MsgMedia

    54 #include <MsgMedia.hrh>

    55 #include <MsgMediaInfo.h>

    56 #include <MmsConformance.h>

    57 #include <mmsversion.h>

    58 #include <MsgTextInfo.h>

    59 

    60 

    61 // MsgDataUTILS

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

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

    64 #include "UniDataUtils.h"

    65 #include "UniSmilSlide.h"

    66 #include "UniSmilModel.h"

    67 #include "UniObjectList.h"

    68 #include "UniObject.h"

    69 #include "UniTextObject.h"

    70 #include "UniMimeInfo.h"

    71 #include "UniSmilUtils.h"

    72 #include "UniSmilParams.h"

    73 

    74 #include "fileprotectionresolver.h"     //     EFileProtDrm2

    75 #include "MsgMimeTypes.h"

    76 

    77 // Logging

    78 //#include "//MsgDataUTILSLOGGing.h"

    79 

    80 

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

    82 

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

    84 

    85 // ========== CONSTANTS ====================================

    86 

    87 // ========== MACROS =======================================

    88 

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

    90 

    91 _LIT( KSmilIntFormat, "%d" );

    92 _LIT( KSmilMsecFormat, "%dms" );

    93 const TUint KSlideArrayGranularity( 16 );

    94 

    95 // SMIL size estimates

    96 const TInt KSizeMandatorySmilTags = 148;

    97 const TInt KSizeHeadOneRegion = 85;

    98 const TInt KSizeHeadTwoRegions = 170;

    99 const TInt KSizeEmptyPar = 27;

   100 const TInt KSizeNonEmptyPar = 41;

   101 const TInt KSizeAudioTag = 38;

   102 const TInt KSizeImageTag = 52;

   103 const TInt KSizeTextTag = 51;

   104 const TInt KSizeVideoTag = 53;

   105 

   106 const TInt KSizeLowResHeight = 208;

   107 const TInt KSizeLowResWidth = 176;

   108 

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

   110 

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

   112 

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

   114 

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

   116 

   117 

   118 // ---------------------------------------------------------

   119 // CUniSmilModel::NewL

   120 //

   121 // Factory method.

   122 // ---------------------------------------------------------

   123 //

   124 CUniSmilModel* CUniSmilModel::NewLC( RFs& aFs,

   125                                              CBaseMtm& aMtm,

   126                                              CUniDataUtils& aData,

   127                                              CUniObjectList& aObjectList )

   128     {

   129     CUniSmilModel* self = new ( ELeave )

   130         CUniSmilModel( aFs, aMtm, aData, aObjectList );

   131 

   132     CleanupStack::PushL(self);

   133     self->ConstructL();

   134     return self;

   135     }

   136 

   137 

   138 // ---------------------------------------------------------

   139 // CUniSmilModel::NewL

   140 //

   141 // Factory method.

   142 // ---------------------------------------------------------

   143 //

   144 CUniSmilModel* CUniSmilModel::NewL( RFs& aFs,

   145                                             CBaseMtm& aMtm,

   146                                             CUniDataUtils& aData,

   147                                             CUniObjectList& aObjectList )

   148     {

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

   150     CleanupStack::Pop( self );

   151     return self;

   152     }

   153 

   154 

   155 // ---------------------------------------------------------

   156 // CUniSmilModel::CUniSmilModel

   157 //

   158 // Constructor.

   159 // ---------------------------------------------------------

   160 //

   161 CUniSmilModel::CUniSmilModel( RFs& aFs,

   162                              CBaseMtm& aMtm,

   163                              CUniDataUtils& aData,

   164                              CUniObjectList& aObjectList ) :

   165     iFs( aFs ),

   166     iMtm( aMtm ),

   167     iData( aData ),

   168     iObjectList( aObjectList ),

   169     iSlideLayout( EUniUndefinedLayout ),

   170     iSmilParams( 0 ),

   171     iScreenSize( 0, 0 ),

   172     iSizeEstimateUpToDate( EFalse ),

   173     iSizeEstimate( 0 )

   174     {

   175     }

   176 

   177 // ---------------------------------------------------------

   178 // CUniSmilModel::~CUniSmilModel

   179 //

   180 // Destructor.

   181 // ---------------------------------------------------------

   182 //

   183 CUniSmilModel::~CUniSmilModel()

   184     {

   185     if (iSlideArray)

   186         {

   187         iSlideArray->ResetAndDestroy();

   188         }

   189     delete iSlideArray;

   190     delete iSmilParams;

   191     }

   192 

   193 // ---------------------------------------------------------

   194 // CUniSmilModel::ParseL

   195 //

   196 // ---------------------------------------------------------

   197 //

   198 TInt CUniSmilModel::ParseL( CMDXMLDocument* aDom )

   199     {

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

   201 

   202     Reset();

   203 

   204     if ( aDom )

   205         {

   206         TRAPD( error, DoPresentationFromDomL( aDom ) );

   207         if ( error )

   208             {

   209             Reset();

   210             User::Leave( error );

   211             }

   212         else

   213             {

   214             iParseResult |= EParsedFromSmil;

   215             }

   216         }

   217     else

   218         {

   219         //  No SMIL -> Do presentation from object list

   220         if ( IsMessageSlide() )

   221             {

   222             // Determine layout. Make slide.

   223             DoNoSmilOneSlideL();

   224             }

   225         else

   226             {

   227             // Do slide for each media object

   228             DoNoSmilManySlideL();

   229             }

   230         iParseResult |= EParsedFromList;

   231         }

   232 

   233     return iParseResult;

   234     }

   235 

   236 

   237 //**********************************************************

   238 //*

   239 //* SMIL COMPOSING FUNCTIONS

   240 //*

   241 //**********************************************************

   242 

   243 

   244 // ---------------------------------------------------------

   245 // CUniSmilModel::¨ComposeL

   246 //

   247 // ---------------------------------------------------------

   248 //

   249 CMDXMLDocument* CUniSmilModel::ComposeL()

   250     {

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

   252 

   253     // Reset region id's

   254     iTextRegionId.Set( KNullDesC );

   255     iImageRegionId.Set( KNullDesC );

   256 

   257     // Read default smil parameters

   258     if( !iSmilParams )

   259         {

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

   261         iSmilParams = CUniSmilParams::NewL( iFs );

   262         }

   263 

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

   265     //delete iDom;

   266     //iDom = 0;

   267     CMDXMLDocument* dom = CMDXMLDocument::NewLC();

   268 

   269     // Create smil node

   270     TPtrC name( KSMILWREleSmil );

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

   272     // Append

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

   274     CleanupStack::Pop( root );

   275 

   276     // Create Head

   277     CreateHeadL( dom, root );

   278 

   279     // Create Body

   280     CreateBodyL( dom, root );

   281 

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

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

   284     CleanupStack::Pop( dom );

   285     return dom;

   286     }

   287 

   288 

   289 

   290 // ---------------------------------------------------------

   291 // CUniSmilModel::RemoveEmptySlides

   292 //

   293 //

   294 // ---------------------------------------------------------

   295 //

   296 void CUniSmilModel::RemoveEmptySlides()

   297     {

   298     TInt count = iSlideArray->Count();

   299     // Must be done from end to beginning because

   300     // slides might be removed.

   301     while ( count-- )

   302         {

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

   304             {

   305             RemoveSlide( count );

   306             }

   307         }

   308     }

   309 

   310 

   311 // ---------------------------------------------------------

   312 // CUniSmilModel::AddSlideL

   313 //

   314 //

   315 // ---------------------------------------------------------

   316 //

   317 void CUniSmilModel::AddSlideL( TInt aSlideNum )

   318     {

   319     DoAddSlideL( aSlideNum );

   320     }

   321 

   322 // ---------------------------------------------------------

   323 // CUniSmilModel::RemoveSlide

   324 //

   325 //

   326 // ---------------------------------------------------------

   327 //

   328 void CUniSmilModel::RemoveSlide( TInt aSlideNum )

   329     {

   330     if ( !IsSlide( aSlideNum ) )

   331         {

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

   333         return;

   334         }

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

   336     if ( slide->ObjectCount() )

   337         {

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

   339         return;

   340         }

   341 

   342     iSlideArray->Delete( aSlideNum );

   343     delete slide;

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

   345     iSizeEstimateUpToDate = EFalse;

   346     }

   347 

   348 // ---------------------------------------------------------

   349 // CUniSmilModel::MoveSlideL

   350 //

   351 //

   352 // ---------------------------------------------------------

   353 //

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

   355     {

   356     TInt slideCount = iSlideArray->Count();

   357     if ( !slideCount

   358         || aSlideToMove < 0

   359         || aSlideToMove >= slideCount

   360         || aSlideToMove == aPlaceToMove )

   361         {

   362         return;

   363         }

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

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

   366 

   367     iSlideArray->Delete( aSlideToMove );

   368     iSlideArray->InsertL( place, slide );

   369     iSizeEstimateUpToDate = EFalse;

   370     }

   371 

   372 // ---------------------------------------------------------

   373 // SortSlidesL

   374 //

   375 // Sorts slides accoring to a separate comparison function

   376 // called SortSlidesCompare().

   377 //

   378 // Insertion sort algorithm.

   379 //

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

   381 // are multiple slides - each slide containing only

   382 // one object

   383 // ---------------------------------------------------------

   384 void CUniSmilModel::SortSlidesL()

   385     {

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

   387     TInt count = SlideCount();

   388     while ( i < count )

   389         {

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

   391         TInt j = i - 1;

   392         while ( j >= 0 )

   393             {

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

   395             if ( SortSlidesCompare( slide1, slide2 ) > 0 )

   396                 {

   397                 break;

   398                 }

   399             j--;

   400             }

   401         j++;

   402         if ( j < i )

   403             {

   404             // slide1 was not in the right place

   405             iSlideArray->Delete( i );

   406             iSlideArray->InsertL( j, slide1 );

   407             }

   408         i++;

   409         }

   410     iSizeEstimateUpToDate = EFalse;

   411     }

   412 

   413 

   414 // ---------------------------------------------------------

   415 // SortSlidesCompare

   416 //

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

   418 //

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

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

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

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

   423 // ---------------------------------------------------------

   424 //

   425 TInt CUniSmilModel::SortSlidesCompare( CUniSmilSlide* aSlide1,

   426                                       CUniSmilSlide* aSlide2 )

   427     {

   428     if ( !aSlide1->ObjectCount() )

   429         {

   430         //if both are empty returns 0

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

   432         return aSlide2->ObjectCount();

   433         }

   434     else if ( !aSlide2->ObjectCount() )

   435         {

   436         //empty slide is always "greatest"

   437         return -1;

   438         }

   439     else

   440         {

   441         TTime time1;

   442         TTime time2;

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

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

   445         if ( time1 < time2 )

   446             {

   447             return -1;

   448             }

   449         else if ( time1 == time2 )

   450             {

   451             return 0;

   452             }

   453         else

   454             {

   455             return 1;

   456             }

   457         }

   458     }

   459 

   460 // ---------------------------------------------------------

   461 // CUniSmilModel::IsSlide

   462 //

   463 //

   464 // ---------------------------------------------------------

   465 //

   466 TBool CUniSmilModel::IsSlide( TInt aSlideNum ) const

   467     {

   468     if( aSlideNum >= 0 &&

   469         aSlideNum < iSlideArray->Count() )

   470         {

   471         return ETrue;

   472         }

   473     return EFalse;

   474     }

   475 

   476 // ---------------------------------------------------------

   477 // CUniSmilModel::AddTextObjectL

   478 //

   479 // ---------------------------------------------------------

   480 //

   481 CUniTextObject* CUniSmilModel::AddTextObjectL(

   482     TInt aSlideNum,

   483     CEikRichTextEditor* aText )

   484     {

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

   486     iObjectList.AddObjectL( obj );

   487     CleanupStack::Pop( obj );

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

   489     iSizeEstimateUpToDate = EFalse;

   490     return obj;

   491     }

   492 

   493 // ---------------------------------------------------------

   494 // CUniSmilModel::AddTempObjectL

   495 //

   496 // ---------------------------------------------------------

   497 //

   498 /*

   499 CUniObject* CUniSmilModel::AddTempObjectL( TInt aSlideNum,

   500                                             CMsgMediaInfo* aMedia )

   501     {

   502     if ( !IsSlide( aSlideNum ) )

   503         {

   504         User::Leave( KErrArgument );

   505         }

   506 

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

   508 

   509     // Update model

   510     iObjectList.AddObjectL( obj );

   511     CleanupStack::Pop( obj );

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

   513     SetLayoutFromObjectTypeL( obj->MediaType() );

   514     iSizeEstimateUpToDate = EFalse;

   515     return obj;

   516     }

   517 */

   518 

   519 // ---------------------------------------------------------

   520 // CUniSmilModel::AddObjectL

   521 //

   522 // ---------------------------------------------------------

   523 //

   524 CUniObject* CUniSmilModel::AddObjectL( MUniObjectSaveObserver& aObserver,

   525                                                TInt aSlideNum,

   526                                                CMsgMediaInfo* aMedia )

   527     {

   528     if ( !IsSlide( aSlideNum ) )

   529         {

   530         User::Leave( KErrArgument );

   531         }

   532 

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

   534 

   535     // Update model

   536     iObjectList.AddObjectL( obj );

   537     CleanupStack::Pop( obj );

   538     obj->Save( aObserver, CMsvAttachment::EMsvLinkedFile );

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

   540     iSizeEstimateUpToDate = EFalse;

   541     return obj;

   542     }

   543 

   544 // ---------------------------------------------------------

   545 // CUniSmilModel::AddStoredObjectL

   546 //

   547 // ---------------------------------------------------------

   548 //

   549 CUniObject* CUniSmilModel::AddStoredObjectL( TInt aSlideNum,

   550                                                      TMsvAttachmentId aAttachmentId,

   551                                                      CMsgMediaInfo* aMedia )

   552     {

   553     if ( !IsSlide( aSlideNum ) )

   554         {

   555         User::Leave( KErrArgument );

   556         }

   557 

   558     CMsvStore* store = iMtm.Entry().EditStoreL();

   559     CleanupStack::PushL( store );

   560     MMsvAttachmentManager& manager = store->AttachmentManagerL();

   561     MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();

   562     CMsvAttachment* attachment = manager.GetAttachmentInfoL( aAttachmentId );

   563     CleanupStack::PushL( attachment );

   564 

   565     CUniObject* obj = NULL;

   566 

   567     if ( aMedia &&

   568          aMedia->MediaType() == EMsgMediaText )

   569         {

   570         CMsgTextInfo* textInfo = static_cast<CMsgTextInfo*>( aMedia );

   571         obj = CUniTextObject::NewLC( iFs, iMtm, iData, textInfo, manager, *attachment );

   572         }

   573     else

   574         {

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

   576         }

   577     managerSync.ModifyAttachmentInfoL( attachment );

   578     CleanupStack::Pop( 2, attachment ); //obj, attachment

   579     CleanupStack::PushL( obj );

   580     store->CommitL();

   581 

   582     // Update model

   583     iObjectList.AddObjectL( obj );

   584     CleanupStack::Pop( obj );

   585     CleanupStack::PopAndDestroy( store );

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

   587     iSizeEstimateUpToDate = EFalse;

   588     return obj;

   589     }

   590 

   591 // ---------------------------------------------------------

   592 // CUniSmilModel::RemoveObjectL

   593 //

   594 //

   595 // ---------------------------------------------------------

   596 //

   597 void CUniSmilModel::RemoveObjectL( TInt aSlideNum,

   598                                             CUniObject* aObject,

   599                                             TBool aLeaveToStore/* = EFalse*/ )

   600     {

   601     if ( !IsSlide( aSlideNum ) ||

   602         !iSlideArray->At( aSlideNum )->IsObject( aObject ) )

   603         {

   604         return;

   605         }

   606     // TODO: Check that object exists on the slide.

   607 

   608     //if ( !IsObject( aSlideNum, aObjectType ) )

   609     //    {

   610     //    return;

   611     //    }

   612     DoRemoveObjectL( aSlideNum, aObject, aLeaveToStore );

   613     }

   614 

   615 // ---------------------------------------------------------

   616 // CUniSmilModel::RemoveObjectByIndexL

   617 //

   618 //

   619 // ---------------------------------------------------------

   620 //

   621 void CUniSmilModel::RemoveObjectByIndexL( TInt aSlideNum, TInt aObjectNum )

   622     {

   623     if ( !IsSlide( aSlideNum ) )

   624         {

   625         return;

   626         }

   627     CUniObject* obj = iSlideArray->At( aSlideNum )->GetObjectByIndex( aObjectNum );

   628     DoRemoveObjectL( aSlideNum, obj );

   629     }

   630 

   631 // ---------------------------------------------------------

   632 // CUniSmilModel::DoRemoveObjectL

   633 //

   634 //

   635 // ---------------------------------------------------------

   636 //

   637 void CUniSmilModel::DoRemoveObjectL( TInt aSlideNum, CUniObject* aObject, TBool aLeaveToStore/* = EFalse*/ )

   638     {

   639     //MsgDataUTILSLOGGER_ENTERFN( "CUniSmilModel : DoRemoveObjectL()" );

   640 

   641     TBool removeObj = ( aObject->ReferenceCount() - 1 <= 0 );

   642     //if last reference was (will be) removed, remove from

   643     //attachment list (and msg store)

   644     if ( removeObj )

   645         {

   646         //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Removing from atta list and store." );

   647         iObjectList.RemoveObjectL( aObject, !aLeaveToStore );

   648         }

   649 

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

   651     slide->RemoveObject( aObject );

   652     iSizeEstimateUpToDate = EFalse;

   653 

   654     if ( removeObj )

   655         {

   656         delete aObject;

   657         }

   658 

   659     //MsgDataUTILSLOGGER_LEAVEFN( "CUniSmilModel : DoRemoveObjectL()" );

   660     }

   661 

   662 // ---------------------------------------------------------

   663 // CUniSmilModel::GetObject

   664 //

   665 //

   666 // ---------------------------------------------------------

   667 //

   668 CUniObject* CUniSmilModel::GetObjectByIndex( TInt aSlideNum,

   669                                                      TInt aObjectNum ) const

   670     {

   671     if( !IsSlide( aSlideNum ) )

   672         {

   673         return NULL;

   674         }

   675     return iSlideArray->At( aSlideNum )->GetObjectByIndex( aObjectNum );

   676     }

   677 

   678 // ---------------------------------------------------------

   679 // CUniSmilModel::GetObject

   680 //

   681 //

   682 // ---------------------------------------------------------

   683 //

   684 CUniObject* CUniSmilModel::GetObject( TInt aSlideNum,

   685                                               TUniRegion aRegion ) const

   686     {

   687     if( !IsSlide( aSlideNum ) )

   688         {

   689         return NULL;

   690         }

   691     return iSlideArray->At( aSlideNum )->GetObject( aRegion );

   692     }

   693 

   694 // ---------------------------------------------------------

   695 // CUniSmilModel::SetLayoutL

   696 //

   697 // Mutator.

   698 // ---------------------------------------------------------

   699 //

   700 void CUniSmilModel::SetLayoutL( TUniLayout aNewLayout )

   701     {

   702     iSlideLayout = aNewLayout;

   703     TUint slideCnt = iSlideArray->Count();

   704     for (TUint i = 0; i < slideCnt; i++ )

   705         {

   706         iSlideArray->At(i)->UpdateLayoutL( iSlideLayout );

   707         }

   708     iSizeEstimateUpToDate = EFalse;

   709     }

   710 

   711 // ---------------------------------------------------------

   712 // CUniSmilModel::SmilComposeSize()

   713 //

   714 // Total size

   715 // ---------------------------------------------------------

   716 //

   717 TInt CUniSmilModel::SmilComposeSize()

   718     {

   719     TInt slideCount = iSlideArray->Count();

   720     if ( !slideCount )

   721         {

   722         return 0;

   723         }

   724     if ( !iSizeEstimateUpToDate )

   725         {

   726         iSizeEstimate = SmilComposeSize(

   727             slideCount,

   728             iSlideArray->At( slideCount - 1 )->ObjectCount() );

   729         iSizeEstimateUpToDate = ETrue;

   730         }

   731     return iSizeEstimate;

   732     }

   733 

   734 

   735 // ---------------------------------------------------------

   736 // CUniSmilModel::SmilComposeSize()

   737 //

   738 // Size from beginning

   739 // ---------------------------------------------------------

   740 //

   741 TInt CUniSmilModel::SmilComposeSize( TInt aToSlideNum, TInt aToObjectNum )

   742     {

   743     //__ASSERT_DEBUG(

   744     //    ( aToSlideNum > 0 && aToSlideNum <= iSlideArray->Count() ),

   745     //    DataUtilsPanic( EMmsIllegalSlide ) );

   746     //__ASSERT_DEBUG(

   747     //    ( aToObjectNum <= iSlideArray->At( aToSlideNum - 1 )->ObjectCount() ),

   748     //    DataUtilsPanic( EMmsIllegalObject ) );

   749 

   750     TInt size( KSizeMandatorySmilTags );

   751     TBool imageRegion = EFalse;

   752     TBool textRegion = EFalse;

   753 

   754     for ( TInt i = 0; i < aToSlideNum; i++ )

   755         {

   756         CUniSmilSlide* slide = iSlideArray->At( i );

   757         TInt toObj = slide->ObjectCount();

   758         if ( i == aToSlideNum - 1 )

   759             {

   760             toObj = aToObjectNum;

   761             }

   762         if ( !toObj )

   763             {

   764             //No objects on the slide

   765             size += KSizeEmptyPar;

   766             }

   767         else

   768             {

   769             //One or more objects

   770             size += KSizeNonEmptyPar;

   771             }

   772         for ( TInt ii = 0; ii < toObj; ii++ )

   773             {

   774             CUniObject* obj = slide->GetObjectByIndex( ii );

   775             switch ( obj->MediaType() )

   776                 {

   777                 case EMsgMediaAudio:

   778                     size += KSizeAudioTag;

   779                     break;

   780                 case EMsgMediaImage:

   781                 case EMsgMediaSvg:

   782                     size += KSizeImageTag;

   783                     imageRegion = ETrue;

   784                     break;

   785                 case EMsgMediaText:

   786                 case EMsgMediaXhtml:

   787                     size += KSizeTextTag;

   788                     textRegion = ETrue;

   789                     break;

   790                 case EMsgMediaVideo:

   791                     size += KSizeVideoTag;

   792                     imageRegion = ETrue;

   793                     break;

   794                 default:

   795                     //Should never come here

   796                     //Don't increase size

   797                     break;

   798                 }

   799             }

   800         }

   801 

   802     TInt regions = 0;

   803     if ( imageRegion )

   804         {

   805         regions++;

   806         }

   807     if ( textRegion )

   808         {

   809         regions++;

   810         }

   811     switch ( regions )

   812         {

   813         case 1:

   814             size += KSizeHeadOneRegion;

   815             break;

   816         case 2:

   817             size += KSizeHeadTwoRegions;

   818             break;

   819         default:

   820             //Should be zero

   821             //Don't increase size

   822             break;

   823         }

   824     return size;

   825     }

   826 

   827 

   828 // ---------------------------------------------------------

   829 // CUniSmilModel::ObjectCount

   830 //

   831 // Accessor

   832 // ---------------------------------------------------------

   833 //

   834 TInt CUniSmilModel::ObjectCount() const

   835     {

   836     TInt objCnt(0);

   837 

   838     for ( TInt i = iSlideArray->Count(); --i >= 0 ;)

   839         {

   840         objCnt += iSlideArray->At(i)->ObjectCount();

   841         }

   842 

   843     return objCnt;

   844     }

   845 

   846 

   847 // ---------------------------------------------------------

   848 // CUniSmilModel::SlideObjectCount

   849 //

   850 // Accessor

   851 // ---------------------------------------------------------

   852 //

   853 TInt CUniSmilModel::SlideObjectCount(TInt aSlideNum) const

   854     {

   855     if ( !IsSlide(aSlideNum) )

   856         {

   857         return 0;

   858         }

   859 

   860     return iSlideArray->At( aSlideNum )->ObjectCount();

   861     }

   862 

   863 //**********************************************************

   864 //*

   865 //* CONTRUCTION FUNCTIONS

   866 //*

   867 //**********************************************************

   868 

   869 

   870 // ---------------------------------------------------------

   871 // CUniSmilModel::ConstructL

   872 //

   873 // 2nd phase constructor.

   874 // ---------------------------------------------------------

   875 //

   876 void CUniSmilModel::ConstructL()

   877     {

   878     iSlideArray = new ( ELeave ) CSmilSlideArray( KSlideArrayGranularity );

   879     iTextRegionId.Set( KNullDesC );

   880     iImageRegionId.Set( KNullDesC );

   881 

   882     // Set default layout to "Text first"

   883     iSlideLayout = EUniTextFirst;

   884 

   885     // Fix for NSIA-6CKFJA. Sets same screen size that SMIL Player is using. MH

   886 /*

   887     TRect appWindowRect;

   888     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow, appWindowRect );

   889 

   890     TAknLayoutRect mainPane;

   891     mainPane.LayoutRect( appWindowRect, AknLayoutScalable_Avkon::main_pane( 0 ) );

   892 

   893     TAknLayoutRect mainSmilPane;

   894     mainSmilPane.LayoutRect( mainPane.Rect(), AknLayoutScalable_Apps::main_smil_pane() );

   895 

   896     iScreenSize = mainSmilPane.Rect().Size();

   897 */

   898     }

   899 

   900 // ---------------------------------------------------------

   901 // CUniSmilModel::Reset

   902 //

   903 //

   904 // ---------------------------------------------------------

   905 //

   906 void CUniSmilModel::Reset()

   907     {

   908     iParseResult = 0;

   909     iSlideLayout = EUniTextFirst;

   910     iTextRegionId.Set( KNullDesC );

   911     iImageRegionId.Set( KNullDesC );

   912     if ( iSlideArray )

   913         {

   914         // Reset slide array

   915         iSlideArray->ResetAndDestroy();

   916         }

   917     TInt objCount = iObjectList.Count();

   918     while ( objCount-- )

   919         {

   920         iObjectList.GetByIndex( objCount )->SetReferenceCount( 0 );

   921         }

   922     }

   923 

   924 // ---------------------------------------------------------

   925 // CUniSmilModel::DoPresentationFromDomL

   926 //

   927 // When this functios is called DOM should be validated as MMS SMIL.

   928 // ---------------------------------------------------------

   929 //

   930 void CUniSmilModel::DoPresentationFromDomL( CMDXMLDocument* aDom )

   931     {

   932     RemoveMetaTagsAndComments( aDom );

   933     // Resolve layout of the slide

   934     iSlideLayout = GetMmsSmilLayout( aDom );

   935 

   936     CMDXMLNode* node = GetNode( aDom, KSMILWREleBody );

   937 

   938     if ( node && node->FirstChild() )

   939         {

   940         // Only one slide in the message since no <par> tag found

   941         if ( node->FirstChild()->NodeName().Compare( KSMILWRElePar ) != 0 )

   942             {

   943             // Add slide - the one and only

   944             AddSlideFromDomL( node );

   945             }

   946 

   947         // Other node types than <par> not possible as this is MMS SMIL.

   948         else

   949             {

   950             // Traverse through every page

   951             CMDXMLNode* page = node->FirstChild();

   952             while ( page )

   953                 {

   954                 AddSlideFromDomL( page );

   955                 // Go to next page.

   956                 page = page->NextSibling();

   957                 }

   958             }

   959         }

   960     }

   961 

   962 // ---------------------------------------------------------

   963 // CUniSmilModel::AddSlideFromDomL

   964 //

   965 // ---------------------------------------------------------

   966 //

   967 void CUniSmilModel::AddSlideFromDomL( CMDXMLNode* aPage )

   968     {

   969     CUniObject* obj = NULL;

   970     CUniSmilSlide* slide = DoAddSlideL();

   971     CMDXMLNode* node = aPage->FirstChild();

   972 

   973     // Traverse through every object in page.

   974     while ( node )

   975         {

   976         if ( UniSmilUtils::IsMediaElem( node ) )

   977             {

   978             obj = iObjectList.GetByNodeL( node );

   979             if ( obj )

   980                 {

   981                 if ( slide )

   982                     {

   983                     obj->SetMediaTypeBySmilTag( UniSmilUtils::MediaElemType( node ) );

   984                     AddObjectFromDomL(

   985                         slide,

   986                         obj,

   987                         GetRegionType( node ) );

   988                     }

   989                 else

   990                     {

   991                     iObjectList.RemoveObjectL( obj, ETrue );

   992                     delete obj;

   993                     iParseResult |= EObjectRemoved;

   994                     }

   995                 }

   996             }

   997         node = node->NextSibling();

   998         }

   999     }

  1000 

  1001 

  1002 // ---------------------------------------------------------

  1003 // CUniSmilModel::AddObjectFromDomL

  1004 //

  1005 // ---------------------------------------------------------

  1006 //

  1007 void CUniSmilModel::AddObjectFromDomL( CUniSmilSlide* aSlide,

  1008                                        CUniObject* aObj,

  1009                                        TUniRegion aRegion )

  1010     {

  1011     if ( !aObj )

  1012         {

  1013         // Smil presentation refers to attachment that's not in the message

  1014         iParseResult |= EMissingObjects;

  1015         // Not actually error that should prevent message viewing.

  1016         return;

  1017         }

  1018 

  1019     TMsgMediaType mediaBySmilTag = aObj->MediaTypeBySmilTag();

  1020     TMsgMediaType media = aObj->MediaType();

  1021 

  1022     if ( media == EMsgMediaSvg )

  1023         {

  1024         // SVG considered an image.

  1025         // (...because "image" tag is used for SVG while composing SMIL.)

  1026         media = EMsgMediaImage;

  1027         }

  1028 

  1029     if ( media == EMsgMediaXhtml )

  1030         {

  1031         // XHTML is considered as a text.

  1032         // (...because "text" tag is used for xhtml while composing SMIL.)

  1033         media = EMsgMediaText;

  1034         }

  1035 

  1036     if ( !( media == EMsgMediaText ||

  1037         media == EMsgMediaImage ||

  1038         media == EMsgMediaAudio ||

  1039         media == EMsgMediaVideo ) )

  1040         {

  1041         // Unsupported format

  1042         //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Parsing: Message has unsupported objects." );

  1043         iParseResult |= EUnsupportedObjects;

  1044         // Not actually error that should prevent message viewing.

  1045         }

  1046 

  1047     //  NOTE: Smil standard allows <img src="aa.txt"> references, but conformance

  1048     //        Data forbids these.

  1049     if ( media != EMsgMediaUnknown &&   //Unknown matches anything

  1050          mediaBySmilTag != EMsgMediaRef &&    //<ref> matches anything

  1051          media != mediaBySmilTag )

  1052         {

  1053         // SMIL does not describe content as it should

  1054         //MsgDataUTILSLOGGER_WRITE( "CUniSmilModel: Parsing: Smil object type differs from message object type." );

  1055         iParseResult |= EBadlyReferencedObjects;

  1056         }

  1057 

  1058     TUniRegion regionBySmilTag = EUniRegionUnresolved;

  1059     switch ( mediaBySmilTag )

  1060         {

  1061         case EMsgMediaAudio:

  1062             {

  1063             regionBySmilTag = EUniRegionAudio;

  1064             break;

  1065             }

  1066         case EMsgMediaImage:

  1067         case EMsgMediaVideo:

  1068             {

  1069             regionBySmilTag = EUniRegionImage;

  1070             break;

  1071             }

  1072         case EMsgMediaText:

  1073             {

  1074             regionBySmilTag = EUniRegionText;

  1075             break;

  1076             }

  1077         default:

  1078             break;

  1079         }

  1080 

  1081     TUniRegion regionByMediaType = EUniRegionUnresolved;

  1082     switch ( media )

  1083         {

  1084         case EMsgMediaAudio:

  1085             {

  1086             regionByMediaType = EUniRegionAudio;

  1087             break;

  1088             }

  1089         case EMsgMediaImage:

  1090         case EMsgMediaVideo:

  1091             {

  1092             regionByMediaType = EUniRegionImage;

  1093             break;

  1094             }

  1095         case EMsgMediaText:

  1096             {

  1097             regionByMediaType = EUniRegionText;

  1098             break;

  1099             }

  1100         default:

  1101             break;

  1102         }

  1103 

  1104     // Check that region type matches object media type

  1105     if ( aRegion != EUniRegionUnresolved &&

  1106         regionByMediaType != EUniRegionUnresolved &&

  1107         aRegion != regionByMediaType )

  1108         {

  1109         iParseResult |= ERegionMediaTypeMismatch;

  1110         aRegion = regionByMediaType;

  1111         }

  1112     else if ( regionByMediaType == EUniRegionUnresolved &&

  1113               aRegion == EUniRegionText )

  1114         {

  1115         // do not put every possible content into text reqion

  1116         iParseResult |= ERegionMediaTypeMismatch;

  1117         aRegion = EUniRegionUnresolved;

  1118         }

  1119     else if ( aRegion == EUniRegionUnresolved )

  1120         {

  1121         // If region couldn't be resolved from the region tag

  1122         // follow the media type. If that's not possible follow

  1123         // the smil media tag name. If everything fails

  1124         // "aRegion" will remain "unresolved".

  1125         aRegion = ( regionByMediaType != EUniRegionUnresolved )

  1126             ? regionByMediaType

  1127             : regionBySmilTag;

  1128         }

  1129 

  1130     CMsgMediaInfo* mediaInfo = aObj->MediaInfo();

  1131     // DRM2 must be put into object view in the viewer

  1132     if ( mediaInfo  &&

  1133          ( /*mediaInfo->HandlerApplicationUid().iUid == 0 ||*/