1 /*

     2 * Copyright (c) 2004,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 SVGT Custom Control which

    15 *                is used to display SVGT content

    16 *

    17 */

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <aknnotewrappers.h>

    23 #include <AknWaitNoteWrapper.h>

    24 #include <AknIconUtils.h>

    25 #include <aknlayoutscalable_apps.cdl.h>

    26 #include <AknsConstants.h>

    27 #include <AknsSkinInstance.h>

    28 #include <AknsUtils.h>

    29 #include <AknWaitDialog.h>

    30 #include <bitdev.h>

    31 #include <StringLoader.h>

    32 #include <DRMHelper.h>

    33 #include <eikenv.h> //CEikonEnv

    34 #include <e32math.h>

    35 #include <uri16.h>

    36 #include <ctsydomainpskeys.h> // for call handling

    37 #include <data_caging_path_literals.hrh>

    38 #include <gdi.h>

    39 #include <SVGTUIControl.rsg>

    40 #include <svgtuicontrol.mbg>

    41 // User Includes

    42 #include "SVGTUIControlDbgFlags.hrh"

    43 #include "SVGTAppObserver.h"

    44 #include "SVGTCustControl.h"

    45 #include "SVGTUIDialog.hrh"

    46 

    47 #include "SvgtController.h"

    48 #include "SvgtApplicationExitObserver.h"

    49 #include "SvgtEventHandlerAO.h"

    50 #include "SvgtEvent.h"

    51 #include <svgtfileviewdetails.h>

    52 #include <aknnavi.h>

    53 #include <aknnavide.h>

    54 #include <avkon.mbg>

    55 

    56 #ifdef RD_SVGT_AUDIO_SUPPORT

    57 #include <AknVolumePopup.h>

    58 #include<remconinterfaceselector.h>     //for CRemConInterfaceSelector

    59 #include<remconcoreapitarget.h>         //for CRemConCoreApiTarget

    60 

    61 #endif //RD_SVGT_AUDIO_SUPPORT

    62 // Constants

    63 

    64 // Panning Constants

    65 // KSccPanNumPixelsX - Amount of Pixels to Pan in X Direction when Pan is

    66 //                     performed once.

    67 // KSccPanNumPixelsY - Amount of Pixels to Pan in Y Direction when Pan is

    68 //                     performed once.

    69 const TInt KSccPanNumPixelsX = 30;

    70 const TInt KSccPanNumPixelsY = 30;

    71 

    72 // Pointer Constants

    73 // When pointer is moved in a particular direction, the movement also

    74 // acceleration. The below constants define the delta for the acceleration.

    75 // KSccCursorMinDeltaX - For X Direciton

    76 // KSccCursorMinDeltaY - For Y Direciton

    77 const TInt KSccCursorMinDeltaX = 5;

    78 const TInt KSccCursorMinDeltaY = 5;

    79 

    80 // Zoom Constants

    81 // KSccZoomInFactor - Indicates zoom factor to use while zooming in.

    82 //                    This Value should be > 1.0

    83 // KSccZoomOutFactor - Indicates zoom factor to use while zooming out.

    84 //                     This value should be > 0 and < 1.0

    85 const TReal32 KSccZoomInFactor = 2.0; // 2X Zoom In

    86 const TReal32 KSccZoomOutFactor = 0.5;// 2X Zoom Out

    87 

    88 // Key Constants

    89 const TInt KSccZoomInKey = ENumberKey5;//'5';

    90 const TInt KSccZoomOutKey =ENumberKey0; //'0';

    91 

    92 // Number of milli seconds per second

    93 const TUint32 KSccNumMSecPerSec = 1000;

    94 

    95 

    96 

    97 // Time in microsecs after which Pointer Inactivity should be declared

    98 const TUint KSccPointerHideTimerStartAfter = 15000000;

    99 

   100 // Time in microsecs per second

   101 const TInt KSccOneSecond = 1000000;

   102 

   103 // General Constants

   104 const TInt KSccConstMinusOne = -1;

   105 const TInt KSccConstZero = 0;

   106 const TInt KSccConstOne = 1;

   107 const TInt KSccConstTwo = 2;

   108 

   109 // set the name of the multi-bitmap file containing the bitmaps

   110 _LIT( KSccIconFile,"Z:SVGTUIControl.mif" );

   111 

   112 // SMIL Fit Value

   113 _LIT( KSccSmilFitValue,"meet" );

   114 

   115 // Font Ids for use with Engine-Init

   116 const TInt KApacFontId = EApacPlain16;

   117 const TInt KLatintFontId = ELatinBold12;

   118 

   119 // Duration const returned by engine when indefinite animations are present

   120 const TUint KSccIndefiniteDur = 0xffffffff;

   121 

   122 

   123 // Interval between two consecutive timer ticks in microseconds.

   124 const TUint32 KSccProgIndTimerYieldDur = 100000;

   125 

   126 //constant for converting radians to degrees

   127 const TReal32 KDegreesToRadiansFactor = 0.01745329252;

   128 

   129 // Maximum length of text in a text element

   130 const TInt KSccMaxTextLength = 250;

   131 const TInt KBackLightTimeInterval = 9;

   132 const TInt KMaxEditorTextLength = 5120; 

   133 const TInt KEmbededImageTagLength = 5;

   134 const TInt KSchemaLength = 4;

   135 

   136 #ifdef RD_SCALABLE_UI_V2

   137 const TInt KInitRepeatInterval = 10000;

   138 #endif // RD_SCALABLE_UI_V2

   139 

   140 // Background colour which is used by engine before rendering as a base colour

   141 const TUint32 KSccArgbWhite = 0xffffffff;

   142 

   143 //TOUCH

   144 #ifdef RD_SVGT_AUDIO_SUPPORT

   145 const TInt KDefaultVolumeLevel = 3;   

   146 const TInt KMinVolume = 0;

   147 const TInt KMaxVolume = 10;

   148 #endif // RD_SVGT_AUDIO_SUPPORT

   149 //TOUCH

   150 #ifdef _DEBUG

   151 // Backlight Strings

   152 _LIT( KSccBacklightOnStr, "Backlight On" );

   153 _LIT( KSccBacklightOffStr, "Backlight Off" );

   154 #endif

   155 

   156 //Loading thread name

   157 _LIT(KSvgThread,"SvgThread");

   158 

   159 _LIT(KJpg,   ".jpg" );

   160 _LIT(KJpeg,  ".jpeg" );

   161 _LIT(KPng,   ".png" );

   162 _LIT(KBmp,   ".bmp" );

   163 _LIT(KSvg,   ".svg" );

   164 _LIT(KSvgz,  ".svgz" );

   165 

   166 _LIT( KWww, "www" );

   167 _LIT( KHttp, "http://");

   168 // ============================ MEMBER FUNCTIONS ===============================

   169 

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

   171 // CSVGTCustControl::CSVGTCustControl

   172 // C++ default constructor.

   173 // -----------------------------------------------------------------------------

   174 //

   175 CSVGTCustControl::CSVGTCustControl(

   176     RFile& aFileHandle, // File Handle of SVGT content

   177     TBool aProgressiveRendering,

   178     TInt aFlag ) :

   179     // Animation State

   180     iTotalNumerOfAnimation( KSccConstMinusOne ),

   181     iAnimationStatus( ESvgNoAnimationsPresent ),

   182     iAnimState( ESvgAnimStoppedState ),

   183     iContentFileHandle( aFileHandle ),

   184     // SVG Engine

   185     iIsLoadingDone( EFalse ),

   186     iFetchImageError( 0 ),

   187     // Control State Variables

   188     iZoomLevel( 0 ),

   189     iIsLoopOn( EFalse ),

   190     iIsFullScreenOn( EFalse ),

   191     // Pointer Variables

   192     iPointerDx( 0 ),

   193     iPointerDy( 0 ),

   194     iPointerX( 0 ),

   195     iPointerY( 0 ),

   196     // Current Match is invalid

   197     iIsSearchStrValid( EFalse ),

   198     iCurSearchMatchId( 0 ),

   199     iNumAnimInProgress( 0 ),

   200     iIsPointerDisplayed( ETrue ),                 

   201     iFindTextHiColor( KRgbBlack ),               

   202     iIgnorePointerKeyEvent( EFalse ),

   203     iPointerType( ESvgPointerDefault ),

   204     iEnableTextOps( ETrue ),

   205     iIsTextEditOn( EFalse ),

   206     iIsTextSelectOn(EFalse),

   207     iProgressiveRendering(aProgressiveRendering),

   208     iDisplayFlags( aFlag ),

   209     iEventHandlerAO(NULL),

   210     iThreadController(NULL),

   211     iIsWaitNoteDisplayed(EFalse),

   212 #ifdef RD_SVGT_AUDIO_SUPPORT

   213 	iVolumeLevel(KDefaultVolumeLevel),

   214 	iPrevVolume(KDefaultVolumeLevel),

   215 #endif //RD_SVGT_AUDIO_SUPPORT

   216     iIsTextChanged( EFalse ),

   217     iViewerCommand(EFalse),

   218     iPlayMSKLabel(EFalse),

   219     iContextMenuActivated(EFalse),

   220     iAElement(EFalse),

   221     iScrollKey(EFalse),

   222     iPointerDownAnimation(EFalse),

   223     iInteractiveElementEnteredCnt(0),

   224     iDownKeyOccurred(EFalse),

   225     iIsVolumeMuted(EFalse),

   226     iIsForeground(ETrue)

   227     {

   228     }

   229 

   230 

   231 // -----------------------------------------------------------------------------

   232 // CSVGTCustControl::ConstructL

   233 // Symbian 2nd phase constructor.

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

   235 //

   236 void CSVGTCustControl::ConstructL(

   237     MSvgtAppObserver* aAppObs, // User Implementation of Mixin

   238     MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering

   239                                             // progress indicator

   240 	MSVGTMSKImpl* aMSKImpl,		//Interface for MSK labelling                                           

   241     MSvgtApplicationExitObserver* aExitObserver,

   242     const CCoeControl* aParent )

   243     {

   244     iEngineInitialized = EFalse;

   245     // Save the user parameters for later access.

   246     iAppObserver = aAppObs;

   247     iProgressBarDrawImpl = aPBDrawImpl;

   248     iMSKImpl=aMSKImpl;

   249     iExitObserver = aExitObserver;

   250    

   251     TRect lRect;

   252     GetNormalScreenLayoutRect( lRect );

   253     // Frame buffers creation

   254     CreateBitmapsL( lRect.Size() );

   255 

   256     // Icons(Pointer, Pan Ind) creation

   257     CreateIconsL();

   258 

   259 #ifdef RD_SVGT_AUDIO_SUPPORT

   260     iVolumePopup = CAknVolumePopup::NewL(NULL, ETrue);

   261     iVolumePopup->SetObserver(this);

   262     _LIT( KVolumePopupTitle, "Presentation volume");

   263     iVolumePopup->SetTitleTextL(KVolumePopupTitle);

   264     iVolumePopup->SetRange( KMinVolume, KMaxVolume);

   265     iVolumePopup->SetValue( KDefaultVolumeLevel );

   266     

   267     

   268     // Open a connection to receive Volume Key events.

   269     iSelector = CRemConInterfaceSelector::NewL();

   270     iInterfaceSelector = CRemConCoreApiTarget::NewL(*iSelector,*this);

   271     TRAPD(err, iSelector->OpenTargetL());

   272     if(err != KErrNone)

   273     {

   274 		#ifdef _DEBUG

   275 		RDebug::Printf("Leave occured in OpenTargetL. Error code returned %d",err);

   276 		#endif

   277     }

   278     

   279 #endif  //RD_SVGT_AUDIO_SUPPORT

   280 

   281     // DrmHelper to display save related query

   282     iSvgDrmHelper = CSVGTDrmHelper::NewL();

   283 

   284     // Check if it is a preview file

   285     iPreviewMode = iSvgDrmHelper->IsPreviewL( iContentFileHandle );

   286    

   287     // Initialise the SVG engine.

   288     InitializeEngineL();

   289    

   290    

   291 //############################################################

   292     // Create the timer for Pointer Inactivity

   293     if ( iDisplayFlags & ESvgDrawPointer )

   294         {

   295         iInactivityTimer = CSVGTPointerHideTimer::NewL( this );

   296         iInactivityTimer->After( KSccPointerHideTimerStartAfter );

   297         }

   298 

   299     // Create the timer for blinking Pause

   300     if ( iDisplayFlags & ESvgDrawPauseIndicator )

   301         {

   302 

   303         iBlinker = CPeriodic::NewL( CTimer::EPriorityStandard );

   304         }   

   305 

   306     // Create the timer for removal of info note

   307     if ( iDisplayFlags & ESvgDisplayErrorNotes)

   308         {

   309         // Create the timer for removal of info note

   310         iNoteRemoverTimer = CPeriodic::NewL( CTimer::EPriorityHigh );

   311         }

   312 

   313     if ( iDisplayFlags & ESvgDisplayErrorNotes )

   314         {

   315         // Create instance of DRM Helper for checking rights for content   

   316         iSvgDrmHelper->CheckRightsAmountL( iContentFileHandle );

   317         }

   318    

   319     //Initialize the backlight time to current time

   320     iPreviousBackLightTimeStamp.HomeTime();

   321     if(iProgressiveRendering)

   322         {

   323         iEventHandlerAO = CSvgtEventHandlerAO::NewL( aAppObs, this,

   324 RThread().Id());

   325         

   326         iThreadController = CSvgtThreadController::NewL(this);

   327         //Separate thread is created to load the content

   328         // set up parameters to thread generate thread, leave if fails

   329         TInt result = iMainThread.Create( KSvgThread,

   330                                       ( TThreadFunction )LoadSvgContent,

   331                                       KDefaultStackSize,

   332                                       NULL, this, EOwnerProcess );

   333         User::LeaveIfError( result );

   334         // log on to thread & requests notification of thread completion

   335         iThreadController->IssueThreadMonitorRequest( iMainThread );

   336 

   337         // give thread low priority

   338         iMainThread.SetPriority( EPriorityMuchLess );

   339         // resume thread (wake it up sometime after this function returns)

   340         iMainThread.Resume();

   341         }

   342     else

   343         {

   344         // Start displaying wait note

   345         LaunchWaitNoteL( R_QTN_SVGT_WAITING_OPENING );

   346    

   347         // Load the SVGT content

   348         LoadContentL( iContentFileHandle );

   349 

   350         // Dismiss the wait note

   351         DismissWaitNote();

   352 

   353         TInt lLoadErr = DoHandleLoadingThreadError();

   354         if ( lLoadErr != KErrNone )

   355             {

   356             if ( lLoadErr != KErrNoMemory )

   357                 {

   358                 // All errors other than memory failure related are

   359                 // ignored.

   360                 lLoadErr = KErrNone;

   361                 }

   362             User::Leave( lLoadErr );   

   363             }

   364        

   365         // Do the post load functionality

   366         DoPostLoadFuncL();   

   367         }

   368     if ( aParent && (iDisplayFlags & ESvgWindowOwning ))

   369         {

   370         CreateWindowL( aParent );

   371         }

   372 //############################################################

   373     // Set the windows size

   374     SetRect( lRect );

   375 

   376     // Activate the window, which makes it ready to be drawn

   377     ActivateL();   

   378     }

   379 

   380 

   381 // -----------------------------------------------------------------------------

   382 // CSVGTCustControl::NewL

   383 // Factory function for creating CSVGTCustControl objects.

   384 // Returns: CSVGTCustControl* ; Pointer to the created object.

   385 //          Leaves if error occurs during creation.

   386 // -----------------------------------------------------------------------------

   387 //

   388 EXPORT_C CSVGTCustControl* CSVGTCustControl::NewL(

   389     RFile& aFileHandle,         // File Handle for the content

   390     MSvgtAppObserver* aAppObs,  // User Implementation of Mixin

   391     MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering

   392                                             // progress indicator

   393 	MSVGTMSKImpl* aMSKImpl,		//Interface for MSK labelling                                          

   394     MSvgtApplicationExitObserver* aExitObserver,

   395     TBool aProgressiveRendering,

   396     const CCoeControl* aParent,                                           

   397     TInt aDisplayFlag )

   398     {

   399     CSVGTCustControl* self = CSVGTCustControl::NewLC( aFileHandle,

   400                                                       aAppObs,

   401                                                       aPBDrawImpl,

   402                                                       aMSKImpl,

   403                                                       aExitObserver,

   404                                                       aProgressiveRendering,

   405                                                       aParent,

   406                                                       aDisplayFlag );

   407     CleanupStack::Pop( self );

   408     return self;

   409     }

   410 

   411 // -----------------------------------------------------------------------------

   412 // CSVGTCustControl::NewLC

   413 // Factory function for creating CSVGTCustControl objects.

   414 // Returns: CSVGTCustControl* ; Pointer to the created object.

   415 //          Leaves if error occurs during creation.

   416 // -----------------------------------------------------------------------------

   417 //

   418 CSVGTCustControl* CSVGTCustControl::NewLC(

   419     RFile& aFileHandle,         // File handle for the content

   420     MSvgtAppObserver* aAppObs , // User Implementation of Mixin

   421     MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering

   422                                             // progress indicator

   423 	MSVGTMSKImpl* aMSKImpl,		//Interface for MSK labelling                                            

   424     MSvgtApplicationExitObserver* aExitObserver,

   425     TBool aProgressiveRendering,

   426     const CCoeControl* aParent,                                           

   427     TInt aDisplayFlag )

   428     {

   429     CSVGTCustControl* self = new ( ELeave ) CSVGTCustControl( aFileHandle,

   430                                                              

   431 aProgressiveRendering,

   432                                                               aDisplayFlag );

   433     CleanupStack::PushL( self );

   434     self->ConstructL( aAppObs, aPBDrawImpl ,aMSKImpl, aExitObserver, aParent );

   435     return self;

   436     }

   437 

   438 // -----------------------------------------------------------------------------

   439 // CSVGTCustControl::~CSVGTCustControl

   440 // Destructor

   441 // -----------------------------------------------------------------------------

   442 //

   443 CSVGTCustControl::~CSVGTCustControl()

   444     {

   445     

   446 #ifdef RD_SVGT_AUDIO_SUPPORT

   447     // if non volume key is pressed <br>

   448     if(iVolumePopup)

   449         {

   450         iVolumePopup->CloseVolumePopup();

   451         delete iVolumePopup;

   452         iVolumePopup=NULL;

   453         }

   454     if(iSelector)

   455         {

   456         delete iSelector;

   457         iInterfaceSelector=NULL;

   458         iSelector=NULL; //iSelector has been deleted by "delete iInterfaceSelector"

   459         }

   460     

   461 #endif //RD_SVGT_AUDIO_SUPPORT       

   462 

   463     if(iProgressiveRendering)

   464         {

   465         TInt count = 0;

   466         if(iSvgModule)

   467             {

   468             if ( iSvgModule->IsLoading() )

   469                 {

   470                 iSvgModule->CancelLoad();

   471                 do

   472                     {

   473                     User::After( 10 * 1000 ); // milliseconds

   474                     }while ( iSvgModule->IsLoading() && count++ < 100 );

   475                 }

   476             }

   477 

   478         if(iThreadController)

   479             {

   480             iThreadController->StopThreadExecution(iMainThread);

   481             }

   482        

   483         iMainThread.Kill(KErrNone);

   484         iMainThread.Close();

   485 

   486         delete iEventHandlerAO;

   487        

   488         delete iThreadController;

   489         }

   490        

   491     // Hyperlink Handler

   492     if ( iSvgModule )

   493         {

   494         iSvgModule->RemoveHyperlinkListener( 

   495         	static_cast< MSvgHyperlinkListener*> ( this ) );

   496         iSvgModule->RemoveListener( static_cast<MSvgLoadingListener*>(this),

   497                                                 ESvgLoadingListener);

   498         iSvgModule->RemoveListener( static_cast<MSvgLoadingListener*>(this),

   499                                                 ESvgHyperlinkListener);

   500         iSvgModule->RemoveListener( static_cast<MSvgInteractiveElementListener*>(this), ESvgInteractiveElementListener);

   501         }

   502          

   503     // SVG Engine

   504     delete iSvgModule;

   505    

   506     // Free the icons

   507     FreeIcons();

   508    

   509     // Screen Bitmaps + Masks

   510     delete iSVGTBitMap;

   511     delete iSVGTBitMapMask;

   512    

   513     // delete SVG drmHelper

   514     delete iSvgDrmHelper;

   515 

   516    

   517    // Delete the arrays

   518    iBoundBoxArray.Close();

   519    iFoundTextArray.Close();

   520    iTextElemIdArray.Close();

   521 

   522     // Reset App Observer

   523     iAppObserver = NULL;

   524    

   525     // Reset Progress Bar Draw Implementation Callback

   526     iProgressBarDrawImpl = NULL;

   527     // Current Match is invalid

   528     iIsSearchStrValid = EFalse;

   529     iCurSearchMatchId = KSccConstZero;

   530 

   531     // Backlight Timer

   532 

   533     // Progress Indicator Timer

   534     delete iProgressBarTimer;

   535         

   536     // Pointer Inactivity Hide Timer

   537     delete iInactivityTimer;

   538 

   539     // Pause Blink Timer

   540     delete iBlinker;

   541    

   542     // Framebuffer  Bitmap

   543     delete iSVGTFrameBufBitMap;

   544    

   545     // Framebuffer Bitmap Context

   546     delete iSVGTFrameBufContext;

   547    

   548     // Framebuffer Bitmap Device

   549     delete iSVGTFrameBufDevice;

   550    

   551     // Delete the wait dialog

   552     delete iWaitDialog;

   553    

   554     // Delete the info note

   555     delete iInfoNote;

   556    

   557     // Delete the info note remover timer

   558     delete iNoteRemoverTimer;

   559    

   560     // Close the System RProperty

   561     iSystemState.Close(); 

   562    

   563     // Reset the loading thread error

   564     iLoadingThreadError = NULL;

   565    

   566     // Reset the exit observer

   567     iExitObserver = NULL;

   568    

   569     }

   570 

   571 // -----------------------------------------------------------------------------

   572 // CSVGTCustControl::ProcessViewerCommandL

   573 // Process commands for handling SVGT content

   574 // -----------------------------------------------------------------------------

   575 //

   576 void CSVGTCustControl::ProcessViewerCommandL( TInt aCommandId ) // Command ID

   577                                                                 // be processed

   578     {

   579    //Set the flag to indicate that the selection key is for options selection

   580     iViewerCommand=ETrue;

   581     switch( aCommandId )

   582         {

   583         case ESvgtDlgSaveCommand:

   584             break;

   585         case ESvgtDlgZoomInCommand:

   586             // Perform Zoom operation

   587             iSvgModule->Zoom( KSccZoomInFactor );

   588             // Do a Redraw

   589             iSvgModule->Redraw();

   590             //dummy mouse move

   591             iSvgModule->MouseMove( iPointerX, iPointerY );

   592             iZoomLevel++;

   593             UpdatePointer();

   594             break;

   595         case ESvgtDlgZoomOutCommand:

   596             if ( iZoomLevel > KSccConstZero )

   597                 {

   598                 iZoomLevel--;

   599                 // Perform Zoom operation

   600                 iSvgModule->Zoom( KSccZoomOutFactor );

   601                 // Do a Redraw

   602                 iSvgModule->Redraw();

   603                 //dummy mouse move

   604                 iSvgModule->MouseMove( iPointerX, iPointerY );

   605                 UpdatePointer();

   606                 }

   607             break;

   608         case ESvgtDlgZoomOptimalCommand:

   609             if ( iZoomLevel != KSccConstZero )

   610                 {

   611                 //This is to nullify only the zooming effect

   612                 //Other transformations(panning, rotation) won't be restored

   613                 TReal reducedFactor = 0.0;

   614                 Math::Pow(reducedFactor, KSccZoomOutFactor, iZoomLevel);

   615                 iZoomLevel = KSccConstZero;

   616                 iSvgModule->Zoom(reducedFactor);

   617                 iSvgModule->Redraw();

   618                 }

   619             break;

   620         case ESvgtDlgSelectTextCommand:

   621             {

   622             if ( iEnableTextOps )

   623                 {

   624                 HBufC* lStrPtr = HBufC::NewLC( KMaxEditorTextLength ); 

   625                 TPtr lPtr = lStrPtr->Des();

   626                

   627                 if ( iCurrentTextElementId )

   628                     {

   629                     if ( iIsCurrentTextElement )

   630                         {

   631                         iSvgModule->GetTextForTextElement(

   632                             iCurrentTextElementId,

   633                             iIsTextEditOn,

   634                             lPtr );

   635                         }

   636                         else

   637                             {

   638                             iSvgModule->GetTextForTextAreaElement(

   639                                 iCurrentTextElementId,

   640                                 iIsTextEditOn,

   641                                 lPtr );

   642                             }

   643                    

   644                     DoTextSelectionL( lPtr );

   645                     }

   646                 CleanupStack::PopAndDestroy( lStrPtr );                   

   647                 }

   648             }

   649             break;

   650         case ESvgtDlgEditTextCommand:

   651             {

   652             if ( iEnableTextOps )

   653                 {

   654                 if ( iCurrentTextElementId )

   655                     {

   656                     HBufC* lStrPtr = HBufC::NewLC( KMaxEditorTextLength ); 

   657                     TPtr lPtr = lStrPtr->Des();

   658 

   659                     if ( iIsCurrentTextElement )

   660                         {

   661                         iSvgModule->GetTextForTextElement(

   662                             iCurrentTextElementId,

   663                             iIsTextEditOn,

   664                             lPtr );

   665                         }

   666                         else

   667                             {

   668                             iSvgModule->GetTextForTextAreaElement(

   669                                 iCurrentTextElementId,

   670                                 iIsTextEditOn,

   671                                 lPtr );

   672                             }

   673                    

   674                    

   675                     DoTextEditingL( iIsCurrentTextElement,

   676                                     iCurrentTextElementId,

   677                                     lPtr );

   678                     CleanupStack::PopAndDestroy( lStrPtr );                               

   679                     }

   680                 }

   681             }

   682             break;

   683         case ESvgtDlgPlayCommand:

   684             ProcessPlayCmd();

   685             break;

   686         case ESvgtDlgPauseCommand:

   687             ProcessPauseCmd();

   688             break;

   689         case ESvgtDlgStopCommand:

   690             ProcessStopCmd();

   691             break;

   692 //TOUCH SUPPORT START   

   693 #ifdef RD_SVGT_AUDIO_SUPPORT

   694         case ESvgtDlgSetVolumeCommand:

   695             {

   696             // The volume popup will close itself after 1s 

   697             // unless another call to ShowVolumePopupL() is made

   698             if(iIsVolumeMuted)

   699             	{

   700             	// Set the volume of pop to zero if muted.

   701             	iVolumePopup->SetValue( 0 );

   702             	iVolumePopup->ShowVolumePopupL();

   703             	}

   704             else

   705             	{

   706             	// If not muted, then show the previous volume

   707             	iVolumePopup->SetValue( iPrevVolume );

   708             	iVolumePopup->ShowVolumePopupL(); 

   709             	}

   710             break;

   711             }

   712 #endif //RD_SVGT_AUDIO_SUPPORT

   713 //TOUCH SUPPORT END

   714         case ESvgtDlgLoopOnCommand:

   715             if ( IsContentFinite() )

   716                 {

   717                 iIsLoopOn = ETrue;

   718                 }

   719             break;

   720         case ESvgtDlgLoopOffCommand:

   721             if ( IsContentFinite() )

   722                 {

   723                 iIsLoopOn = EFalse;

   724                 }

   725             break;

   726         case ESvgtDlgFindTextCommand:

   727             ProcessFindTextCmdL();

   728             break;

   729         case ESvgtDlgFullScreenCommand: // Fall Through

   730         case ESvgtDlgNormalScreenCommand:

   731             // No processing here. The Command is processed by the dialog.

   732             // Dialog sets the size of the control, because of which

   733             // SizeChanged() of control is called. This queries the

   734             // layout rectangles and recreates the framebuffer.

   735             break;

   736         case ESvgtDlgViewDetailsCommand:

   737             {

   738             CSvgtFileViewDetailsDialog* fileDetailsDialog =

   739                 CSvgtFileViewDetailsDialog::NewL();

   740             fileDetailsDialog->ExecuteLD( iContentFileHandle );

   741 

   742             break;

   743             }

   744         case ESvgtDlgAngle90:

   745             {

   746             DoRotation( ERotationAngle90 );

   747             }

   748             break;

   749         case ESvgtDlgAngle180:

   750             {

   751             DoRotation( ERotationAngle180 );

   752             }

   753             break;

   754         case ESvgtDlgAngle270:

   755             {

   756             DoRotation( ERotationAngle270 );

   757             }

   758             break;

   759         case ESvgtDlgHelpCommand:

   760             break;

   761         default:

   762             break;

   763         }

   764     if(iMSKImpl && !iPreviewMode)

   765     	{

   766     	TRAP_IGNORE(SetMSKLabelL());

   767     	}

   768 }

   769 // -----------------------------------------------------------------------------

   770 // CSVGTCustControl::GetCurrentZoomLevel

   771 // Get function for current zoom level. Zoom level is the number of times the

   772 // user has zoomed in.

   773 // -----------------------------------------------------------------------------

   774 //

   775 void CSVGTCustControl::GetCurrentZoomLevel(

   776     TInt& aZoomLevel ) const  // Current Zoom Level

   777     {

   778     aZoomLevel = iZoomLevel;

   779     }

   780 

   781 // -----------------------------------------------------------------------------

   782 // CSVGTCustControl::GetCurrentAnimState

   783 // Get function for current animation state

   784 // -----------------------------------------------------------------------------

   785 //

   786 void CSVGTCustControl::GetCurrentAnimState(

   787     TSvgtViewerAnimStatus& aAnimState )  const // Playing/Paused/Stopped

   788     {

   789     aAnimState = iAnimState;

   790     }

   791 

   792 // -----------------------------------------------------------------------------

   793 // CSVGTCustControl::GetCurrentFullScreenStatus

   794 // Get function for current viewing mode.

   795 // -----------------------------------------------------------------------------

   796 //

   797 void CSVGTCustControl::GetCurrentFullScreenStatus(

   798     TBool& aIsFullScreenOn )  const //  Full Screen( ETrue )/Normal( EFalse )

   799     {

   800     aIsFullScreenOn = iIsFullScreenOn;

   801     }

   802 // -----------------------------------------------------------------------------

   803 // CSVGTCustControl::GetCurrentLoopStatus

   804 // Get function for current loop mode.

   805 // -----------------------------------------------------------------------------

   806 //

   807 void CSVGTCustControl::GetCurrentLoopStatus(

   808     TBool& aIsLoopOn )  const //  Loop On( ETrue )/Loop Off( EFalse )

   809     {

   810     aIsLoopOn = iIsLoopOn;

   811     }

   812 

   813 // -----------------------------------------------------------------------------

   814 // CSVGTCustControl::GetNormalScreenLayoutRect

   815 // Gets the normal screen layout rectangle for control from LAF.

   816 // -----------------------------------------------------------------------------

   817 //

   818 void CSVGTCustControl::GetNormalScreenLayoutRect(

   819     TRect& aRect )  const // Rectangle specifying extent of control

   820     {

   821     // Get parent client rect.

   822     TRect myRect = iEikonEnv->EikAppUi()->ClientRect();

   823    

   824     if ( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )

   825         {

   826         TAknLayoutRect lNormalLayoutRect;

   827         lNormalLayoutRect.LayoutRect( myRect,

   828             AknLayoutScalable_Apps::main_viewer_pane( 0 ) ); // Normal Screen

   829         aRect = lNormalLayoutRect.Rect();

   830         }

   831         else

   832             {

   833             aRect = myRect;

   834             }

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // CSVGTCustControl::IsLoopAllowed

   839 // Indicates whether the Loop feature is allowed for the Control.

   840 // -----------------------------------------------------------------------------

   841 //

   842 TBool CSVGTCustControl::IsLoopAllowed()  const

   843     {

   844     return ( IsContentFinite() );

   845     }

   846 

   847 // -----------------------------------------------------------------------------

   848 // CSVGTCustControl::IsAnimationPresent

   849 //  Finds whether the content has any animations

   850 // @return TBool -  ETrue indicates content contains animations,

   851 //                  EFalse otherwise

   852 // -----------------------------------------------------------------------------

   853 //

   854 TBool  CSVGTCustControl::IsAnimationPresent() const

   855     {

   856     return ( iAnimationStatus != ESvgNoAnimationsPresent );

   857     }

   858 

   859 // -----------------------------------------------------------------------------

   860 // CSVGTCustControl::IsContentFinite

   861 //  Finds whether the content is of finite duration.

   862 // @return TBool -  ETrue indicates Finite Duration,

   863 //                  EFalse otherwise

   864 // -----------------------------------------------------------------------------

   865 //

   866 TBool  CSVGTCustControl::IsContentFinite() const

   867     {

   868     // Does it not have any infinite repeat count

   869     // animations

   870     if ( ( iDuration != 0 ) &&

   871         ( iDuration != KSccIndefiniteDur ) )

   872         {

   873         return ETrue;

   874         }

   875     // Content contains atlease one infinite animation

   876     return EFalse;

   877     }

   878 

   879 // -----------------------------------------------------------------------------

   880 // CSVGTCustControl::IsProcessDone

   881 // Returns ETrue if loading is done.

   882 // -----------------------------------------------------------------------------

   883 //

   884 TBool CSVGTCustControl::IsProcessDone() const

   885     {

   886     return iIsLoadingDone;

   887     }

   888    

   889 // -----------------------------------------------------------------------------

   890 // CSVGTCustControl::SetCurrentFullScreenStatus

   891 // Set function for current viewing mode.

   892 // -----------------------------------------------------------------------------

   893 //

   894 void CSVGTCustControl::SetCurrentFullScreenStatus(

   895     TBool aIsFullScreenOn )  //  Full Screen( ETrue )/Normal( EFalse )

   896     {

   897     iIsFullScreenOn = aIsFullScreenOn;

   898     }   

   899 // -----------------------------------------------------------------------------

   900 // CSVGTCustControl::HandleApplicationForegroundEvent

   901 // Does the handling of foreground event occurring.

   902 // -----------------------------------------------------------------------------

   903 //

   904 void CSVGTCustControl::HandleApplicationForegroundEvent( TBool aForeground )

   905     { 

   906     iIsForeground = aForeground;

   907     if ( !aForeground )

   908         {

   909         // Application going into background, pause presentation.

   910         // We need to check first if there are any

   911         // animations at all in this presentation and pause

   912         // makes sense or not.

   913         if ( IsAnimationPresent() && iAnimState == ESvgAnimPlayingState )

   914             {

   915             TRAPD(errProcessViewerCmd,

   916                 ProcessViewerCommandL( ESvgtDlgPauseCommand ));

   917            

   918             if ( errProcessViewerCmd != KErrNone )

   919                 {

   920                 // Error occurred , Stop Processing

   921                 return;

   922                 }

   923                

   924             if ( iBlinker->IsActive() )               

   925                 {

   926                 iBlinker->Cancel();

   927                 iPauseIconVisible = ETrue;

   928                 }

   929             }

   930         }

   931     else

   932         {

   933         // Application coming into foreground.

   934         // May need to start a flashing pause indicator so

   935         // that user would come to know presentation is paused.

   936         if ( IsAnimationPresent() && iAnimState == ESvgAnimPausedState )

   937             {

   938             if ( iPauseIconVisible )

   939                 {

   940                 ShowPauseIcon( ETrue );

   941                 }

   942             }

   943         // Perform a redraw to avoid corrupted bitmap

   944         iSvgModule->Redraw();

   945         }

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // CSVGTCustControl::IsTextSelectOn

   950 // Indicates whether the "Select Text" menu item be displayed.

   951 // -----------------------------------------------------------------------------

   952 //

   953 TBool CSVGTCustControl::IsTextSelectOn() const

   954     {

   955     return ( iIsTextSelectOn );

   956     }

   957 

   958 // -----------------------------------------------------------------------------

   959 // CSVGTCustControl::IsTextEditOn

   960 // Indicates whether the "Edit Text" menu item be displayed.

   961 // -----------------------------------------------------------------------------

   962 //

   963 TBool CSVGTCustControl::IsTextEditOn() const

   964     {

   965     return ( iIsTextEditOn );

   966     }

   967 

   968 // -----------------------------------------------------------------------------

   969 // CSVGTCustControl::IsTextContentChanged

   970 // Indicates whether the text in the content was modified.

   971 // -----------------------------------------------------------------------------

   972 //

   973 TBool CSVGTCustControl::IsTextContentChanged() const

   974     {

   975     return ( iIsTextChanged );

   976     }

   977 

   978 // -----------------------------------------------------------------------------

   979 // CSVGTCustControl::SaveComplete

   980 // Used to perform any cleanup once save is complete.

   981 // -----------------------------------------------------------------------------

   982 //

   983 void CSVGTCustControl::SaveComplete( const TInt aError )

   984     {

   985     if ( !aError )

   986         {

   987         iIsTextChanged = EFalse;

   988        

   989         //Upadate the MSK label once saving is done

   990         if(iMSKImpl && !iPreviewMode)

   991         	{

   992         	TRAP_IGNORE(SetMSKLabelL());	

   993         	}

   994        

   995         }

   996     }

   997    

   998 // -----------------------------------------------------------------------------

   999 // CSVGTCustControl::UpdateScreen

  1000 // Implements MSvgRequestObserver::UpdateScreen.

  1001 // -----------------------------------------------------------------------------

  1002 //

  1003 void CSVGTCustControl::UpdateScreen()

  1004     {

  1005     if ( IsContentFinite() )

  1006         {

  1007         ResetBacklightTime();    

  1008         }

  1009     if ( iSVGTBitMapMask )

  1010         {

  1011         // Generate the mask for the bitmap

  1012         iSvgModule->GenerateMask( iSVGTBitMapMask );

  1013         }

  1014 	iSvgModule->IsPanPossibleFourWay(iPanLt,iPanRt,iPanUp,iPanDn);

  1015        

  1016     // Find the new position of bounding boxes if

  1017     // Find Text was performed

  1018     if ( iIsSearchStrValid )

  1019         {

  1020         CalcFindTextBBox();

  1021         }

  1022     if ( iIsLoadingDone )

  1023         {

  1024         DrawNow();

  1025         }   

  1026     }

  1027 

  1028 // -----------------------------------------------------------------------------

  1029 // CSVGTCustControl::ScriptCall

  1030 // Implements MSvgRequestObserver::ScriptCall.

  1031 // -----------------------------------------------------------------------------

  1032 //

  1033 TBool CSVGTCustControl::ScriptCall( const TDesC& /*aScript*/,

  1034                                   CSvgElementImpl* /*aCallerElement*/ )

  1035     {

  1036     return EFalse;

  1037     }

  1038 

  1039 

  1040 // -----------------------------------------------------------------------------

  1041 // CSVGTCustControl::FetchImage

  1042 // Implements MSvgRequestObserver::FetchImage. It executes asynchronously.

  1043 // To fetch the image each time the KErrGeneral should be return.

  1044 // -----------------------------------------------------------------------------

  1045 //   

  1046 TInt  CSVGTCustControl::FetchImage( const TDesC& aUri,

  1047              RFs& aSession, RFile& aFileHandle )

  1048     {

  1049 

  1050     TInt ret = 0;

  1051 

  1052     iImageFileType = ImageFileType(aUri);

  1053     if ( iAppObserver )

  1054         {

  1055         ret = iAppObserver->FetchImage( aUri, aSession, aFileHandle ) ;

  1056         }

  1057     else

  1058         {

  1059         return KErrNotFound;

  1060         }

  1061 

  1062     if ( !iFetchImageError )

  1063         {

  1064         iFetchImageError = ret;

  1065         }

  1066 

  1067     if(iImageFileType == ELocalImageFile)

  1068         {

  1069         return ret;

  1070         }

  1071     else

  1072         {

  1073         return KErrGeneral;

  1074         }

  1075     }

  1076 

  1077 TInt CSVGTCustControl::FetchFont( const TDesC& aUri ,

  1078                                     RFs& aSession , RFile& aFileHandle )

  1079     {

  1080     _LIT(KPath, "C:\\data\\images\\");

  1081     TBuf<KMaxPath> fileName;

  1082     fileName.Copy(KPath);

  1083     fileName.Append(aUri);

  1084     return aFileHandle.Open( aSession, fileName, EFileShareReadersOnly);

  1085     }

  1086 	  

  1087 // -----------------------------------------------------------------------------

  1088 // CSVGTCustControl:: GetSmilFitValue

  1089 // Implements the MSvgRequestObserver::GetSmilFitValue.

  1090 // -----------------------------------------------------------------------------

  1091 //

  1092 void CSVGTCustControl::GetSmilFitValue( TDes& aSmilValue )

  1093     {

  1094     aSmilValue.Copy( KSccSmilFitValue );

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // CSVGTCustControl::UpdatePresentation

  1099 // Implements MSvgRequestObserver::UpdatePresentation.

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 void  CSVGTCustControl::UpdatePresentation( const TInt32&  aNoOfAnimation )

  1103     {

  1104     if ( iTotalNumerOfAnimation == KSccConstMinusOne )

  1105         {

  1106         if ( aNoOfAnimation == KSccConstZero )

  1107             {

  1108             iAnimationStatus = ESvgNoAnimationsPresent;

  1109             return;

  1110             }

  1111         else

  1112             {

  1113             // First time Update Presentation is called

  1114             // and animations are present.

  1115             iTotalNumerOfAnimation = aNoOfAnimation;

  1116             }

  1117         }

  1118     else

  1119         {

  1120         iTotalNumerOfAnimation -= aNoOfAnimation;

  1121         }

  1122 

  1123     if ( iTotalNumerOfAnimation == KSccConstZero )

  1124         {

  1125         iAnimationStatus = ESvgAllAnimationsComplete;

  1126         return;

  1127         }

  1128 

  1129     iAnimationStatus =  ESvgAnimationsNotComplete;

  1130     }

  1131 

  1132 // -----------------------------------------------------------------------------

  1133 // CSVGTCustControl::OfferKeyEventL

  1134 // Handles Key events by reimplementing CCoeControl::OfferKeyEventL.

  1135 // Returns: