Mercurial Mercurial > oss > MCL > sf > mw > imghandling / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailobjectsource.cpp
branchRCL_3
changeset 20 2b4b06654caa
parent 19 f759b6186ab5
equal deleted inserted replaced
19:f759b6186ab5 20:2b4b06654caa 
    22 
    22 
    23 // ======== MEMBER FUNCTIONS ========
 
    23 // ======== MEMBER FUNCTIONS ========
 
    24 
    24 
    25 // ---------------------------------------------------------------------------
 
    25 // ---------------------------------------------------------------------------
 
    26 // CThumbnailObjectSource::NewL()
 
    26 // CThumbnailObjectSource::NewL()
 
       
    27 // CThumbnailObjectSource::NewLC()
 
    27 // Two-phased constructor.
 
    28 // Two-phased constructor.
 
    28 // ---------------------------------------------------------------------------
 
    29 // ---------------------------------------------------------------------------
 
    29 //
 
    30 //
 
    30 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC&
 
    31 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC&
 
    31     aUri, const TDesC& aMimeType )
 
    32     aUri, const TDesC& aMimeType )
 
    34         aMimeType );
 
    35         aMimeType );
 
    35     CleanupStack::Pop( self );
 
    36     CleanupStack::Pop( self );
 
    36     return self;
 
    37     return self;
 
    37     }
 
    38     }
 
    38 
    39 
    39 
       
    40 // ---------------------------------------------------------------------------
 
       
    41 // CThumbnailObjectSource::NewLC()
 
       
    42 // Two-phased constructor.
 
       
    43 // ---------------------------------------------------------------------------
 
       
    44 //
 
       
    45 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC&
 
    40 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC&
 
    46     aUri, const TDesC& aMimeType )
 
    41     aUri, const TDesC& aMimeType )
 
    47     {
 
    42     {
 
    48     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    43     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    49     CleanupStack::PushL( self );
 
    44     CleanupStack::PushL( self );
 
    50     self->ConstructL( aUri, aMimeType );
 
    45     self->ConstructL( aUri, aMimeType );
 
    51     return self;
 
    46     return self;
 
    52     }
 
    47     }
 
    53 
    48 
    54 // ---------------------------------------------------------------------------
 
       
    55 // CThumbnailObjectSource::NewL()
 
       
    56 // Two-phased constructor.
 
       
    57 // ---------------------------------------------------------------------------
 
       
    58 //
 
       
    59 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const RFile64&
 
    49 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const RFile64&
 
    60     aFile, const TDesC& aMimeType )
 
    50     aFile, const TDesC& aMimeType )
 
    61     {
 
    51     {
 
    62     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aFile,
 
    52     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aFile,
 
    63         aMimeType );
 
    53         aMimeType );
 
    64     CleanupStack::Pop( self );
 
    54     CleanupStack::Pop( self );
 
    65     return self;
 
    55     return self;
 
    66     }
 
    56     }
 
    67 
    57 
    68 
       
    69 // ---------------------------------------------------------------------------
 
       
    70 // CThumbnailObjectSource::NewLC()
 
       
    71 // Two-phased constructor.
 
       
    72 // ---------------------------------------------------------------------------
 
       
    73 //
 
       
    74 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const RFile64&
 
    58 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const RFile64&
 
    75     aFile, const TDesC& aMimeType )
 
    59     aFile, const TDesC& aMimeType )
 
    76     {
 
    60     {
 
    77     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    61     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    78     CleanupStack::PushL( self );
 
    62     CleanupStack::PushL( self );
 
    79     self->ConstructL( aFile, aMimeType );
 
    63     self->ConstructL( aFile, aMimeType );
 
    80     return self;
 
    64     return self;
 
    81     }
 
    65     }
 
    82 
    66 
    83 
    67 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( CFbsBitmap*  aBitmap, 
    84 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( CFbsBitmap*  aBitmap, const TDesC& aUri )
 
    68     const TDesC& aUri )
 
    85     {
 
    69     {
 
    86     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBitmap, aUri );
 
    70     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBitmap, aUri );
 
    87     CleanupStack::Pop( self );
 
    71     CleanupStack::Pop( self );
 
    88     return self;   
    72     return self;   
    89     }
 
    73     }
 
    90 
    74 
    91 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( CFbsBitmap*  aBitmap, const TDesC& aUri )
 
    75 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( CFbsBitmap*  aBitmap,
 
       
    76     const TDesC& aUri )
 
    92     {
 
    77     {
 
    93     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    78     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    94     CleanupStack::PushL( self );
 
    79     CleanupStack::PushL( self );
 
    95     self->ConstructL( aBitmap, aUri );
 
    80     self->ConstructL( aBitmap, aUri );
 
    96     return self;
 
    81     return self;
 
    97     }
 
    82     }
 
    98 
    83 
    99 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( TDesC8* aBuffer,  TDesC& aMimeType, const TDesC& aUri)
 
    84 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( TDesC8* aBuffer,
 
   100     {
 
    85     TDesC& aMimeType, const TDesC& aUri)
 
   101     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBuffer, aMimeType, aUri );
 
    86     {
 
       
    87     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aBuffer, 
       
    88         aMimeType, aUri );
 
   102     CleanupStack::Pop( self );
 
    89     CleanupStack::Pop( self );
 
   103     return self;   
    90     return self;   
   104     }
 
    91     }
 
   105 
    92 
   106 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( TDesC8* aBuffer,  TDesC& aMimeType, const TDesC& aUri)
 
    93 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( TDesC8* aBuffer, 
       
    94     TDesC& aMimeType, const TDesC& aUri)
 
   107     {
 
    95     {
 
   108     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
    96     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
   109     CleanupStack::PushL( self );
 
    97     CleanupStack::PushL( self );
 
   110     self->ConstructL( aBuffer, aMimeType, aUri );
 
    98     self->ConstructL( aBuffer, aMimeType, aUri );
 
   111     return self;
 
    99     return self;
 
   112     }
 
   100     }
 
   113    
   101 
       
   102 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC& 
       
   103     aUri, const TThumbnailId aThumbnailId, const TDesC& aMimeType )
 
       
   104     {
 
       
   105     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aUri,
 
       
   106         aThumbnailId, aMimeType );
 
       
   107     CleanupStack::Pop( self );
 
       
   108     return self;
 
       
   109     }
 
       
   110 
       
   111 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC& aUri, 
       
   112     const TThumbnailId aThumbnailId, const TDesC& aMimeType )
 
       
   113     {
 
       
   114     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
       
   115     CleanupStack::PushL( self );
 
       
   116     self->ConstructL( aUri, aMimeType, aThumbnailId );
 
       
   117     return self;
 
       
   118     }
 
       
   119 
       
   120 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC& aUri, 
       
   121     const TDesC& aTargetUri, const TDesC& aMimeType )
 
       
   122     {
 
       
   123     CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aUri, aTargetUri,
 
       
   124         aMimeType );
 
       
   125     CleanupStack::Pop( self );
 
       
   126     return self;   
       
   127     }
 
       
   128 
       
   129 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC& aUri, 
       
   130     const TDesC& aTargetUri, const TDesC& aMimeType )
 
       
   131     {
 
       
   132     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
       
   133     CleanupStack::PushL( self );
 
       
   134     self->ConstructL( aUri, aTargetUri, aMimeType );
 
       
   135     return self;
 
       
   136     }
 
       
   137 
   114 
   138 
   115 // ---------------------------------------------------------------------------
 
   139 // ---------------------------------------------------------------------------
 
   116 // CThumbnailObjectSource::CThumbnailObjectSource()
 
   140 // CThumbnailObjectSource::CThumbnailObjectSource()
 
   117 // C++ default constructor can NOT contain any code, that might leave.
 
   141 // C++ default constructor can NOT contain any code, that might leave.
 
   118 // ---------------------------------------------------------------------------
 
   142 // ---------------------------------------------------------------------------
 
   132     aMimeType)
 
   156     aMimeType)
 
   133     {
 
   157     {
 
   134     iUri = aUri.AllocL();
 
   158     iUri = aUri.AllocL();
 
   135     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   159     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   136     iMimeType->Des().Copy( aMimeType );
 
   160     iMimeType->Des().Copy( aMimeType );
 
   137     iBitmap = NULL;
 
   161     iThumbnailId = 0;
 
   138     }
 
   162     iBitmap = NULL;
 
   139 
   163     iTargetUri = NULL;
 
   140 
   164     }
 
   141 // ---------------------------------------------------------------------------
 
   165 
   142 // CThumbnailObjectSource::ConstructL()
 
       
   143 // Symbian 2nd phase constructor can leave.
 
       
   144 // ---------------------------------------------------------------------------
 
       
   145 //
 
       
   146 void CThumbnailObjectSource::ConstructL( const RFile64& aFile, const TDesC&
 
   166 void CThumbnailObjectSource::ConstructL( const RFile64& aFile, const TDesC&
 
   147     aMimeType )
 
   167     aMimeType )
 
   148     {
 
   168     {
 
   149     iFile = aFile;
 
   169     iFile = aFile;
 
   150     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   170     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   151     iMimeType->Des().Copy( aMimeType );
 
   171     iMimeType->Des().Copy( aMimeType );
 
   152     iThumbnailId = 0;
 
   172     iThumbnailId = 0;
 
   153     iBitmap = NULL;
 
   173     iBitmap = NULL;
 
   154     }
 
   174     iTargetUri = NULL;
 
   155 
   175     }
 
   156 // ---------------------------------------------------------------------------
 
   176 
   157 // CThumbnailObjectSource::ConstructL()
 
   177 void CThumbnailObjectSource::ConstructL( CFbsBitmap* aBitmap, const TDesC& 
   158 // Symbian 2nd phase constructor can leave.
 
   178     aUri )
 
   159 // ---------------------------------------------------------------------------
 
       
   160 //
 
       
   161 void CThumbnailObjectSource::ConstructL( CFbsBitmap* aBitmap, const TDesC&
 
       
   162         aUri )
 
       
   163     {
 
   179     {
 
   164     iBitmap = aBitmap;
 
   180     iBitmap = aBitmap;
 
   165     iUri = aUri.AllocL();
 
   181     iUri = aUri.AllocL();
 
   166     iThumbnailId = 0;
 
   182     iThumbnailId = 0;
 
   167     }
 
   183     iTargetUri = NULL;
 
   168 
   184     }
 
   169 // ---------------------------------------------------------------------------
 
   185 
   170 // CThumbnailObjectSource::ConstructL()
 
       
   171 // Symbian 2nd phase constructor can leave.
 
       
   172 // ---------------------------------------------------------------------------
 
       
   173 //
 
       
   174 void CThumbnailObjectSource::ConstructL( TDesC8* aBuffer, const TDesC&
 
   186 void CThumbnailObjectSource::ConstructL( TDesC8* aBuffer, const TDesC&
 
   175     aMimeType, const TDesC& aUri )
 
   187     aMimeType, const TDesC& aUri )
 
   176     {
 
   188     {
 
   177     iBuffer = aBuffer;
 
   189     iBuffer = aBuffer;
 
   178     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   190     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   179     iMimeType->Des().Copy( aMimeType );
 
   191     iMimeType->Des().Copy( aMimeType );
 
   180     iUri = aUri.AllocL(); 
   192     iUri = aUri.AllocL(); 
   181     iThumbnailId = 0;
 
   193     iThumbnailId = 0;
 
   182     iBitmap = NULL;
 
   194     iBitmap = NULL;
 
   183     }
 
   195     iTargetUri = NULL;
 
   184 
   196     }
 
   185 // ---------------------------------------------------------------------------
 
   197 
   186 // CThumbnailObjectSource::ConstructL()
 
       
   187 // Symbian 2nd phase constructor can leave.
 
       
   188 // ---------------------------------------------------------------------------
 
       
   189 //
 
       
   190 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&
 
   198 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&
 
   191     aMimeType, TThumbnailId aThumbnailId )
 
   199     aMimeType, TThumbnailId aThumbnailId )
 
   192     {
 
   200     {
 
   193     iUri = aUri.AllocL();
 
   201     iUri = aUri.AllocL();
 
   194     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   202     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   195     iMimeType->Des().Copy( aMimeType );
 
   203     iMimeType->Des().Copy( aMimeType );
 
   196     iThumbnailId = aThumbnailId;
 
   204     iThumbnailId = aThumbnailId;
 
       
   205     iTargetUri = NULL;
 
       
   206     }
 
       
   207 
       
   208 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC& 
       
   209     aTargetUri, const TDesC& aMimeType )
 
       
   210     {
 
       
   211     iUri = aUri.AllocL();
 
       
   212     iTargetUri = aTargetUri.AllocL();
 
       
   213     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
       
   214     iMimeType->Des().Copy( aMimeType );
 
       
   215     iThumbnailId = 0;
 
       
   216     iBitmap = NULL;
 
   197     }
 
   217     }
 
   198 
   218 
   199 
   219 
   200 // ---------------------------------------------------------------------------
 
   220 // ---------------------------------------------------------------------------
 
   201 // CThumbnailObjectSource::~CThumbnailObjectSource()()
 
   221 // CThumbnailObjectSource::~CThumbnailObjectSource()()
 
   217 
   237 
   218 // ---------------------------------------------------------------------------
 
   238 // ---------------------------------------------------------------------------
 
   219 // CThumbnailObjectSourceImpl::FileHandle()
 
   239 // CThumbnailObjectSourceImpl::FileHandle()
 
   220 // ---------------------------------------------------------------------------
 
   240 // ---------------------------------------------------------------------------
 
   221 //
 
   241 //
 
   222 EXPORT_C  RFile64& CThumbnailObjectSource::FileHandle()
 
   242 EXPORT_C RFile64& CThumbnailObjectSource::FileHandle()
 
   223     {
 
   243     {
 
   224     return iFile;
 
   244     return iFile;
 
   225     }
 
   245     }
 
   226 
       
   227 
   246 
   228 // ---------------------------------------------------------------------------
 
   247 // ---------------------------------------------------------------------------
 
   229 // CThumbnailObjectSourceImpl::Uri()
 
   248 // CThumbnailObjectSourceImpl::Uri()
 
   230 // ---------------------------------------------------------------------------
 
   249 // ---------------------------------------------------------------------------
 
   231 //
 
   250 //
 
   269         return *iMimeType;
 
   288         return *iMimeType;
 
   270         }
 
   289         }
 
   271     return KNullDesC8;
 
   290     return KNullDesC8;
 
   272     }
 
   291     }
 
   273 
   292 
       
   293 // ---------------------------------------------------------------------------
 
       
   294 // CThumbnailObjectSourceImpl::Id()
 
       
   295 // ---------------------------------------------------------------------------
 
       
   296 //
 
   274 EXPORT_C TThumbnailId CThumbnailObjectSource::Id()
 
   297 EXPORT_C TThumbnailId CThumbnailObjectSource::Id()
 
   275     {
 
   298     {
 
   276     return iThumbnailId;
 
   299     return iThumbnailId;
 
   277     }
 
   300     }
 
   278 	
   301 	
   279 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewL( const TDesC&
 
       
   280 aUri, const TThumbnailId aThumbnailId, const TDesC& aMimeType )
 
       
   281 {
 
       
   282 CThumbnailObjectSource* self = CThumbnailObjectSource::NewLC( aUri,
 
       
   283         aThumbnailId, aMimeType );
 
       
   284 CleanupStack::Pop( self );
 
       
   285 return self;
 
       
   286     }
 
       
   287 
       
   288 
       
   289 // ---------------------------------------------------------------------------
 
       
   290 // CThumbnailObjectSource::NewLC()
 
       
   291 // Two-phased constructor.
 
       
   292 // ---------------------------------------------------------------------------
 
       
   293 //
 
       
   294 EXPORT_C CThumbnailObjectSource* CThumbnailObjectSource::NewLC( const TDesC& aUri, 
       
   295 	const TThumbnailId aThumbnailId, const TDesC& aMimeType )
 
       
   296     {
 
       
   297     CThumbnailObjectSource* self = new( ELeave )CThumbnailObjectSource();
 
       
   298     CleanupStack::PushL( self );
 
       
   299     self->ConstructL( aUri, aMimeType, aThumbnailId );
 
       
   300     return self;
 
       
   301     }
 
       
   302 
       
   303 // ---------------------------------------------------------------------------
 
   302 // ---------------------------------------------------------------------------
 
   304 // CThumbnailObjectSourceImpl::Bitmap()
 
   303 // CThumbnailObjectSourceImpl::Bitmap()
 
   305 // ---------------------------------------------------------------------------
 
   304 // ---------------------------------------------------------------------------
 
   306 //
 
   305 //
 
   307 EXPORT_C CFbsBitmap* CThumbnailObjectSource::Bitmap()
 
   306 EXPORT_C CFbsBitmap* CThumbnailObjectSource::Bitmap()
 
   318     CFbsBitmap* temp = iBitmap;
 
   317     CFbsBitmap* temp = iBitmap;
 
   319     iBitmap = NULL;
 
   318     iBitmap = NULL;
 
   320     return temp;
 
   319     return temp;
 
   321     }
 
   320     }
 
   322 
   321 
       
   322 // ---------------------------------------------------------------------------
 
       
   323 // CThumbnailObjectSourceImpl::TargetUri()
 
       
   324 // ---------------------------------------------------------------------------
 
       
   325 //
 
       
   326 EXPORT_C const TDesC& CThumbnailObjectSource::TargetUri()
 
       
   327     {
 
       
   328     if ( iTargetUri )
 
       
   329         {
 
       
   330         return * iTargetUri;
 
       
   331         }
 
       
   332     return KNullDesC;
 
       
   333     }
 
       
   334 
       
   335 
   323 // End of file
 
   336 // End of file
MCL/sf/mw/imghandling