1 /*

     2 * Copyright (c) 2005-2007 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:  Transaction factory implementation

    15 *

    16 */

    17 

    18 

    19 #include    "transactionfactoryimpl.h"

    20 

    21 #include    "transaction.h"

    22 #include    "texttransactionelement.h"

    23 #include    "databuffertransactionelement.h"

    24 #include    "imagetransactionelement.h"

    25 #include    "emptycontenttransactionelement.h"

    26 #include    "newstickertransactionelement.h"

    27 #include    "aixmluiconstants.h"

    28 

    29 using namespace AiXmlUiController;

    30 

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

    32 

    33 CTransactionFactoryImpl::CTransactionFactoryImpl(

    34                             AiUtility::CContentPriorityMap& aContentPriorityMap,

    35                             CCssPropertyMap& aPropertyMap )

    36     : iAvailableTransactions( CTransaction::FactoryLinkOffset() ),

    37       iReservedTransactions( CTransaction::FactoryLinkOffset() ),

    38       iAvailableElements( CTransactionElement::FactoryLinkOffset() ),

    39       iReservedElements( CTransactionElement::FactoryLinkOffset() ),

    40       iContentPriorityMap( aContentPriorityMap ),

    41       iPropertyMap( aPropertyMap )

    42     {

    43     }

    44 

    45 CTransactionFactoryImpl* CTransactionFactoryImpl::NewL(

    46                             AiUtility::CContentPriorityMap& aContentPriorityMap,

    47                             CCssPropertyMap& aPropertyMap )

    48     {

    49     CTransactionFactoryImpl* self =

    50                 new( ELeave ) CTransactionFactoryImpl( aContentPriorityMap,

    51                                                        aPropertyMap );

    52     

    53     return self;

    54     }

    55     

    56 CTransactionFactoryImpl::~CTransactionFactoryImpl()

    57     {

    58     // Delete transaction objects

    59     DeleteTransactionList( iAvailableTransactions );

    60     DeleteTransactionList( iReservedTransactions );

    61     

    62     // Delete transaction elements

    63     DeleteElementList( iAvailableElements );

    64     DeleteElementList( iReservedElements );

    65     }

    66 

    67 MTransaction* CTransactionFactoryImpl::CreateTransactionL( TInt aTxId )

    68     {

    69     CTransaction* tr = NULL;

    70     

    71     if ( iAvailableTransactions.IsEmpty() ) // No free transactions

    72         {

    73         tr = CTransaction::NewL();

    74         }

    75     else

    76         {

    77         // Take first available transaction and remove from queue

    78         tr = iAvailableTransactions.First();

    79         iAvailableTransactions.Remove( *tr );

    80         }

    81     

    82     // Initialize with id

    83     tr->Initialize(aTxId);

    84     

    85     // Reserve

    86     iReservedTransactions.AddFirst( *tr );

    87 

    88     return tr;

    89     }

    90             

    91 void CTransactionFactoryImpl::ReleaseTransaction( MTransaction* aTransaction )

    92     {

    93     CTransaction* tr = dynamic_cast< CTransaction* >( aTransaction );

    94     if ( tr )

    95         {

    96         // Reset transaction for reuse

    97         tr->Reset( *this );

    98         

    99         // Deque from reserved list

   100         iReservedTransactions.Remove( *tr );

   101         

   102         // Enque to available list

   103         iAvailableTransactions.AddFirst( *tr );

   104         }

   105     }

   106 

   107 MTransactionElement* CTransactionFactoryImpl::CreateTextTransactionElementL(

   108     CXnNodeAppIf& aTarget,

   109     const TDesC& aText,

   110     TInt aPriority )

   111     {

   112     // Instantiate new element

   113     CTextTransactionElement* element = NewInstanceL< CTextTransactionElement >();

   114     

   115     CleanupStack::PushL( element );

   116     

   117     // Initialize element

   118     element->InitializeL( aTarget, aText );

   119     

   120     CleanupStack::Pop( element );

   121     

   122     // Reserve

   123     iReservedElements.AddLast( *element );

   124     

   125     // Set content priority

   126     element->SetContentPriority( aPriority );

   127     

   128     return element;

   129     }

   130 

   131 MTransactionElement*

   132     CTransactionFactoryImpl::CreateDataBufferTransactionElementL(

   133         CXnNodeAppIf& aTarget,

   134         const TDesC8& aData,

   135         TInt aPriority )

   136     {

   137     // Instantiate element

   138     CDataBufferTransactionElement* element = NewInstanceL< CDataBufferTransactionElement >();

   139     CleanupStack::PushL( element );

   140     

   141     // Initialize

   142     element->InitializeL( aTarget, aData );

   143     CleanupStack::Pop( element );

   144     

   145     // Reserve

   146     iReservedElements.AddLast( *element );

   147     

   148     // Set content priority

   149     element->SetContentPriority( aPriority );

   150     

   151     return element;

   152     }    

   153 

   154 MTransactionElement*

   155     CTransactionFactoryImpl::CreateDataBufferTransactionElementL(

   156         CXnNodeAppIf& aTarget,

   157         const TDesC8& aData,

   158         TInt aPriority,

   159         const TDesC& aCid, 

   160         TInt aIndex )

   161     {

   162     // Instantiate element

   163     CDataBufferTransactionElement* element = NewInstanceL< CDataBufferTransactionElement >();

   164     CleanupStack::PushL( element );

   165     

   166     // Initialize

   167     element->InitializeL( aTarget, aData, aCid, aIndex );

   168     CleanupStack::Pop( element );

   169     

   170     // Reserve

   171     iReservedElements.AddLast( *element );

   172     

   173     // Set content priority

   174     element->SetContentPriority( aPriority );

   175         

   176     return element;

   177     }    

   178 

   179 MTransactionElement*

   180     CTransactionFactoryImpl::CreateEmptyContentTransactionElementL(

   181         CXnNodeAppIf& aTarget,

   182         TInt aIndex)

   183     {

   184     // Instantiate

   185     CEmptyContentTransactionElement* element = NewInstanceL< CEmptyContentTransactionElement >();

   186     

   187     CleanupStack::PushL( element );

   188     

   189     // Initialize

   190     element->InitializeL( aTarget, aIndex );

   191     

   192     CleanupStack::Pop( element );

   193     

   194     // Reserve

   195     iReservedElements.AddLast( *element );

   196     

   197     return element;

   198     }

   199   

   200 MTransactionElement* CTransactionFactoryImpl::CreateImageTransactionElementL( CXnNodeAppIf& aTarget,

   201                                                                               CGulIcon* aIcon,

   202                                                                               TInt aPriority )

   203     {

   204     // Instantiate

   205     CImageTransactionElement* element = NewInstanceL< CImageTransactionElement >();

   206     

   207     CleanupStack::PushL( element );

   208     

   209     // Initialize

   210     element->InitializeL( aTarget, aIcon );

   211     

   212     CleanupStack::Pop( element );

   213     

   214     // Reserve

   215     iReservedElements.AddLast( *element );

   216     

   217     // Set priority

   218     element->SetContentPriority( aPriority );

   219     

   220     return element;

   221     }

   222 

   223 MTransactionElement* CTransactionFactoryImpl::CreateImageTransactionElementL(

   224     CXnNodeAppIf& aTarget,

   225     RFile& aFile,

   226     TInt aPriority )

   227     {

   228     // Instantiate

   229     CImageTransactionElement* element = NewInstanceL< CImageTransactionElement >();

   230     

   231     CleanupStack::PushL( element );

   232     

   233     // Initialize

   234     element->InitializeL( aTarget, aFile );

   235     

   236     CleanupStack::Pop( element );

   237     

   238     // Reserve

   239     iReservedElements.AddLast( *element );

   240     

   241     // Set priority

   242     element->SetContentPriority( aPriority );

   243     

   244     return element;

   245     }

   246 

   247 MTransactionElement* CTransactionFactoryImpl::CreateNewsTickerTransactionElementL(

   248     CXnNodeAppIf& aTarget,

   249     const TDesC& aText,

   250     TInt aPriority, 

   251     TInt aIndex )

   252     {

   253     // Instantiate new element

   254     CNewsTickerTransactionElement* element = NewInstanceL< CNewsTickerTransactionElement >();

   255     

   256     CleanupStack::PushL( element );

   257     

   258     // Initialize element

   259     element->InitializeL( aTarget, aText, aIndex );

   260     

   261     CleanupStack::Pop( element );

   262     

   263     // Reserve

   264     iReservedElements.AddLast( *element );

   265     

   266     // Set content priority

   267     element->SetContentPriority( aPriority );

   268     

   269     return element;

   270     }

   271             

   272 void CTransactionFactoryImpl::ReleaseTransactionElement( MTransactionElement* aElement)

   273     {

   274     CTransactionElement* element = dynamic_cast< CTransactionElement* >( aElement );

   275     

   276     if ( element )

   277         {

   278         // Reset element

   279         element->Reset();

   280         

   281         // Move element from reserved list to available

   282         iReservedElements.Remove( *element );

   283         iAvailableElements.AddFirst( *element );

   284         }

   285     }

   286 

   287 TBool CTransactionFactoryImpl::IsSupported( CXnNodeAppIf& aTarget, const TDesC8& aContentType )

   288     {

   289     // Check if target node and content type is supported

   290     if ( aContentType == KContentTypeText )

   291         {

   292         return CTextTransactionElement::IsSupported( aTarget ) || CNewsTickerTransactionElement::IsSupported( aTarget );

   293         }

   294     else if ( aContentType == KContentTypeBitmap )

   295         {

   296         return CImageTransactionElement::IsSupported( aTarget );

   297         }

   298     else

   299         {

   300         return CDataBufferTransactionElement::IsSupported( aTarget, aContentType ); 

   301         }

   302     }

   303 

   304 template< class T > T* CTransactionFactoryImpl::NewInstanceL()

   305     {

   306     T* instance = NULL;

   307     

   308     // Iterate list of transaction elements

   309     TSglQueIter< CTransactionElement > iter( iAvailableElements );

   310     iter.SetToFirst();

   311     

   312     while ( iter )

   313         {

   314         instance = dynamic_cast< T* >( iter++ );   // NULL if not T*

   315         

   316         if ( instance )

   317             {

   318             // Deque first instance of class T and quit

   319             iAvailableElements.Remove( *instance );

   320             return instance;

   321             }

   322         }

   323     

   324     // Not found from list. Instantiate

   325     instance = T::NewL(iContentPriorityMap);

   326     instance->SetCssPropertyMap( &iPropertyMap );    

   327     

   328     return instance;

   329     }

   330 

   331 void CTransactionFactoryImpl::DeleteTransactionList( TSglQue< CTransaction >& aList )

   332     {

   333     TSglQueIter< CTransaction > trIter( aList );

   334     trIter.SetToFirst();

   335     

   336     while (trIter)

   337         {

   338         // Get first transaction and remove it from the list

   339         CTransaction* first = trIter++;

   340         aList.Remove( *first );

   341         

   342         // Delete

   343         first->Reset( *this );

   344         delete first;

   345         }

   346     }

   347             

   348 void CTransactionFactoryImpl::DeleteElementList( TSglQue< CTransactionElement >& aList )

   349     {

   350     TSglQueIter< CTransactionElement > iter( aList );

   351     iter.SetToFirst();

   352         

   353     while ( iter )

   354         {

   355         CTransactionElement* element = iter++;

   356         aList.Remove( *element );

   357         

   358         delete element;

   359         }

   360     }

   361 

   362 //  End of File