Mercurial Mercurial > oss > FCL > 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
branchGCC_SURGE
changeset 32 a0ee3f735f8b
parent 30 b67379558a75
equal deleted inserted replaced
26:ea43e3e86079 32:a0ee3f735f8b 
    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     }
 
   161     iThumbnailId = 0;
 
   138 
   162     iBitmap = NULL;
 
   139 
   163     iTargetUri = NULL;
 
   140 // ---------------------------------------------------------------------------
 
   164     }
 
   141 // CThumbnailObjectSource::ConstructL()
 
   165 
   142 // Symbian 2nd phase constructor can leave.
 
       
   143 // ---------------------------------------------------------------------------
 
       
   144 //
 
       
   145 void CThumbnailObjectSource::ConstructL( const RFile64& aFile, const TDesC&
 
   166 void CThumbnailObjectSource::ConstructL( const RFile64& aFile, const TDesC&
 
   146     aMimeType )
 
   167     aMimeType )
 
   147     {
 
   168     {
 
   148     iFile = aFile;
 
   169     iFile = aFile;
 
   149     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   170     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   150     iMimeType->Des().Copy( aMimeType );
 
   171     iMimeType->Des().Copy( aMimeType );
 
   151     iThumbnailId = 0;
 
   172     iThumbnailId = 0;
 
   152     }
 
   173     iBitmap = NULL;
 
   153 
   174     iTargetUri = NULL;
 
   154 // ---------------------------------------------------------------------------
 
   175     }
 
   155 // CThumbnailObjectSource::ConstructL()
 
   176 
   156 // Symbian 2nd phase constructor can leave.
 
   177 void CThumbnailObjectSource::ConstructL( CFbsBitmap* aBitmap, const TDesC& 
   157 // ---------------------------------------------------------------------------
 
   178     aUri )
 
   158 //
 
       
   159 void CThumbnailObjectSource::ConstructL( CFbsBitmap* aBitmap, const TDesC&
 
       
   160         aUri )
 
       
   161     {
 
   179     {
 
   162     iBitmap = aBitmap;
 
   180     iBitmap = aBitmap;
 
   163     iUri = aUri.AllocL();
 
   181     iUri = aUri.AllocL();
 
   164     iThumbnailId = 0;
 
   182     iThumbnailId = 0;
 
   165     }
 
   183     iTargetUri = NULL;
 
   166 
   184     }
 
   167 // ---------------------------------------------------------------------------
 
   185 
   168 // CThumbnailObjectSource::ConstructL()
 
       
   169 // Symbian 2nd phase constructor can leave.
 
       
   170 // ---------------------------------------------------------------------------
 
       
   171 //
 
       
   172 void CThumbnailObjectSource::ConstructL( TDesC8* aBuffer, const TDesC&
 
   186 void CThumbnailObjectSource::ConstructL( TDesC8* aBuffer, const TDesC&
 
   173     aMimeType, const TDesC& aUri )
 
   187     aMimeType, const TDesC& aUri )
 
   174     {
 
   188     {
 
   175     iBuffer = aBuffer;
 
   189     iBuffer = aBuffer;
 
   176     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   190     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   177     iMimeType->Des().Copy( aMimeType );
 
   191     iMimeType->Des().Copy( aMimeType );
 
   178     iUri = aUri.AllocL(); 
   192     iUri = aUri.AllocL(); 
   179     iThumbnailId = 0;
 
   193     iThumbnailId = 0;
 
   180     }
 
   194     iBitmap = NULL;
 
   181 
   195     iTargetUri = NULL;
 
   182 // ---------------------------------------------------------------------------
 
   196     }
 
   183 // CThumbnailObjectSource::ConstructL()
 
   197 
   184 // Symbian 2nd phase constructor can leave.
 
       
   185 // ---------------------------------------------------------------------------
 
       
   186 //
 
       
   187 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&
 
   198 void CThumbnailObjectSource::ConstructL( const TDesC& aUri, const TDesC&
 
   188     aMimeType, TThumbnailId aThumbnailId )
 
   199     aMimeType, TThumbnailId aThumbnailId )
 
   189     {
 
   200     {
 
   190     iUri = aUri.AllocL();
 
   201     iUri = aUri.AllocL();
 
   191     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   202     iMimeType = HBufC8::NewL( aMimeType.Length() );
 
   192     iMimeType->Des().Copy( aMimeType );
 
   203     iMimeType->Des().Copy( aMimeType );
 
   193     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;
 
   194     }
 
   217     }
 
   195 
   218 
   196 
   219 
   197 // ---------------------------------------------------------------------------
 
   220 // ---------------------------------------------------------------------------
 
   198 // CThumbnailObjectSource::~CThumbnailObjectSource()()
 
   221 // CThumbnailObjectSource::~CThumbnailObjectSource()()
 
   200 // ---------------------------------------------------------------------------
 
   223 // ---------------------------------------------------------------------------
 
   201 //
 
   224 //
 
   202 CThumbnailObjectSource::~CThumbnailObjectSource()
 
   225 CThumbnailObjectSource::~CThumbnailObjectSource()
 
   203     {
 
   226     {
 
   204     delete iUri;
 
   227     delete iUri;
 
       
   228     iUri = NULL;
 
   205     delete iMimeType;
 
   229     delete iMimeType;
 
       
   230     iMimeType = NULL;
 
   206     delete iBuffer;
 
   231     delete iBuffer;
 
       
   232     iBuffer = NULL;
 
   207     delete iBitmap;
 
   233     delete iBitmap;
 
       
   234     iBitmap = NULL;
 
   208     }
 
   235     }
 
   209 
   236 
   210 
   237 
   211 // ---------------------------------------------------------------------------
 
   238 // ---------------------------------------------------------------------------
 
   212 // CThumbnailObjectSourceImpl::FileHandle()
 
   239 // CThumbnailObjectSourceImpl::FileHandle()
 
   213 // ---------------------------------------------------------------------------
 
   240 // ---------------------------------------------------------------------------
 
   214 //
 
   241 //
 
   215 EXPORT_C  RFile64& CThumbnailObjectSource::FileHandle()
 
   242 EXPORT_C RFile64& CThumbnailObjectSource::FileHandle()
 
   216     {
 
   243     {
 
   217     return iFile;
 
   244     return iFile;
 
   218     }
 
   245     }
 
   219 
       
   220 
   246 
   221 // ---------------------------------------------------------------------------
 
   247 // ---------------------------------------------------------------------------
 
   222 // CThumbnailObjectSourceImpl::Uri()
 
   248 // CThumbnailObjectSourceImpl::Uri()
 
   223 // ---------------------------------------------------------------------------
 
   249 // ---------------------------------------------------------------------------
 
   224 //
 
   250 //
 
   262         return *iMimeType;
 
   288         return *iMimeType;
 
   263         }
 
   289         }
 
   264     return KNullDesC8;
 
   290     return KNullDesC8;
 
   265     }
 
   291     }
 
   266 
   292 
       
   293 // ---------------------------------------------------------------------------
 
       
   294 // CThumbnailObjectSourceImpl::Id()
 
       
   295 // ---------------------------------------------------------------------------
 
       
   296 //
 
   267 EXPORT_C TThumbnailId CThumbnailObjectSource::Id()
 
   297 EXPORT_C TThumbnailId CThumbnailObjectSource::Id()
 
   268     {
 
   298     {
 
   269     return iThumbnailId;
 
   299     return iThumbnailId;
 
   270     }
 
   300     }
 
   271 	
   301 	
   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 // ---------------------------------------------------------------------------
 
   302 // ---------------------------------------------------------------------------
 
   297 // CThumbnailObjectSourceImpl::Bitmap()
 
   303 // CThumbnailObjectSourceImpl::Bitmap()
 
   298 // ---------------------------------------------------------------------------
 
   304 // ---------------------------------------------------------------------------
 
   299 //
 
   305 //
 
   300 EXPORT_C CFbsBitmap* CThumbnailObjectSource::Bitmap()
 
   306 EXPORT_C CFbsBitmap* CThumbnailObjectSource::Bitmap()
 
   311     CFbsBitmap* temp = iBitmap;
 
   317     CFbsBitmap* temp = iBitmap;
 
   312     iBitmap = NULL;
 
   318     iBitmap = NULL;
 
   313     return temp;
 
   319     return temp;
 
   314     }
 
   320     }
 
   315 
   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 
   316 // End of file
 
   336 // End of file
FCL/sf/mw/imghandling