messagingapp/msgutils/unidatamodel/unimmsdataplugin/src/UniDataModel.cpp
changeset 25 84d9eb65b26f
parent 23 238255e8b033
child 27 e4592d119491
child 37 518b245aa84c
child 79 2981cb3aa489
equal deleted inserted replaced
23:238255e8b033 25:84d9eb65b26f
     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 *       Provides CUniDataModel class methods.
       
    16 *
       
    17 *
       
    18 */
       
    19 
       
    20 
       
    21 
       
    22 // ========== INCLUDE FILES ================================
       
    23 
       
    24 #include "debugtraces.h"
       
    25 
       
    26 #include <eikenv.h>
       
    27 #include <eikdoc.h>
       
    28 
       
    29 #include <msvstd.h>                     // TMsvEntry
       
    30 #include <msvapi.h>
       
    31 #include <msvuids.h>                    // Msgs Uids
       
    32 #include <mtclbase.h>                   // CBaseMtm
       
    33 #include <mmsvattachmentmanager.h>
       
    34 #include <cmsvattachment.h>
       
    35 #include <cmsvmimeheaders.h>
       
    36 
       
    37 #include <bautils.h>
       
    38 
       
    39 /*
       
    40 #include <muiumsvuiserviceutilities.h>  //Disk space check
       
    41 #include <msgattachmentinfo.h>
       
    42 */
       
    43 
       
    44 #include <gmxmldocument.h>
       
    45 #include <gmxmlnode.h>
       
    46 #include <gmxmlelement.h>
       
    47 
       
    48 // Features
       
    49 #include <featmgr.h>
       
    50 #include <bldvariant.hrh>
       
    51 
       
    52 // MsgMedia
       
    53 #include <MsgMediaResolver.h>
       
    54 #include <MsgMediaInfo.h>
       
    55 #include <MsgTextInfo.h>
       
    56 
       
    57 #include <MmsConformance.h>
       
    58 
       
    59 #include "UniDataModel.h"
       
    60 #include "UniSmilModel.h"
       
    61 
       
    62 #include "UniDataUtils.h"
       
    63 #include "UniModelConst.h"
       
    64 #include "UniObjectList.h"
       
    65 #include "UniSmilList.h"
       
    66 #include "UniObject.h"
       
    67 #include "UniTextObject.h"
       
    68 #include "UniMimeInfo.h"
       
    69 
       
    70 #include "UniSmilUtils.h"
       
    71 //#include "UniEditorLogging.h"
       
    72 //#include "messagingvariant.hrh"
       
    73 #include "MsgMimeTypes.h"
       
    74 #include <e32base.h>
       
    75 
       
    76 // ========== CONSTANTS ====================================
       
    77 
       
    78 // ---------------------------------------------------------
       
    79 // CUniDataModel::Constructor
       
    80 // ---------------------------------------------------------
       
    81 //
       
    82 CUniDataModel::CUniDataModel( RFs& aFs, CBaseMtm& aMtm ) :
       
    83     iFs( aFs ),
       
    84     iMtm( aMtm ),
       
    85     iSmilModel( NULL ),
       
    86     iDom( NULL )
       
    87     {
       
    88     }
       
    89 
       
    90 // ---------------------------------------------------------
       
    91 // CUniDataModel::NewL
       
    92 // ---------------------------------------------------------
       
    93 //
       
    94  CUniDataModel* CUniDataModel::NewL( RFs& aFs, CBaseMtm& aMtm )
       
    95     {
       
    96     CUniDataModel* self =  new ( ELeave ) CUniDataModel( aFs, aMtm );
       
    97     CleanupStack::PushL( self );
       
    98     self->ConstructL();
       
    99     CleanupStack::Pop( self );
       
   100     return self;
       
   101     }
       
   102 
       
   103 // ---------------------------------------------------------
       
   104 // CUniDataModel::ConstructL
       
   105 // ---------------------------------------------------------
       
   106 //
       
   107  void CUniDataModel::ConstructL()
       
   108     {
       
   109 #ifdef _DEBUG_TRACES_
       
   110     qCritical() << " CUniDataModel ConstructL start";
       
   111 #endif
       
   112     iDataUtils = CUniDataUtils::NewL( iFs );
       
   113     iObjectList = CUniObjectList::NewL( iMtm, *iDataUtils );
       
   114     iAttachmentList = CUniObjectList::NewL( iMtm, *iDataUtils );
       
   115     iSmilList = CUniSmilList::NewL( iMtm );
       
   116     iSmilModel = CUniSmilModel::NewL( iFs, iMtm, *iDataUtils, *iObjectList );
       
   117 
       
   118     iMediaResolver = CMsgMediaResolver::NewL();
       
   119     iMediaResolver->SetCharacterSetRecognition( EFalse );
       
   120 
       
   121     iMmsConformance = CMmsConformance::NewL();
       
   122     iMmsConformance->CheckCharacterSet( EFalse );
       
   123     
       
   124 #ifdef _DEBUG_TRACES_
       
   125     qCritical() << " CUniDataModel ConstructL End";
       
   126 #endif
       
   127     }
       
   128 
       
   129 // ---------------------------------------------------------
       
   130 // CUniDataModel::~CUniDataModel
       
   131 //
       
   132 // Destructor.
       
   133 // ---------------------------------------------------------
       
   134 //
       
   135  CUniDataModel::~CUniDataModel()
       
   136     {
       
   137     delete iMediaResolver;
       
   138     delete iMmsConformance;
       
   139     delete iSmilModel;
       
   140     delete iObjectList;
       
   141     delete iAttachmentList;
       
   142     delete iSmilList;
       
   143     delete iDataUtils;
       
   144     delete iParser;
       
   145     delete iDom;
       
   146     }
       
   147 
       
   148 // ---------------------------------------------------------
       
   149 // CUniDataModel::RestoreL
       
   150 //
       
   151 // Initialise the model.
       
   152 // ---------------------------------------------------------
       
   153 //
       
   154  void CUniDataModel::RestoreL(
       
   155         MUniDataModelObserver& aObserver,
       
   156         TBool aRemoveCorrupted /*= ETrue*/,
       
   157         TBool aAllowSmil /*= ETrue*/ )
       
   158     {
       
   159     iObserver = &aObserver;
       
   160     iSmilType = ENoSmil;
       
   161 
       
   162     if ( iMtm.Entry().HasStoreL() )
       
   163     	{
       
   164         FindAndHandleCorruptL( aRemoveCorrupted );
       
   165 
       
   166         TBool readOnly = iMtm.Entry().Entry().ReadOnly();
       
   167         CMsvStore* store = readOnly
       
   168         	? iMtm.Entry().ReadStoreL()
       
   169         	: iMtm.Entry().EditStoreL();
       
   170         CleanupStack::PushL( store );
       
   171         MMsvAttachmentManager& manager = store->AttachmentManagerL();
       
   172         CMsvMimeHeaders* msvMime = CMsvMimeHeaders::NewLC();
       
   173 
       
   174         iParseResult = 0;
       
   175 
       
   176         iOrigAttachmentCount = manager.AttachmentCount();
       
   177 
       
   178         for ( TInt i = 0; i < iOrigAttachmentCount ; i++ )
       
   179             {
       
   180             CMsvAttachment* attachment = manager.GetAttachmentInfoL( i );
       
   181             CleanupStack::PushL( attachment );
       
   182             msvMime->RestoreL( *attachment );
       
   183 
       
   184             TBuf8<KMaxDataTypeLength> contentType;
       
   185             contentType.Copy( msvMime->ContentType() );
       
   186             contentType.Append( _L8("/") );
       
   187             contentType.Append( msvMime->ContentSubType() );
       
   188 
       
   189             // Put smil attas to own array, except if SendUi
       
   190             if ( aAllowSmil &&
       
   191                 contentType.CompareF( KMsgMimeSmil ) == 0 )
       
   192                 {
       
   193                 iSmilList->AddSmilAttachmentL( manager, attachment->Id() );
       
   194                 CleanupStack::PopAndDestroy( attachment );
       
   195                 continue;
       
   196                 }
       
   197 
       
   198             RFile readFile = manager.GetAttachmentFileL( i );
       
   199             CleanupClosePushL( readFile );
       
   200             CUniObject* newObj = CreateObjectFromAttachmentLC(
       
   201                 contentType,
       
   202                 readFile,
       
   203                 manager,
       
   204                 *attachment );
       
   205 
       
   206             if ( newObj->Attachment() )
       
   207                 {
       
   208                 iAttachmentList->AddObjectL( newObj );
       
   209                 }
       
   210             else
       
   211                 {
       
   212                 iObjectList->AddObjectL( newObj );
       
   213                 }
       
   214 
       
   215             CleanupStack::Pop( newObj );
       
   216             CleanupStack::PopAndDestroy( &readFile );
       
   217             CleanupStack::PopAndDestroy( attachment );
       
   218             } // for
       
   219 
       
   220         CleanupStack::PopAndDestroy( msvMime );
       
   221 
       
   222 
       
   223 
       
   224         //UNILOGGER_WRITE_TIMESTAMP("CUniDataModel::RestoreL commit start");
       
   225 
       
   226 
       
   227         //UNILOGGER_WRITE_TIMESTAMP("CUniDataModel::RestoreL commit end");
       
   228         CleanupStack::PopAndDestroy( store );
       
   229 
       
   230         if ( iSmilList->Count() == 1 )
       
   231             {
       
   232             RFile smilFile = iDataUtils->GetAttachmentFileL( iMtm, iSmilList->GetSmilAttachmentByIndex( 0 ) );
       
   233             iParser = CMDXMLParser::NewL( this );
       
   234             iParser->ParseFile( smilFile );
       
   235             if( !iObjWait.IsStarted() )
       
   236                 {
       
   237                 iObjWait.Start();
       
   238                 }
       
   239             }
       
   240         else
       
   241             {
       
   242             if ( iSmilList->Count() > 1 )
       
   243                 {
       
   244                 iSmilType = EMultipleSmil;
       
   245                 }
       
   246             iParseResult = iSmilModel->ParseL( NULL ); // Try to create something anyway
       
   247             
       
   248             FinalizeRestoreL( KErrNone );
       
   249             }
       
   250     	}
       
   251     else
       
   252     	{
       
   253         FinalizeRestoreL( KErrNone );
       
   254     	}
       
   255     }
       
   256 
       
   257 // ---------------------------------------------------------
       
   258 // CUniDataModel::AddAttachmentL
       
   259 // ---------------------------------------------------------
       
   260 //
       
   261  CUniObject* CUniDataModel::AddAttachmentL(
       
   262         MUniObjectSaveObserver& aObserver,
       
   263         CMsgMediaInfo* aMedia,
       
   264         CMsvAttachment::TMsvAttachmentType aSaveType /*= CMsvAttachment::EMsvLinkedFile*/ )
       
   265     {
       
   266     CUniObject* obj = CUniObject::NewLC( iFs, iMtm, *iDataUtils, aMedia );
       
   267 
       
   268     // Update attachment list
       
   269     iAttachmentList->AddObjectL( obj );
       
   270     obj->SetAttachment( ETrue );
       
   271 
       
   272     CleanupStack::Pop( obj );
       
   273     obj->Save( aObserver, aSaveType );
       
   274 
       
   275     return obj;
       
   276     }
       
   277 
       
   278 // ---------------------------------------------------------
       
   279 // CUniDataModel::AddStoredAttachmentL
       
   280 // ---------------------------------------------------------
       
   281 //
       
   282  CUniObject* CUniDataModel::AddStoredAttachmentL( TMsvAttachmentId aAttachmentId,
       
   283                                                           CMsgMediaInfo* aMedia )
       
   284     {
       
   285     CMsvStore* store = iMtm.Entry().EditStoreL();
       
   286     CleanupStack::PushL( store );
       
   287 
       
   288     MMsvAttachmentManager& manager = store->AttachmentManagerL();
       
   289     MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();
       
   290     CMsvAttachment* attachment = manager.GetAttachmentInfoL( aAttachmentId );
       
   291     CleanupStack::PushL( attachment );
       
   292 
       
   293     CUniObject* obj = CUniObject::NewLC( iFs, iMtm, *iDataUtils, aMedia, manager, *attachment );
       
   294 
       
   295     managerSync.ModifyAttachmentInfoL( attachment );
       
   296     CleanupStack::Pop( 2, attachment ); //obj, attachment
       
   297     CleanupStack::PushL( obj );
       
   298     store->CommitL();
       
   299 
       
   300     // Update attachment list
       
   301     iAttachmentList->AddObjectL( obj );
       
   302     obj->SetAttachment( ETrue );
       
   303 
       
   304     CleanupStack::Pop( obj );
       
   305     CleanupStack::PopAndDestroy( store );
       
   306     return obj;
       
   307     }
       
   308 
       
   309 // ---------------------------------------------------------
       
   310 // CUniDataModel::FinalizeMediaParse
       
   311 // ---------------------------------------------------------
       
   312 //
       
   313  void CUniDataModel::FinalizeMediaParse()
       
   314     {
       
   315     while ( iObjectToParse )
       
   316         {
       
   317         if ( !iObjWait.IsStarted() )
       
   318             {
       
   319             iObjWait.Start();
       
   320             }
       
   321         }
       
   322     }
       
   323 
       
   324 // ---------------------------------------------------------
       
   325 // CUniDataModel::MediaInfoParsed
       
   326 // ---------------------------------------------------------
       
   327 //
       
   328 void CUniDataModel::MediaInfoParsed()
       
   329     {
       
   330     if ( iObjectToParse->MediaInfo()->Corrupt() )
       
   331         {
       
   332         iObjectToParse->SetCorrupted( ETrue );
       
   333         }
       
   334     ParseNextObject();
       
   335     if ( iObjWait.IsStarted() )
       
   336         {
       
   337         iObjWait.AsyncStop();
       
   338         }
       
   339   //  CActiveScheduler::Stop();
       
   340     }
       
   341 
       
   342 // ---------------------------------------------------------
       
   343 // CUniDataModel::ParseNextObject
       
   344 // ---------------------------------------------------------
       
   345 //
       
   346 void CUniDataModel::ParseNextObject()
       
   347     {
       
   348     CUniObjectList* list = iObjectList;
       
   349 
       
   350     while ( list )
       
   351         {
       
   352         for ( TInt i = 0; i < list->Count(); i++ )
       
   353             {
       
   354             iObjectToParse = list->GetByIndex( i );
       
   355             if ( !iObjectToParse->MediaInfo()->Parsed() &&
       
   356                  !iObjectToParse->MediaInfo()->ParseError() )
       
   357                 {
       
   358                 RFile file;
       
   359                 TRAPD( error, file = iDataUtils->GetAttachmentFileL( iMtm, iObjectToParse->AttachmentId() ) );
       
   360 
       
   361                 if ( error == KErrNone )
       
   362                     {
       
   363                     iObjectToParse->MediaInfo()->ParseInfoDetails( file, *( iMediaResolver->DRMHelper() ), *this );
       
   364                    // CActiveScheduler::Start();
       
   365                     file.Close();
       
   366                     return;
       
   367                     }
       
   368                 else
       
   369                     {
       
   370                     iObjectToParse->SetCorrupted( ETrue );
       
   371                     file.Close();
       
   372                     }
       
   373                 }
       
   374             }
       
   375         if ( list == iObjectList )
       
   376             {
       
   377             list = iAttachmentList;
       
   378             }
       
   379         else
       
   380             {
       
   381             list = NULL;
       
   382             }
       
   383         }
       
   384    iObjectToParse = NULL;
       
   385    }
       
   386 
       
   387 // ---------------------------------------------------------
       
   388 // CUniDataModel::ParseFileCompleteL
       
   389 // ---------------------------------------------------------
       
   390 //
       
   391 void CUniDataModel::ParseFileCompleteL()
       
   392     {
       
   393     TRAPD( err, DoParseFileCompleteL() );
       
   394     FinalizeRestoreL( err );
       
   395     }
       
   396 
       
   397 // ---------------------------------------------------------
       
   398 // CUniDataModel::DoParseFileCompleteL
       
   399 // ---------------------------------------------------------
       
   400 //
       
   401 void CUniDataModel::DoParseFileCompleteL()
       
   402     {
       
   403     iDom = iParser->DetachXMLDoc();
       
   404     iSmilType = UniSmilUtils::GetSmilTypeL( iDom );
       
   405     if ( iSmilType == ENoSmil )
       
   406         {
       
   407         iParseResult = iSmilModel->ParseL( NULL );
       
   408         }
       
   409     else if ( iSmilType == EMmsSmil )
       
   410         {
       
   411         TRAPD( err, ( iParseResult = iSmilModel->ParseL( iDom ) ) );
       
   412         if ( err )
       
   413             {
       
   414             iSmilType = E3GPPSmil;
       
   415             iParseResult = 0;
       
   416             FindDomObjectRefCountsL();
       
   417             }
       
   418         }
       
   419     else
       
   420         {
       
   421         FindDomObjectRefCountsL();
       
   422         }
       
   423     }
       
   424 
       
   425 
       
   426 // ---------------------------------------------------------
       
   427 // CUniDataModel::FinalizeRestoreL
       
   428 // ---------------------------------------------------------
       
   429 //
       
   430 void CUniDataModel::FinalizeRestoreL( TInt aError )
       
   431     {
       
   432     if ( !aError )
       
   433         {
       
   434         // Won't leave.
       
   435         FindAttachmentsL();
       
   436         }
       
   437     iObserver->RestoreReady( iParseResult, aError );
       
   438 
       
   439     ParseNextObject();
       
   440     
       
   441     if ( iObjWait.IsStarted() )
       
   442         {
       
   443         iObjWait.AsyncStop();
       
   444         }
       
   445     
       
   446     }
       
   447 
       
   448 // ---------------------------------------------------------
       
   449 // CUniSmilModel::FindAttachmentsL
       
   450 //
       
   451 //
       
   452 // ---------------------------------------------------------
       
   453 //
       
   454 void CUniDataModel::FindAttachmentsL()
       
   455     {
       
   456     for ( TInt i = iObjectList->Count(); --i >= 0; )
       
   457         {
       
   458         CUniObject* obj = iObjectList->GetByIndex( i );
       
   459         if ( !obj->ReferenceCount() )
       
   460             {
       
   461             //don't remove from store -> cannot leave
       
   462             iObjectList->RemoveObjectL( obj, EFalse );
       
   463             iAttachmentList->AddObjectL( obj );
       
   464             obj->SetAttachment( ETrue );
       
   465             }
       
   466         }
       
   467     }
       
   468 
       
   469 // ---------------------------------------------------------
       
   470 // FindAndHandleCorruptL
       
   471 //
       
   472 // ---------------------------------------------------------
       
   473 void CUniDataModel::FindAndHandleCorruptL( TBool aRemoveCorrupted )
       
   474     {
       
   475     CMsvEntrySelection* corSel = FindCorruptLC();
       
   476     iCorruptedCount = corSel->Count();
       
   477 
       
   478     if ( iCorruptedCount > 0 )
       
   479         {
       
   480         if ( aRemoveCorrupted )
       
   481             {
       
   482             CMsvStore* store = iMtm.Entry().EditStoreL();
       
   483             CleanupStack::PushL( store );
       
   484             MMsvAttachmentManager& manager = store->AttachmentManagerL();
       
   485             MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();
       
   486 
       
   487             for (TInt i = iCorruptedCount; --i >= 0 ;)
       
   488                 {
       
   489                 // Editor tries to recover by deleting corrupted ones
       
   490                 // Note: This means that SMIL parsing will fail with ESmil_Missing_Objects.
       
   491                 //       and object order is not maintained. But better to do it this
       
   492                 //       way so that message can be opened.
       
   493                 TRAP_IGNORE ( managerSync.RemoveAttachmentL(
       
   494                     CUniDataUtils::IndexPositionOfAttachmentL( manager, corSel->At( i ) ) ) );
       
   495                 }
       
   496             store->CommitL();
       
   497             CleanupStack::PopAndDestroy( store );
       
   498             }
       
   499         else
       
   500             {
       
   501             // In viewer case consider message corrupted and leave.
       
   502             // Model not made viewer should exit.
       
   503             User::Leave( KErrCorrupt );
       
   504             }
       
   505         }
       
   506 
       
   507     CleanupStack::PopAndDestroy( corSel );
       
   508     }
       
   509 
       
   510 // ---------------------------------------------------------
       
   511 // FindCorruptLC
       
   512 //
       
   513 // ---------------------------------------------------------
       
   514 CMsvEntrySelection* CUniDataModel::FindCorruptLC()
       
   515     {
       
   516     CMsvEntrySelection* corrupts = new(ELeave) CMsvEntrySelection();
       
   517     CleanupStack::PushL( corrupts );
       
   518 
       
   519     if ( iMtm.Entry().HasStoreL() )
       
   520     	{
       
   521         CMsvStore* store = iMtm.Entry().ReadStoreL();
       
   522         CleanupStack::PushL( store );
       
   523         MMsvAttachmentManager& manager = store->AttachmentManagerL();
       
   524 
       
   525         TInt count = manager.AttachmentCount();
       
   526         for( TInt i = count; --i >= 0; )
       
   527             {
       
   528             CMsvAttachment* atta = manager.GetAttachmentInfoL( i );
       
   529             TMsvAttachmentId attaId = atta->Id();
       
   530             delete atta;
       
   531 
       
   532             RFile attaFile;
       
   533             TRAPD( err, attaFile = manager.GetAttachmentFileL( attaId ) );
       
   534             // if error, hardly no need to close
       
   535             attaFile.Close();
       
   536             if ( err )
       
   537                 {
       
   538                 corrupts->AppendL( attaId );
       
   539                 }
       
   540             }
       
   541 
       
   542         CleanupStack::PopAndDestroy( store );
       
   543     	}
       
   544     return corrupts;
       
   545     }
       
   546 
       
   547 // ---------------------------------------------------------
       
   548 // CreateObjectFromAttachmentLC
       
   549 //
       
   550 // ---------------------------------------------------------
       
   551 CUniObject* CUniDataModel::CreateObjectFromAttachmentLC(
       
   552                             const TPtrC8&               aMimeType,
       
   553                             RFile&                      aFile,
       
   554                             MMsvAttachmentManager&      aManager,
       
   555                             CMsvAttachment&             aAttachment )
       
   556     {
       
   557     // Linked attachments are handles similarly as ordinary ones.
       
   558     CUniObject* object = NULL;
       
   559     CMsgMediaInfo* info = NULL;
       
   560     if ( aMimeType.CompareF( KMsgMimeTextPlain ) == 0 )
       
   561         {
       
   562         TDataType mimeType( aMimeType );
       
   563         info = iMediaResolver->CreateMediaInfoL( aFile, mimeType );
       
   564         }
       
   565     else
       
   566         {
       
   567         info = iMediaResolver->CreateMediaInfoL( aFile );
       
   568         }
       
   569 
       
   570     if ( info->MediaType() == EMsgMediaText ||
       
   571          info->MediaType() == EMsgMediaXhtml )
       
   572         {
       
   573         object = CUniTextObject::NewLC(
       
   574             iFs,
       
   575             iMtm,
       
   576             *iDataUtils,
       
   577             static_cast< CMsgTextInfo* >( info ),
       
   578             aManager,
       
   579             aAttachment );
       
   580         }
       
   581     else
       
   582         {
       
   583         object = CUniObject::NewLC(
       
   584             iFs,
       
   585             iMtm,
       
   586             *iDataUtils,
       
   587             info,
       
   588             aManager,
       
   589             aAttachment );
       
   590         }
       
   591     // Media info is to be parsed asynchronously!
       
   592 
       
   593     return object;
       
   594     }
       
   595 
       
   596 // ---------------------------------------------------------
       
   597 // GetDomObjectRefCounts
       
   598 //
       
   599 // ---------------------------------------------------------
       
   600 void CUniDataModel::FindDomObjectRefCountsL()
       
   601     {
       
   602     CMDXMLNode* node = iDom->DocumentElement()->FirstChild();
       
   603     CUniObject* obj = NULL;
       
   604 
       
   605     while ( node )
       
   606         {
       
   607         if ( UniSmilUtils::IsMediaElem( node ) ) // Filtering of structural nodes.
       
   608             {
       
   609             obj = iObjectList->GetByNodeL( node );
       
   610             if ( obj )
       
   611                 {
       
   612                 obj->SetReferenceCount( obj->ReferenceCount() + 1 );
       
   613                 }
       
   614 
       
   615             }
       
   616         node = UniSmilUtils::NextNode( node );
       
   617         }
       
   618 
       
   619     }
       
   620 
       
   621 //  End of File