1 /*

     2 * Copyright (c) 2006-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:  Class for encapsulating the data source for objects.

    15  *

    16 */

    17 

    18 #include <fbs.h>

    19 

    20 #include "thumbnailobjectsource.h"

    21 

    22 

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

    24 

    25 // ---------------------------------------------------------------------------

    26 // CThumbnailObjectSource::NewL()

    27 // Two-phased constructor.

    28 // ---------------------------------------------------------------------------

    29 //

    30 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC&

    31     aUri, const TDesC& aMimeType )

    32     {

    33     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aUri,

    34         aMimeType );

    35     CleanupStack::Pop( self );

    36     return self;

    37     }

    38 

    39 

    40 // ---------------------------------------------------------------------------

    41 // CThumbnailObjectSource::NewLC()

    42 // Two-phased constructor.

    43 // ---------------------------------------------------------------------------

    44 //

    45 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC&

    46     aUri, const TDesC& aMimeType )

    47     {

    48     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();

    49     CleanupStack::PushL( self );

    50     self->ConstructL( aUri, aMimeType );

    51     return self;

    52     }

    53 

    54 // ---------------------------------------------------------------------------

    55 // CThumbnailObjectSource::NewL()

    56 // Two-phased constructor.

    57 // ---------------------------------------------------------------------------

    58 //

    59 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const RFile64&

    60     aFile, const TDesC& aMimeType )

    61     {

    62     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aFile,

    63         aMimeType );

    64     CleanupStack::Pop( self );

    65     return self;

    66     }

    67 

    68 

    69 // ---------------------------------------------------------------------------

    70 // CThumbnailObjectSource::NewLC()

    71 // Two-phased constructor.

    72 // ---------------------------------------------------------------------------

    73 //

    74 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const RFile64&

    75     aFile, const TDesC& aMimeType )

    76     {

    77     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();

    78     CleanupStack::PushL( self );

    79     self->ConstructL( aFile, aMimeType );

    80     return self;

    81     }

    82 

    83 

    84 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( CFbsBitmap*  aBitmap, const TDesC& aUri )

    85     {

    86     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBitmap, aUri );

    87     CleanupStack::Pop( self );

    88     return self;   

    89     }

    90 

    91 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( CFbsBitmap*  aBitmap, const TDesC& aUri )

    92     {

    93     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();

    94     CleanupStack::PushL( self );

    95     self->ConstructL( aBitmap, aUri );

    96     return self;

    97     }

    98 

    99 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( TDesC8* aBuffer,  TDesC& aMimeType, const TDesC& aUri)

   100     {

   101     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBuffer, aMimeType, aUri );

   102     CleanupStack::Pop( self );

   103     return self;   

   104     }

   105 

   106 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( TDesC8* aBuffer,  TDesC& aMimeType, const TDesC& aUri)

   107     {

   108     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();

   109     CleanupStack::PushL( self );

   110     self->ConstructL( aBuffer, aMimeType, aUri );

   111     return self;

   112     }

   113    

   114 

   115 // ---------------------------------------------------------------------------

   116 // CThumbnailObjectSource::CThumbnailObjectSource()

   117 // C++ default constructor can NOT contain any code, that might leave.

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

   119 //

   120 CThumbnailObjectSource::CThumbnailObjectSource()

   121     {

   122     // No implementation required

   123     }

   124 

   125 

   126 // ---------------------------------------------------------------------------

   127 // CThumbnailObjectSource::ConstructL()

   128 // Symbian 2nd phase constructor can leave.

   129 // ---------------------------------------------------------------------------

   130 //

   131 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&

   132     aMimeType)

   133     {

   134     iUri = aUri.AllocL();

   135     iMimeType = HBufC8::NewL( aMimeType.Length() );

   136     iMimeType->Des().Copy( aMimeType );

   137     }

   138 

   139 

   140 // ---------------------------------------------------------------------------

   141 // CThumbnailObjectSource::ConstructL()

   142 // Symbian 2nd phase constructor can leave.

   143 // ---------------------------------------------------------------------------

   144 //

   145 void CThumbnailObjectSource::ConstructL( const RFile64& aFile, const TDesC&

   146     aMimeType )

   147     {

   148     iFile = aFile;

   149     iMimeType = HBufC8::NewL( aMimeType.Length() );

   150     iMimeType->Des().Copy( aMimeType );

   151     iThumbnailId = 0;

   152     }

   153 

   154 // ---------------------------------------------------------------------------

   155 // CThumbnailObjectSource::ConstructL()

   156 // Symbian 2nd phase constructor can leave.

   157 // ---------------------------------------------------------------------------

   158 //

   159 void CThumbnailObjectSource::ConstructL( CFbsBitmap* aBitmap, const TDesC&

   160         aUri )

   161     {

   162     iBitmap = aBitmap;

   163     iUri = aUri.AllocL();

   164     iThumbnailId = 0;

   165     }

   166 

   167 // ---------------------------------------------------------------------------

   168 // CThumbnailObjectSource::ConstructL()

   169 // Symbian 2nd phase constructor can leave.

   170 // ---------------------------------------------------------------------------

   171 //

   172 void CThumbnailObjectSource::ConstructL( TDesC8* aBuffer, const TDesC&

   173     aMimeType, const TDesC& aUri )

   174     {

   175     iBuffer = aBuffer;

   176     iMimeType = HBufC8::NewL( aMimeType.Length() );

   177     iMimeType->Des().Copy( aMimeType );

   178     iUri = aUri.AllocL(); 

   179     iThumbnailId = 0;

   180     }

   181 

   182 // ---------------------------------------------------------------------------

   183 // CThumbnailObjectSource::ConstructL()

   184 // Symbian 2nd phase constructor can leave.

   185 // ---------------------------------------------------------------------------

   186 //

   187 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&

   188     aMimeType, TThumbnailId aThumbnailId )

   189     {

   190     iUri = aUri.AllocL();

   191     iMimeType = HBufC8::NewL( aMimeType.Length() );

   192     iMimeType->Des().Copy( aMimeType );

   193     iThumbnailId = aThumbnailId;

   194     }

   195 

   196 

   197 // ---------------------------------------------------------------------------

   198 // CThumbnailObjectSource::~CThumbnailObjectSource()()

   199 // Destructor.

   200 // ---------------------------------------------------------------------------

   201 //

   202 CThumbnailObjectSource::~CThumbnailObjectSource()

   203     {

   204     delete iUri;

   205     delete iMimeType;

   206     delete iBuffer;

   207     delete iBitmap;

   208     }

   209 

   210 

   211 // ---------------------------------------------------------------------------

   212 // CThumbnailObjectSourceImpl::FileHandle()

   213 // ---------------------------------------------------------------------------

   214 //

   215 EXPORT_C  RFile64& CThumbnailObjectSource::FileHandle()

   216     {

   217     return iFile;

   218     }

   219 

   220 

   221 // ---------------------------------------------------------------------------

   222 // CThumbnailObjectSourceImpl::Uri()

   223 // ---------------------------------------------------------------------------

   224 //

   225 EXPORT_C const TDesC& CThumbnailObjectSource::Uri()

   226     {

   227     if ( iUri )

   228         {

   229         return * iUri;

   230         }

   231     return KNullDesC;

   232     }

   233 

   234 // ---------------------------------------------------------------------------

   235 // CThumbnailObjectSourceImpl::Buffer()

   236 // ---------------------------------------------------------------------------

   237 //

   238 EXPORT_C TDesC8* CThumbnailObjectSource::Buffer()

   239     {

   240     return iBuffer;

   241     }

   242 

   243 // ---------------------------------------------------------------------------

   244 // CThumbnailObjectSourceImpl::GetBufferOwnership()

   245 // ---------------------------------------------------------------------------

   246 //

   247 EXPORT_C TDesC8* CThumbnailObjectSource::GetBufferOwnership()

   248     {

   249     TDesC8* temp = iBuffer;

   250     iBuffer = NULL;

   251     return temp;

   252     }

   253 

   254 // ---------------------------------------------------------------------------

   255 // CThumbnailObjectSourceImpl::aMimeType()

   256 // ---------------------------------------------------------------------------

   257 //

   258 EXPORT_C const TDesC8& CThumbnailObjectSource::MimeType()

   259     {

   260     if ( iMimeType )

   261         {

   262         return *iMimeType;

   263         }

   264     return KNullDesC8;

   265     }

   266 

   267 EXPORT_C TThumbnailId CThumbnailObjectSource::Id()

   268     {

   269     return iThumbnailId;

   270     }

   271 	

   272 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC&

   273 aUri, const TThumbnailId aThumbnailId, const TDesC& aMimeType )

   274 {

   275 CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aUri,

   276         aThumbnailId, aMimeType );

   277 CleanupStack::Pop( self );

   278 return self;

   279     }

   280 

   281 

   282 // ---------------------------------------------------------------------------

   283 // CThumbnailObjectSource::NewLC()

   284 // Two-phased constructor.

   285 // ---------------------------------------------------------------------------

   286 //

   287 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC& aUri, 

   288 	const TThumbnailId aThumbnailId, const TDesC& aMimeType )

   289     {

   290     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();

   291     CleanupStack::PushL( self );

   292     self->ConstructL( aUri, aMimeType, aThumbnailId );

   293     return self;

   294     }

   295 

   296 // ---------------------------------------------------------------------------

   297 // CThumbnailObjectSourceImpl::Bitmap()

   298 // ---------------------------------------------------------------------------

   299 //

   300 EXPORT_C CFbsBitmap* CThumbnailObjectSource::Bitmap()

   301     {

   302     return iBitmap;

   303     }

   304 

   305 // ---------------------------------------------------------------------------

   306 // CThumbnailObjectSourceImpl::GetBitmapOwnership()

   307 // ---------------------------------------------------------------------------

   308 //

   309 EXPORT_C CFbsBitmap* CThumbnailObjectSource::GetBitmapOwnership()

   310     {

   311     CFbsBitmap* temp = iBitmap;

   312     iBitmap = NULL;

   313     return temp;

   314     }

   315 

   316 // End of file