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: This file implements the read codec for the SVG presentation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "SVGCodec.h" |
|
20 |
|
21 // INCLUDE FILES |
|
22 #include <uri16.h> |
|
23 #include <coeutils.h> |
|
24 #include <SVGEngineInterfaceImpl.h> |
|
25 #include <gdi.h> |
|
26 #include <pathconfiguration.hrh> |
|
27 // User Includes |
|
28 #include <SVGTUIControlDbgFlags.hrh> |
|
29 #include <imcvcodc.h> |
|
30 #include <utf.h> |
|
31 |
|
32 #ifdef RD_MULTIPLE_DRIVE |
|
33 #include <pathinfo.h> |
|
34 #include <driveinfo.h> |
|
35 #endif |
|
36 |
|
37 // General Constants |
|
38 const TInt KSccConstZero = 0; |
|
39 const TUint KSccBackground = 0xffffffff; |
|
40 // SMIL Fit Value |
|
41 _LIT( KSccSmilFitValue,"meet" ); |
|
42 |
|
43 // |
|
44 _LIT( KWww, "www" ); |
|
45 _LIT( KHttp, "http://"); |
|
46 _LIT( KDotDot, ".." ); |
|
47 _LIT( KBSlashStr, "/" ); |
|
48 _LIT( KSlashStr, "\\" ); |
|
49 _LIT( KDotSlashStr, ".\\" ); |
|
50 _LIT( KColonStr, ":" ); |
|
51 |
|
52 _LIT(KJpg, ".jpg" ); |
|
53 _LIT(KJpeg, ".jpeg" ); |
|
54 _LIT(KPng, ".png" ); |
|
55 _LIT(KBmp, ".bmp" ); |
|
56 _LIT(KSvg, ".svg" ); |
|
57 _LIT(KSvgz, ".svgz" ); |
|
58 // |
|
59 |
|
60 enum TSVGCodecPanic |
|
61 { |
|
62 ECouldNotGenerateThumbnail |
|
63 }; |
|
64 |
|
65 // ============================ MEMBER FUNCTIONS =============================== |
|
66 |
|
67 // ----------------------------------------------------------------------------- |
|
68 // CSvgReadCodec::CSvgReadCodec |
|
69 // Default constructor. |
|
70 // ----------------------------------------------------------------------------- |
|
71 // |
|
72 CSvgReadCodec::CSvgReadCodec( const TSize& aSize ): iImagesPresent(EFalse), |
|
73 iImagesLoaded (EFalse), |
|
74 iOriginalSize(aSize) |
|
75 |
|
76 { |
|
77 } |
|
78 |
|
79 // ----------------------------------------------------------------------------- |
|
80 // CSvgReadCodec::NewL |
|
81 // Static constructor. Returns the pointer to the CSvgReadCodec |
|
82 // ----------------------------------------------------------------------------- |
|
83 // |
|
84 CSvgReadCodec* CSvgReadCodec::NewL( const TSize& aSize ) |
|
85 { |
|
86 CSvgReadCodec* self = new(ELeave) CSvgReadCodec( aSize ); |
|
87 CleanupStack::PushL(self); |
|
88 self->ConstructL(); |
|
89 CleanupStack::Pop(self); |
|
90 return self; |
|
91 } |
|
92 |
|
93 void CSvgReadCodec::ConstructL() |
|
94 { |
|
95 iSvgModule = NULL; |
|
96 iSVGTBitMapDummy = NULL; |
|
97 InitializeEngineL(); |
|
98 } |
|
99 |
|
100 void CSvgReadCodec::InitializeEngineL() |
|
101 { |
|
102 if ( !iSvgModule ) |
|
103 { |
|
104 TFontSpec spec; |
|
105 |
|
106 if ( !iSVGTBitMapDummy ) |
|
107 { |
|
108 // For thumbnails, the user provided bitmap is used, |
|
109 // Have to give some dummy bitmap to the engine in the constructor. |
|
110 iSVGTBitMapDummy = new( ELeave ) CFbsBitmap; |
|
111 User::LeaveIfError( |
|
112 iSVGTBitMapDummy->Create( |
|
113 TSize( KSccConstZero, KSccConstZero ), |
|
114 EGray2 ) ); |
|
115 } |
|
116 |
|
117 iSvgModule = CSvgEngineInterfaceImpl::NewL( iSVGTBitMapDummy, this, spec ); |
|
118 // 0xffffffff is the default color. |
|
119 iSvgModule->SetBackgroundColor( KSccBackground ); |
|
120 iSvgModule->AddListener(static_cast<MSvgLoadingListener*>(this), |
|
121 ESvgLoadingListener); |
|
122 |
|
123 } |
|
124 } |
|
125 |
|
126 // ----------------------------------------------------------------------------- |
|
127 // CSvgReadCodec::~CSvgReadCodec |
|
128 // Destructor |
|
129 // ----------------------------------------------------------------------------- |
|
130 // |
|
131 CSvgReadCodec::~CSvgReadCodec() |
|
132 { |
|
133 DeleteEngine(); |
|
134 |
|
135 // Dummy bitmap |
|
136 delete iSVGTBitMapDummy; |
|
137 |
|
138 // SVG file data |
|
139 delete iFileData; |
|
140 } |
|
141 |
|
142 // ----------------------------------------------------------------------------- |
|
143 // CSvgReadCodec::SetFileDataL |
|
144 // Sets the SVG presentation data |
|
145 // ----------------------------------------------------------------------------- |
|
146 // |
|
147 void CSvgReadCodec::SetFileDataL( const TDesC8& aFileData ) |
|
148 { |
|
149 delete iFileData; |
|
150 iFileData = NULL; |
|
151 |
|
152 // For files which are in UTF-16 or unicode format the first 2 bytes |
|
153 // will be FF and FE. In UTF-16 and unicode format every single character |
|
154 // is represented by two bytes. |
|
155 |
|
156 HBufC8* binaryBuffer=NULL; |
|
157 binaryBuffer = HBufC8::NewL( aFileData.Length() ); |
|
158 |
|
159 TPtr8 binaryBufferPtr = binaryBuffer->Des(); |
|
160 binaryBufferPtr = aFileData; |
|
161 |
|
162 TInt hichar = (CEditableText::EReversedByteOrderMark & 0xFF00)>>8; |
|
163 TInt lochar = CEditableText::EReversedByteOrderMark & 0x00FF; |
|
164 TInt bytesPerChar = 1; |
|
165 |
|
166 if(binaryBufferPtr[0] == hichar && binaryBufferPtr[1] == lochar) |
|
167 { |
|
168 bytesPerChar = 2; |
|
169 |
|
170 HBufC* dataBuffer=NULL; |
|
171 TInt fileSize = aFileData.Length(); |
|
172 dataBuffer = HBufC::New(aFileData.Length()/bytesPerChar); |
|
173 if ( !dataBuffer) |
|
174 { |
|
175 //_LIT( KErrorMsg, "Failed to Load Svg Content: Out of memory"); |
|
176 delete binaryBuffer; |
|
177 return; |
|
178 } |
|
179 |
|
180 TPtr dataBufferPtr = dataBuffer->Des(); |
|
181 |
|
182 // Skip two bytes and set the pointer to the next location |
|
183 // from where the actual data starts. |
|
184 dataBufferPtr.Set((TUint16*)binaryBufferPtr.Ptr()+1, |
|
185 fileSize/bytesPerChar-1, |
|
186 fileSize/bytesPerChar-1); |
|
187 |
|
188 HBufC8* outputBuffer= NULL; |
|
189 outputBuffer=HBufC8::New(fileSize); |
|
190 if(!outputBuffer) |
|
191 { |
|
192 //_LIT( KErrorMsg, "Failed to Load Svg Content: Out of memory"); |
|
193 delete dataBuffer; |
|
194 delete binaryBuffer; |
|
195 return ; |
|
196 } |
|
197 TPtr8 outputBufferptr=outputBuffer->Des(); |
|
198 CnvUtfConverter::ConvertFromUnicodeToUtf8( |
|
199 outputBufferptr, // Destination |
|
200 dataBufferPtr ); |
|
201 |
|
202 iFileData = HBufC8::NewL(fileSize); |
|
203 iFileData->Des().Copy(outputBufferptr); |
|
204 |
|
205 delete dataBuffer; |
|
206 delete outputBuffer; |
|
207 |
|
208 } |
|
209 else |
|
210 { |
|
211 iFileData = HBufC8::NewL(aFileData.Length()); |
|
212 iFileData->Des().Copy( aFileData ); |
|
213 } |
|
214 delete binaryBuffer; |
|
215 } |
|
216 |
|
217 // ----------------------------------------------------------------------------- |
|
218 // CSvgReadCodec::ProcessFrameL |
|
219 // Processes the frame data contained in aSrc. |
|
220 // ----------------------------------------------------------------------------- |
|
221 // |
|
222 TFrameState CSvgReadCodec::ProcessFrameL(TBufPtr8& aSrc ) |
|
223 { |
|
224 aSrc.Shift( 1 ); |
|
225 TFrameState lRetVal = EFrameComplete; |
|
226 DoProcessL(); |
|
227 |
|
228 if(iImagesPresent && !iImagesLoaded) |
|
229 { |
|
230 lRetVal = EFrameIncompleteRepositionRequest; |
|
231 } |
|
232 |
|
233 return lRetVal; |
|
234 } |
|
235 |
|
236 // ----------------------------------------------------------------------------- |
|
237 // CSvgReadCodec::DoProcessL |
|
238 // Processes the SVG presentation file data. Called by ProcessFrameL() |
|
239 // ----------------------------------------------------------------------------- |
|
240 // |
|
241 void CSvgReadCodec::DoProcessL() |
|
242 { |
|
243 } |
|
244 |
|
245 // ----------------------------------------------------------------------------- |
|
246 // CSvgReadCodec::InitFrameL |
|
247 // Processes the SVG presentation file data. Called by ProcessFrameL() |
|
248 // ----------------------------------------------------------------------------- |
|
249 // |
|
250 void CSvgReadCodec::InitFrameL(TFrameInfo& /* aFrameInfo*/, |
|
251 CFrameImageData& /*aFrameImageData*/, |
|
252 TBool /*aDisableErrorDiffusion */, |
|
253 CFbsBitmap& aFrame, |
|
254 CFbsBitmap* /* aDestinationMask */ ) |
|
255 { |
|
256 GenerateThumbnailL(&aFrame, NULL); |
|
257 } |
|
258 |
|
259 void CSvgReadCodec::UpdateScreen() |
|
260 { |
|
261 } |
|
262 |
|
263 TBool CSvgReadCodec::ScriptCall( const TDesC& /*aScript*/, CSvgElementImpl* /*aCallerElement*/ ) |
|
264 { |
|
265 return EFalse; |
|
266 } |
|
267 |
|
268 TInt CSvgReadCodec::FetchImage( const TDesC& aUri, RFs& aSession, RFile& aFileHandle ) |
|
269 { |
|
270 TInt errorCode = KErrNotFound; |
|
271 TInt ret = 0; |
|
272 TRAPD(err, ret = IsDownloadNeededL(aUri)); |
|
273 if(err==KErrNone) |
|
274 { |
|
275 if( ret == ELocalImageFile) |
|
276 { |
|
277 TFileName fileName; |
|
278 |
|
279 #ifdef RD_MULTIPLE_DRIVE |
|
280 |
|
281 // RFs fsSession; |
|
282 HBufC* fullImagesPathBuf = HBufC::New( KMaxPath ); |
|
283 if (fullImagesPathBuf) |
|
284 { |
|
285 TPtr fullImagesPathPtr = fullImagesPathBuf->Des(); |
|
286 TInt intDrive; |
|
287 DriveInfo::TDriveArray driveArray; |
|
288 |
|
289 // fsSession.Connect(); |
|
290 |
|
291 TInt err1=DriveInfo::GetUserVisibleDrives( aSession, driveArray ); |
|
292 if(err1==KErrNone) |
|
293 { |
|
294 for(TInt i=0; i < driveArray.Count(); i++) |
|
295 { |
|
296 TChar driveLetter = driveArray.LetterAt(i); |
|
297 TInt err2=RFs::CharToDrive(driveLetter, intDrive); |
|
298 if(err2==KErrNone) |
|
299 { |
|
300 TInt err3=PathInfo::GetRootPath(fullImagesPathPtr, intDrive); |
|
301 if(err3==KErrNone) |
|
302 { |
|
303 fullImagesPathPtr.Append( PathInfo::ImagesPath() ); |
|
304 if(GetLocalFile( aUri, fileName, fullImagesPathPtr)) |
|
305 { |
|
306 errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny ); |
|
307 break; |
|
308 } |
|
309 } |
|
310 } |
|
311 } |
|
312 } |
|
313 } |
|
314 delete fullImagesPathBuf; |
|
315 fullImagesPathBuf=NULL; |
|
316 |
|
317 // fsSession.Close(); |
|
318 |
|
319 #else |
|
320 |
|
321 HBufC* phoneMemImagesPath = GetImagesPath(EPhoneMemory); |
|
322 TPtr ptrphoneMemImagesPath(phoneMemImagesPath->Des()); |
|
323 HBufC* memCardImagesPath = GetImagesPath(EMemoryCard); |
|
324 TPtr ptrMemCardImagesPath(memCardImagesPath->Des()); |
|
325 |
|
326 if(GetLocalFile( aUri, fileName, ptrphoneMemImagesPath)) |
|
327 errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny ); |
|
328 else if(GetLocalFile( aUri, fileName, ptrMemCardImagesPath)) |
|
329 errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny ); |
|
330 |
|
331 delete memCardImagesPath; |
|
332 delete phoneMemImagesPath; |
|
333 #endif |
|
334 } |
|
335 } |
|
336 return errorCode; |
|
337 } |
|
338 |
|
339 TInt CSvgReadCodec::FetchFont( const TDesC& /* aUri */, |
|
340 RFs& /* aSession */, RFile& /* aFileHandle */ ) |
|
341 { |
|
342 return KErrNotSupported; |
|
343 } |
|
344 |
|
345 |
|
346 void CSvgReadCodec::GetSmilFitValue( TDes& aSmilValue ) |
|
347 { |
|
348 aSmilValue.Copy( KSccSmilFitValue ); |
|
349 } |
|
350 |
|
351 void CSvgReadCodec::UpdatePresentation( const TInt32& /* aNoOfAnimation */ ) |
|
352 { |
|
353 } |
|
354 |
|
355 void CSvgReadCodec::PrepareEngine() |
|
356 { |
|
357 iPrepareDomResult = iSvgModule->PrepareDom( *iFileData, iThumbnailHandle ); |
|
358 TInt err = iPrepareDomResult->HasError(); |
|
359 iSvgModule->UseDom( iThumbnailHandle, NULL); |
|
360 iContentSize = iSvgModule->GetSvgBoundingBox().Size(); |
|
361 if(iContentSize.iHeight < 1) |
|
362 { |
|
363 iContentSize.iHeight = 1; |
|
364 } |
|
365 if(iContentSize.iWidth < 1) |
|
366 { |
|
367 iContentSize.iWidth = 1; |
|
368 } |
|
369 } |
|
370 |
|
371 TSize CSvgReadCodec::ContentSize() const |
|
372 { |
|
373 return iContentSize; |
|
374 } |
|
375 |
|
376 void CSvgReadCodec::GenerateThumbnailL(CFbsBitmap* aFrame, CFbsBitmap* /*aFrameMask*/) |
|
377 { |
|
378 if ( iSvgModule ) |
|
379 { |
|
380 // NULL is returned, possible out of memory when create error object. |
|
381 User::LeaveIfNull( iPrepareDomResult ); |
|
382 User::LeaveIfError(iPrepareDomResult->HasError()); |
|
383 #ifdef SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE |
|
384 iSvgModule->SetThumbNailMode( ETrue ); // Set thumbnail mode On |
|
385 #endif // SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE |
|
386 |
|
387 // Setup the engine to use the DOM |
|
388 MSvgError* pResult = iSvgModule->UseDom( iThumbnailHandle, aFrame ); |
|
389 if ( pResult->HasError() && !pResult->IsWarning() ) |
|
390 { |
|
391 User::Leave( KErrGeneral ); |
|
392 } |
|
393 |
|
394 // View Box define for Dom associated frame |
|
395 iSvgModule->ChooseViewBoxIfNotSet(iThumbnailHandle); |
|
396 |
|
397 // Setup the frame size as the one obtained from |
|
398 // creator of codec. |
|
399 const TSize frameSize = aFrame->SizeInPixels(); |
|
400 // Get the Display mode for bitmap |
|
401 TDisplayMode lFrameDispMode = aFrame->DisplayMode(); |
|
402 // Get the Displaymode for mask |
|
403 iSvgModule->InitializeEngine(); |
|
404 iSvgModule->RenderFrame( NULL, 0); |
|
405 // render static content as well |
|
406 if ( iFrameList.Count() ) |
|
407 { |
|
408 CFbsBitGc* bitmapContext=NULL; |
|
409 CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( aFrame ); |
|
410 CleanupStack::PushL( bitmapDevice ); |
|
411 User::LeaveIfError( bitmapDevice->CreateContext( bitmapContext ) ); |
|
412 CleanupStack::PushL( bitmapContext ); |
|
413 bitmapContext->BitBlt( TPoint(0,0),iFrameList[ 0 ] ); |
|
414 CleanupStack::PopAndDestroy(2); |
|
415 } |
|
416 |
|
417 #ifdef SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE |
|
418 iSvgModule->SetThumbNailMode( EFalse ); // Set thumbnail mode Off |
|
419 #endif // SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE |
|
420 } |
|
421 } |
|
422 |
|
423 // ----------------------------------------------------------------------------- |
|
424 // CSvgReadCodec::DeleteEngine |
|
425 // Deletes the structures associated with the engine |
|
426 // viz. The Frame List, Mask List, Delay Interval List, |
|
427 // The DOM for the content and the Engine Implementation itself |
|
428 // ----------------------------------------------------------------------------- |
|
429 // |
|
430 void CSvgReadCodec::DeleteEngine() |
|
431 { |
|
432 // Cleanup elements in the frame list |
|
433 for ( TInt i = 0; i < iFrameList.Count(); i++ ) |
|
434 { |
|
435 delete iFrameList[i]; |
|
436 } |
|
437 |
|
438 // Cleanup elements in the mask list |
|
439 for ( TInt i = 0; i < iMaskList.Count(); i++ ) |
|
440 { |
|
441 delete iMaskList[i]; |
|
442 } |
|
443 |
|
444 // Cleanup the memory used for storing the pointers/values |
|
445 iFrameList.Reset(); |
|
446 iMaskList.Reset(); |
|
447 iDelayList.Reset(); |
|
448 |
|
449 // Close the resources |
|
450 iFrameList.Close(); |
|
451 iMaskList.Close(); |
|
452 iDelayList.Close(); |
|
453 |
|
454 // Delete the DOM created for the content |
|
455 //if ( iThumbnailHandle ) |
|
456 // { |
|
457 // iSvgModule->DeleteDom( iThumbnailHandle ); |
|
458 // iThumbnailHandle = 0; |
|
459 // } |
|
460 |
|
461 // Delete the Engine module |
|
462 delete iSvgModule; |
|
463 iSvgModule = NULL; |
|
464 } |
|
465 |
|
466 CSvgReadCodec::TDownloadNeeded CSvgReadCodec::IsDownloadNeededL( const TDesC& aUri ) const |
|
467 { |
|
468 |
|
469 TUriParser UriParser; |
|
470 |
|
471 TBuf<KMaxFileName> localUri; |
|
472 // url starts with www so append http:// |
|
473 if ( !aUri.Left( 4 ).Compare( KWww ) ) |
|
474 { |
|
475 localUri.Append( KHttp ); |
|
476 localUri.Append( aUri ); |
|
477 User::LeaveIfError( UriParser.Parse( localUri ) ); |
|
478 } |
|
479 else |
|
480 { |
|
481 User::LeaveIfError( UriParser.Parse( aUri ) ); |
|
482 } |
|
483 |
|
484 if ( UriParser.IsPresent( EUriHost ) ) |
|
485 { |
|
486 // Extract the Path, filename and extension from the uri |
|
487 TFileName filename = UriParser.Extract( EUriPath ); |
|
488 TParsePtrC fileParser( filename ); |
|
489 |
|
490 if ( fileParser.NamePresent() && fileParser.ExtPresent() ) |
|
491 { |
|
492 if ( fileParser.Ext().Compare( KJpg ) == 0 || |
|
493 fileParser.Ext().Compare( KJpeg ) == 0 || |
|
494 fileParser.Ext().Compare( KBmp ) == 0 || |
|
495 fileParser.Ext().Compare( KPng ) == 0 || |
|
496 fileParser.Ext().Compare( KSvg ) == 0 || |
|
497 fileParser.Ext().Compare( KSvgz ) == 0 ) |
|
498 { |
|
499 // file name and ext present and |
|
500 // it is amy of the supported image types |
|
501 return ERemoteImageFile; |
|
502 } |
|
503 else |
|
504 { |
|
505 //file Extension present but not a supported image ext, |
|
506 //may be some html file |
|
507 return ENotAnImageFile; |
|
508 } |
|
509 } |
|
510 else |
|
511 { |
|
512 //Should be a domain name so return ENotAnImageFile |
|
513 return ENotAnImageFile; |
|
514 } |
|
515 } |
|
516 else |
|
517 { |
|
518 return ELocalImageFile; |
|
519 } |
|
520 } |
|
521 |
|
522 TBool CSvgReadCodec::GetLocalFile( const TDesC& aUri, |
|
523 TDes& aFileName , |
|
524 const TDesC& aRefPath ) const |
|
525 { |
|
526 aFileName.Zero(); |
|
527 TBuf<KMaxFileName> copyUri = aUri; |
|
528 // Before giving the uri to the file parser, |
|
529 // convert '/' to '\'. |
|
530 TInt pos; |
|
531 while( KErrNotFound != ( pos = copyUri.FindF( KBSlashStr ) ) ) |
|
532 { |
|
533 copyUri.Replace(pos,1,KSlashStr ); |
|
534 } |
|
535 |
|
536 // if the uri starts with ".\" remove ".\" |
|
537 if ( copyUri.Left( 2 ).Compare( KDotSlashStr ) == 0 ) |
|
538 { |
|
539 copyUri = copyUri.Right( copyUri.Length() - KDotSlashStr().Length() ); |
|
540 } |
|
541 |
|
542 // If the second letter is not ':' |
|
543 // and if it is not starting with '\', |
|
544 // and if the path has '/', |
|
545 // then prepend slash to it. |
|
546 if ( copyUri.Length() >= 2 && |
|
547 copyUri.Mid( 1, 1 ).Compare( KColonStr ) != 0 && |
|
548 copyUri.Mid( 0, 1 ).Compare( KSlashStr ) != 0 && |
|
549 ( copyUri.Find( KSlashStr ) != KErrNotFound ) ) |
|
550 { |
|
551 copyUri.Insert( 0, KSlashStr ); |
|
552 } |
|
553 |
|
554 TParse fileParser; |
|
555 if( fileParser.Set( copyUri, NULL, NULL ) != KErrNone ) |
|
556 { |
|
557 return EFalse; |
|
558 } |
|
559 |
|
560 if ( fileParser.DrivePresent() ) |
|
561 { |
|
562 // The uri is an absolute path |
|
563 aFileName.Append( fileParser.Drive() ); |
|
564 // Append path, file name and extension from the uri. |
|
565 if ( fileParser.PathPresent() ) |
|
566 { |
|
567 aFileName.Append( fileParser.Path() ); |
|
568 } |
|
569 if ( fileParser.NamePresent() ) |
|
570 { |
|
571 aFileName.Append( fileParser.Name() ); |
|
572 } |
|
573 if ( fileParser.ExtPresent() ) |
|
574 { |
|
575 aFileName.Append( fileParser.Ext() ); |
|
576 } |
|
577 |
|
578 if ( !ConeUtils::FileExists( aFileName ) ) |
|
579 { |
|
580 return EFalse; |
|
581 } |
|
582 return ETrue; |
|
583 } |
|
584 else |
|
585 { |
|
586 |
|
587 TParse svgFilenameParser; |
|
588 if ( svgFilenameParser.Set( aRefPath,NULL,NULL ) != KErrNone ) |
|
589 { |
|
590 return EFalse; |
|
591 } |
|
592 |
|
593 if ( svgFilenameParser.DrivePresent() ) |
|
594 { |
|
595 aFileName.Append( svgFilenameParser.Drive() ); |
|
596 } |
|
597 |
|
598 TInt dotdotPos = copyUri.Find( KDotDot ); |
|
599 TInt rightPos = 0; |
|
600 |
|
601 if ( dotdotPos != KErrNotFound ) |
|
602 { |
|
603 // If ".." is present collapse it with the parent path |
|
604 if ( svgFilenameParser.PathPresent() ) |
|
605 { |
|
606 do |
|
607 { |
|
608 if ( dotdotPos > 1 ) |
|
609 { |
|
610 svgFilenameParser.AddDir( copyUri.Left(dotdotPos - 1) ); |
|
611 } |
|
612 |
|
613 if ( svgFilenameParser.PopDir() != KErrNone ) |
|
614 { |
|
615 return EFalse; |
|
616 } |
|
617 |
|
618 rightPos = (copyUri.Length()) - (dotdotPos + 3); |
|
619 |
|
620 if ( rightPos > 0 ) |
|
621 { |
|
622 copyUri = copyUri.Right( rightPos ); |
|
623 } |
|
624 |
|
625 }while ( (dotdotPos = copyUri.Find( KDotDot ) ) |
|
626 != KErrNotFound ); |
|
627 |
|
628 aFileName.Append( svgFilenameParser.Path() ); |
|
629 aFileName.Append( copyUri ); |
|
630 } |
|
631 else |
|
632 { |
|
633 return EFalse; |
|
634 } |
|
635 } |
|
636 else |
|
637 { |
|
638 if ( svgFilenameParser.PathPresent() ) |
|
639 { |
|
640 aFileName.Append( svgFilenameParser.Path() ); |
|
641 } |
|
642 |
|
643 // Append path, file name and extension from the uri. |
|
644 if ( fileParser.PathPresent() ) |
|
645 { |
|
646 TFileName path(fileParser.Path() ); |
|
647 path.Copy(path.Right(path.Length()-1)); |
|
648 aFileName.Append( path ); |
|
649 |
|
650 } |
|
651 |
|
652 if ( fileParser.NamePresent() ) |
|
653 { |
|
654 aFileName.Append( fileParser.Name() ); |
|
655 } |
|
656 if ( fileParser.ExtPresent() ) |
|
657 { |
|
658 aFileName.Append( fileParser.Ext() ); |
|
659 } |
|
660 } |
|
661 if ( !ConeUtils::FileExists( aFileName ) ) |
|
662 { |
|
663 return EFalse; |
|
664 } |
|
665 return ETrue; |
|
666 } |
|
667 } |
|
668 |
|
669 HBufC* CSvgReadCodec::GetImagesPath( |
|
670 CSvgReadCodec::TImagesLocation aImagesLocation) const |
|
671 { |
|
672 HBufC* fullImagesPath = HBufC::New( KMaxPath ); |
|
673 if(fullImagesPath) |
|
674 { |
|
675 TPtr ptrFullImagesPath(fullImagesPath->Des()); |
|
676 |
|
677 TPtrC8 ptrImagesPath((TText8*)text_images_path); |
|
678 TFileName imagesPath16; |
|
679 imagesPath16.Copy(ptrImagesPath); |
|
680 |
|
681 switch( aImagesLocation ) |
|
682 { |
|
683 case EPhoneMemory: |
|
684 { |
|
685 TPtrC8 ptrRootPhoneMemPath((TText8*)text_phone_memory_root_path); |
|
686 ptrFullImagesPath.Copy(ptrRootPhoneMemPath); |
|
687 } |
|
688 break; |
|
689 case EMemoryCard: |
|
690 { |
|
691 TPtrC8 ptrRootMemCardPath((TText8*)text_memory_card_root_path); |
|
692 ptrFullImagesPath.Copy(ptrRootMemCardPath); |
|
693 } |
|
694 break; |
|
695 default: |
|
696 break; |
|
697 } |
|
698 ptrFullImagesPath.Append(imagesPath16); |
|
699 } |
|
700 return fullImagesPath; |
|
701 } |
|
702 |
|
703 //------------------------------------------------------------------------ |
|
704 //From MsvgLoadingListener |
|
705 /** |
|
706 * Query the listener if every element is to be reported or only |
|
707 * the children of <svg> tag. |
|
708 * |
|
709 * @since 1.0 |
|
710 * @return : ETrue if every element is to be reported, otherwise |
|
711 * only the children of <svg> are reported. |
|
712 */ |
|
713 TBool CSvgReadCodec::ReportAllElements() |
|
714 { |
|
715 return ETrue; |
|
716 } |
|
717 |
|
718 /** |
|
719 * Query the listener if client will call 'AssignImageData' to decode images |
|
720 * separately from parsing. This is used to avoid non-thread-safe calls in |
|
721 * creating bitmap and decoding images, which must be executed in the main thread. |
|
722 * |
|
723 * @since 1.0 |
|
724 * @return : ETrue to use 'ImageDataReference' instead of 'FetchImage'. |
|
725 */ |
|
726 TBool CSvgReadCodec::WillAssignImageData() |
|
727 { |
|
728 return ETrue; |
|
729 } |
|
730 |
|
731 /** |
|
732 * Callback when the href:xlink attribute is encountered for the <image> |
|
733 * element. This method is used to notify clients of image data references |
|
734 * needed by <image> element. This method is called only when 'WillAssignImageData' |
|
735 * returns ETrue. |
|
736 * |
|
737 * @since 1.0 |
|
738 * @return : none. |
|
739 */ |
|
740 void CSvgReadCodec::ImageDataReference( const TDesC& aUri ) |
|
741 { |
|
742 iImagesPresent = ETrue; |
|
743 |
|
744 HBufC8* lImageData = NULL; |
|
745 |
|
746 TInt errorCode = KErrNotFound; |
|
747 TInt ret = 0; |
|
748 TRAPD(err, ret = IsDownloadNeededL(aUri)); |
|
749 if(err==KErrNone) |
|
750 { |
|
751 if( ret != ELocalImageFile) |
|
752 { |
|
753 lImageData = HBufC8::New(0); |
|
754 if(lImageData) |
|
755 { |
|
756 iSvgModule->AssignImageData(aUri , lImageData ); |
|
757 } |
|
758 |
|
759 return; |
|
760 } |
|
761 |
|
762 _LIT(KEncodedImage,"data:image"); |
|
763 |
|
764 if( ! ( aUri.Left(10).Compare(KEncodedImage) )) |
|
765 { |
|
766 _LIT(KBase,"Base64"); |
|
767 if(aUri.FindF(KBase) != KErrNotFound) |
|
768 { |
|
769 TInt startIndex = aUri.Locate( ';' ); |
|
770 TInt endIndex = aUri.Locate( ',' ); |
|
771 // find index of first character after white-space |
|
772 TInt index = endIndex + 1; |
|
773 while ( index < aUri.Length() && TChar( aUri[index] ).IsSpace() ) |
|
774 index++; |
|
775 // must be 8-bit |
|
776 TInt length = aUri.Length() - index; |
|
777 HBufC8* encoded = HBufC8::New( length ); |
|
778 if(encoded) |
|
779 { |
|
780 encoded->Des().Copy( aUri.Right( length ) ); |
|
781 // Assign to member variable to destroy after image is process. |
|
782 lImageData = HBufC8::New( length ); |
|
783 if(lImageData) |
|
784 { |
|
785 TPtr8 decodedDes = lImageData->Des(); |
|
786 // decode |
|
787 TImCodecB64 encodingBase64; |
|
788 TInt decodeError = encodingBase64.Decode( *encoded, decodedDes ); |
|
789 delete encoded; |
|
790 encoded = NULL; |
|
791 } |
|
792 } |
|
793 } |
|
794 else |
|
795 { |
|
796 //lImageData = HBufC8::NewL(0); |
|
797 } |
|
798 } |
|
799 else |
|
800 { |
|
801 RFile lSvgFile; |
|
802 TFileName lFileName; |
|
803 RFs session; |
|
804 |
|
805 TInt Connecterror = session.Connect(); |
|
806 |
|
807 HBufC* phoneMemImagesPath = GetImagesPath(EPhoneMemory); |
|
808 TPtr ptrphoneMemImagesPath(phoneMemImagesPath->Des()); |
|
809 HBufC* memCardImagesPath = GetImagesPath(EMemoryCard); |
|
810 TPtr ptrMemCardImagesPath(memCardImagesPath->Des()); |
|
811 |
|
812 if(GetLocalFile( aUri, lFileName, ptrphoneMemImagesPath)) |
|
813 errorCode = lSvgFile.Open( session, lFileName, EFileShareAny ); |
|
814 else if(GetLocalFile( aUri, lFileName, ptrMemCardImagesPath)) |
|
815 errorCode = lSvgFile.Open( session, lFileName, EFileShareAny ); |
|
816 |
|
817 delete memCardImagesPath; |
|
818 delete phoneMemImagesPath; |
|
819 |
|
820 if(errorCode == KErrNone) |
|
821 { |
|
822 // Get the size of the data to create read buffer |
|
823 TInt lFileSize = 0; |
|
824 TInt sizeError = lSvgFile.Size(lFileSize) ; |
|
825 // Create buffer that will contain the file data |
|
826 lImageData = HBufC8::New(lFileSize); |
|
827 if(lImageData) |
|
828 { |
|
829 TPtr8 lFileDataPtr(lImageData->Des()); |
|
830 |
|
831 // Read from the file |
|
832 TInt ReadError = lSvgFile.Read(lFileDataPtr); |
|
833 } |
|
834 } |
|
835 else |
|
836 { |
|
837 lImageData = HBufC8::New(0); |
|
838 } |
|
839 lSvgFile.Close(); |
|
840 session.Close(); |
|
841 } |
|
842 if(lImageData) |
|
843 { |
|
844 iSvgModule->AssignImageData(aUri , lImageData ); |
|
845 } |
|
846 } |
|
847 } |
|
848 |
|
849 /** |
|
850 * Notified when the start of a svg document(<svg> tag) is encountered. |
|
851 * |
|
852 * @since 1.0 |
|
853 * @return : For future use. Value is ignored. |
|
854 */ |
|
855 TBool CSvgReadCodec::DocumentStart() |
|
856 { |
|
857 return EFalse; |
|
858 } |
|
859 |
|
860 /** |
|
861 * Notified when the end of a svg document(</svg> tag) is encountered. |
|
862 * |
|
863 * @since 1.0 |
|
864 * @return : For future use. Value is ignored. |
|
865 */ |
|
866 TBool CSvgReadCodec::DocumentEnd() |
|
867 { |
|
868 return ETrue; |
|
869 } |
|
870 |
|
871 /** |
|
872 * Notified when the start of a svg element is encountered. |
|
873 * |
|
874 * @since 1.0 |
|
875 * @param : aTagName -- name of svg tag |
|
876 * @param : aAttributeList -- attribute list. |
|
877 * @return : For future use. Value is ignored. |
|
878 */ |
|
879 TBool CSvgReadCodec::ElementStart( const TDesC& /*aTagName*/, |
|
880 MSvgAttributeList& /*aAttributeList*/) |
|
881 { |
|
882 return ETrue; |
|
883 } |
|
884 |
|
885 /** |
|
886 * Notified when the end of a svg element is encountered. |
|
887 * activated. |
|
888 * |
|
889 * @since 1.0 |
|
890 * @param : aTagName -- name of svg tag |
|
891 * @return : For future use. Value is ignored. |
|
892 */ |
|
893 TBool CSvgReadCodec::ElementEnd( const TDesC& /*aTagName*/ ) |
|
894 { |
|
895 return ETrue; |
|
896 } |
|
897 |
|
898 /** |
|
899 * Notified when an external data is needed by the svg document, |
|
900 * such as a image-file or an embedded svg-file. |
|
901 * |
|
902 * @since 1.0 |
|
903 * @param : aUri -- URI string of external data |
|
904 * @return : For future use. Value is ignored. |
|
905 */ |
|
906 TBool CSvgReadCodec::ExternalDataRequested( const TDesC& /*aUri*/ ) |
|
907 { |
|
908 return EFalse; |
|
909 } |
|
910 |
|
911 /** |
|
912 * Notified when an external data has been retrieved, |
|
913 * such as a image-file or an embedded svg-file. |
|
914 * |
|
915 * @since 1.0 |
|
916 * @param : aUri -- URI string of external data |
|
917 * @return : For future use. Value is ignored. |
|
918 */ |
|
919 TBool CSvgReadCodec::ExternalDataReceived( const TDesC& /*aUri*/ ) |
|
920 { |
|
921 return EFalse; |
|
922 } |
|
923 |
|
924 /** |
|
925 * Notified when an external data request has failed. |
|
926 * |
|
927 * @since 1.0 |
|
928 * @param : aUri -- URI string of external data |
|
929 * @return : For future use. Value is ignored. |
|
930 */ |
|
931 TBool CSvgReadCodec::ExternalDataRequestFailed( const TDesC& /*aUri*/ ) |
|
932 { |
|
933 return EFalse; |
|
934 } |
|
935 |
|
936 /** |
|
937 * Notified when an unsupported element is encountered. |
|
938 * |
|
939 * @since 1.0 |
|
940 * @param : aTagName -- tag name of element |
|
941 * @param : aAttributeList -- attribute list. |
|
942 * @return : For future use. Value is ignored. |
|
943 */ |
|
944 TBool CSvgReadCodec::UnsupportedElement( const TDesC& /*aTagName*/, |
|
945 MSvgAttributeList& /*aAttributeList*/ ) |
|
946 { |
|
947 return EFalse; |
|
948 } |
|
949 |
|
950 |
|
951 void CSvgReadCodec::ImagesLoaded(TInt /*aError*/) |
|
952 { |
|
953 iImagesLoaded = ETrue; |
|
954 iImagesPresent = EFalse; |
|
955 } |
|
956 |
|
957 void CSvgReadCodec::GetNewDataPosition(TInt& aPosition, TInt& /*aLength*/) |
|
958 { |
|
959 // Reset position to force seek to beginning |
|
960 aPosition =0; |
|
961 } |
|
962 |
|
963 |
|
964 |
|
965 |
|
966 |
|
967 //End of file |
|