diff -r e52958d06c29 -r 5fd161fa28b6 svgtviewer/SvgtViewerPlugin/UIControlSrc/SVGTCustControl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/svgtviewer/SvgtViewerPlugin/UIControlSrc/SVGTCustControl.cpp Thu Sep 09 11:17:40 2010 +0300 @@ -0,0 +1,4850 @@ +/* +* Copyright (c) 2004,2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: This file implements the SVGT Custom Control which +* is used to display SVGT content +* +*/ + + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include //CEikonEnv +#include +#include +#include // for call handling +#include +#include +#include +#include +// User Includes +#include "SVGTUIControlDbgFlags.hrh" +#include "SVGTAppObserver.h" +#include "SVGTCustControl.h" +#include "SVGTUIDialog.hrh" + +#include "SvgtController.h" +#include "SvgtApplicationExitObserver.h" +#include "SvgtEventHandlerAO.h" +#include "SvgtEvent.h" +#include +#include +#include +#include + +#ifdef RD_SVGT_AUDIO_SUPPORT +#include +#include //for CRemConInterfaceSelector +#include //for CRemConCoreApiTarget + +#endif //RD_SVGT_AUDIO_SUPPORT +// Constants + +// Panning Constants +// KSccPanNumPixelsX - Amount of Pixels to Pan in X Direction when Pan is +// performed once. +// KSccPanNumPixelsY - Amount of Pixels to Pan in Y Direction when Pan is +// performed once. +const TInt KSccPanNumPixelsX = 30; +const TInt KSccPanNumPixelsY = 30; + +// Pointer Constants +// When pointer is moved in a particular direction, the movement also +// acceleration. The below constants define the delta for the acceleration. +// KSccCursorMinDeltaX - For X Direciton +// KSccCursorMinDeltaY - For Y Direciton +const TInt KSccCursorMinDeltaX = 5; +const TInt KSccCursorMinDeltaY = 5; + +// Zoom Constants +// KSccZoomInFactor - Indicates zoom factor to use while zooming in. +// This Value should be > 1.0 +// KSccZoomOutFactor - Indicates zoom factor to use while zooming out. +// This value should be > 0 and < 1.0 +const TReal32 KSccZoomInFactor = 2.0; // 2X Zoom In +const TReal32 KSccZoomOutFactor = 0.5;// 2X Zoom Out + +// Key Constants +const TInt KSccZoomInKey = ENumberKey5;//'5'; +const TInt KSccZoomOutKey =ENumberKey0; //'0'; + +// Number of milli seconds per second +const TUint32 KSccNumMSecPerSec = 1000; + + + +// Time in microsecs after which Pointer Inactivity should be declared +const TUint KSccPointerHideTimerStartAfter = 15000000; + +// Time in microsecs per second +const TInt KSccOneSecond = 1000000; + +// General Constants +const TInt KSccConstMinusOne = -1; +const TInt KSccConstZero = 0; +const TInt KSccConstOne = 1; +const TInt KSccConstTwo = 2; + +// set the name of the multi-bitmap file containing the bitmaps +_LIT( KSccIconFile,"Z:SVGTUIControl.mif" ); + +// SMIL Fit Value +_LIT( KSccSmilFitValue,"meet" ); + +// Font Ids for use with Engine-Init +const TInt KApacFontId = EApacPlain16; +const TInt KLatintFontId = ELatinBold12; + +// Duration const returned by engine when indefinite animations are present +const TUint KSccIndefiniteDur = 0xffffffff; + + +// Interval between two consecutive timer ticks in microseconds. +const TUint32 KSccProgIndTimerYieldDur = 100000; + +//constant for converting radians to degrees +const TReal32 KDegreesToRadiansFactor = 0.01745329252; + +// Maximum length of text in a text element +const TInt KSccMaxTextLength = 250; +const TInt KBackLightTimeInterval = 9; +const TInt KMaxEditorTextLength = 5120; +const TInt KEmbededImageTagLength = 5; +const TInt KSchemaLength = 4; + +#ifdef RD_SCALABLE_UI_V2 +const TInt KInitRepeatInterval = 10000; +#endif // RD_SCALABLE_UI_V2 + +// Background colour which is used by engine before rendering as a base colour +const TUint32 KSccArgbWhite = 0xffffffff; + +//TOUCH +#ifdef RD_SVGT_AUDIO_SUPPORT +const TInt KDefaultVolumeLevel = 3; +const TInt KMinVolume = 0; +const TInt KMaxVolume = 10; +#endif // RD_SVGT_AUDIO_SUPPORT +//TOUCH +#ifdef _DEBUG +// Backlight Strings +_LIT( KSccBacklightOnStr, "Backlight On" ); +_LIT( KSccBacklightOffStr, "Backlight Off" ); +#endif + +//Loading thread name +_LIT(KSvgThread,"SvgThread"); + +_LIT(KJpg, ".jpg" ); +_LIT(KJpeg, ".jpeg" ); +_LIT(KPng, ".png" ); +_LIT(KBmp, ".bmp" ); +_LIT(KSvg, ".svg" ); +_LIT(KSvgz, ".svgz" ); + +_LIT( KWww, "www" ); +_LIT( KHttp, "http://"); +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CSVGTCustControl +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +CSVGTCustControl::CSVGTCustControl( + RFile& aFileHandle, // File Handle of SVGT content + TBool aProgressiveRendering, + TInt aFlag ) : + // Animation State + iTotalNumerOfAnimation( KSccConstMinusOne ), + iAnimationStatus( ESvgNoAnimationsPresent ), + iAnimState( ESvgAnimStoppedState ), + iContentFileHandle( aFileHandle ), + // SVG Engine + iIsLoadingDone( EFalse ), + iFetchImageError( 0 ), + // Control State Variables + iZoomLevel( 0 ), + iIsLoopOn( EFalse ), + iIsFullScreenOn( EFalse ), + // Pointer Variables + iPointerDx( 0 ), + iPointerDy( 0 ), + iPointerX( 0 ), + iPointerY( 0 ), + // Current Match is invalid + iIsSearchStrValid( EFalse ), + iCurSearchMatchId( 0 ), + iNumAnimInProgress( 0 ), + iIsPointerDisplayed( ETrue ), + iFindTextHiColor( KRgbBlack ), + iIgnorePointerKeyEvent( EFalse ), + iPointerType( ESvgPointerDefault ), + iEnableTextOps( ETrue ), + iIsTextEditOn( EFalse ), + iIsTextSelectOn(EFalse), + iProgressiveRendering(aProgressiveRendering), + iDisplayFlags( aFlag ), + iEventHandlerAO(NULL), + iThreadController(NULL), + iIsWaitNoteDisplayed(EFalse), +#ifdef RD_SVGT_AUDIO_SUPPORT + iVolumeLevel(KDefaultVolumeLevel), + iPrevVolume(KDefaultVolumeLevel), +#endif //RD_SVGT_AUDIO_SUPPORT + iIsTextChanged( EFalse ), + iViewerCommand(EFalse), + iPlayMSKLabel(EFalse), + iContextMenuActivated(EFalse), + iAElement(EFalse), + iScrollKey(EFalse), + iPointerDownAnimation(EFalse), + iInteractiveElementEnteredCnt(0), + iDownKeyOccurred(EFalse), + iIsVolumeMuted(EFalse), + iIsForeground(ETrue) + { + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ConstructL +// Symbian 2nd phase constructor. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ConstructL( + MSvgtAppObserver* aAppObs, // User Implementation of Mixin + MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering + // progress indicator + MSVGTMSKImpl* aMSKImpl, //Interface for MSK labelling + MSvgtApplicationExitObserver* aExitObserver, + const CCoeControl* aParent ) + { + iEngineInitialized = EFalse; + // Save the user parameters for later access. + iAppObserver = aAppObs; + iProgressBarDrawImpl = aPBDrawImpl; + iMSKImpl=aMSKImpl; + iExitObserver = aExitObserver; + + TRect lRect; + GetNormalScreenLayoutRect( lRect ); + // Frame buffers creation + CreateBitmapsL( lRect.Size() ); + + // Icons(Pointer, Pan Ind) creation + CreateIconsL(); + +#ifdef RD_SVGT_AUDIO_SUPPORT + iVolumePopup = CAknVolumePopup::NewL(NULL, ETrue); + iVolumePopup->SetObserver(this); + _LIT( KVolumePopupTitle, "Presentation volume"); + iVolumePopup->SetTitleTextL(KVolumePopupTitle); + iVolumePopup->SetRange( KMinVolume, KMaxVolume); + iVolumePopup->SetValue( KDefaultVolumeLevel ); + + + // Open a connection to receive Volume Key events. + iSelector = CRemConInterfaceSelector::NewL(); + iInterfaceSelector = CRemConCoreApiTarget::NewL(*iSelector,*this); + TRAPD(err, iSelector->OpenTargetL()); + if(err != KErrNone) + { + #ifdef _DEBUG + RDebug::Printf("Leave occured in OpenTargetL. Error code returned %d",err); + #endif + } + +#endif //RD_SVGT_AUDIO_SUPPORT + + // DrmHelper to display save related query + iSvgDrmHelper = CSVGTDrmHelper::NewL(); + + // Check if it is a preview file + iPreviewMode = iSvgDrmHelper->IsPreviewL( iContentFileHandle ); + + // Initialise the SVG engine. + InitializeEngineL(); + + +//############################################################ + // Create the timer for Pointer Inactivity + if ( iDisplayFlags & ESvgDrawPointer ) + { + iInactivityTimer = CSVGTPointerHideTimer::NewL( this ); + iInactivityTimer->After( KSccPointerHideTimerStartAfter ); + } + + // Create the timer for blinking Pause + if ( iDisplayFlags & ESvgDrawPauseIndicator ) + { + + iBlinker = CPeriodic::NewL( CTimer::EPriorityStandard ); + } + + // Create the timer for removal of info note + if ( iDisplayFlags & ESvgDisplayErrorNotes) + { + // Create the timer for removal of info note + iNoteRemoverTimer = CPeriodic::NewL( CTimer::EPriorityHigh ); + } + + if ( iDisplayFlags & ESvgDisplayErrorNotes ) + { + // Create instance of DRM Helper for checking rights for content + iSvgDrmHelper->CheckRightsAmountL( iContentFileHandle ); + } + + //Initialize the backlight time to current time + iPreviousBackLightTimeStamp.HomeTime(); + if(iProgressiveRendering) + { + iEventHandlerAO = CSvgtEventHandlerAO::NewL( aAppObs, this, +RThread().Id()); + + iThreadController = CSvgtThreadController::NewL(this); + //Separate thread is created to load the content + // set up parameters to thread generate thread, leave if fails + TInt result = iMainThread.Create( KSvgThread, + ( TThreadFunction )LoadSvgContent, + KDefaultStackSize, + NULL, this, EOwnerProcess ); + User::LeaveIfError( result ); + // log on to thread & requests notification of thread completion + iThreadController->IssueThreadMonitorRequest( iMainThread ); + + // give thread low priority + iMainThread.SetPriority( EPriorityMuchLess ); + // resume thread (wake it up sometime after this function returns) + iMainThread.Resume(); + } + else + { + // Start displaying wait note + LaunchWaitNoteL( R_QTN_SVGT_WAITING_OPENING ); + + // Load the SVGT content + LoadContentL( iContentFileHandle ); + + // Dismiss the wait note + DismissWaitNote(); + + TInt lLoadErr = DoHandleLoadingThreadError(); + if ( lLoadErr != KErrNone ) + { + if ( lLoadErr != KErrNoMemory ) + { + // All errors other than memory failure related are + // ignored. + lLoadErr = KErrNone; + } + User::Leave( lLoadErr ); + } + + // Do the post load functionality + DoPostLoadFuncL(); + } + if ( aParent && (iDisplayFlags & ESvgWindowOwning )) + { + CreateWindowL( aParent ); + } +//############################################################ + // Set the windows size + SetRect( lRect ); + + // Activate the window, which makes it ready to be drawn + ActivateL(); + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::NewL +// Factory function for creating CSVGTCustControl objects. +// Returns: CSVGTCustControl* ; Pointer to the created object. +// Leaves if error occurs during creation. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSVGTCustControl* CSVGTCustControl::NewL( + RFile& aFileHandle, // File Handle for the content + MSvgtAppObserver* aAppObs, // User Implementation of Mixin + MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering + // progress indicator + MSVGTMSKImpl* aMSKImpl, //Interface for MSK labelling + MSvgtApplicationExitObserver* aExitObserver, + TBool aProgressiveRendering, + const CCoeControl* aParent, + TInt aDisplayFlag ) + { + CSVGTCustControl* self = CSVGTCustControl::NewLC( aFileHandle, + aAppObs, + aPBDrawImpl, + aMSKImpl, + aExitObserver, + aProgressiveRendering, + aParent, + aDisplayFlag ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::NewLC +// Factory function for creating CSVGTCustControl objects. +// Returns: CSVGTCustControl* ; Pointer to the created object. +// Leaves if error occurs during creation. +// ----------------------------------------------------------------------------- +// +CSVGTCustControl* CSVGTCustControl::NewLC( + RFile& aFileHandle, // File handle for the content + MSvgtAppObserver* aAppObs , // User Implementation of Mixin + MSVGTProgressBarDrawImpl* aPBDrawImpl , // Implementation for rendering + // progress indicator + MSVGTMSKImpl* aMSKImpl, //Interface for MSK labelling + MSvgtApplicationExitObserver* aExitObserver, + TBool aProgressiveRendering, + const CCoeControl* aParent, + TInt aDisplayFlag ) + { + CSVGTCustControl* self = new ( ELeave ) CSVGTCustControl( aFileHandle, + +aProgressiveRendering, + aDisplayFlag ); + CleanupStack::PushL( self ); + self->ConstructL( aAppObs, aPBDrawImpl ,aMSKImpl, aExitObserver, aParent ); + return self; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::~CSVGTCustControl +// Destructor +// ----------------------------------------------------------------------------- +// +CSVGTCustControl::~CSVGTCustControl() + { + +#ifdef RD_SVGT_AUDIO_SUPPORT + // if non volume key is pressed
+ if(iVolumePopup) + { + iVolumePopup->CloseVolumePopup(); + delete iVolumePopup; + iVolumePopup=NULL; + } + if(iSelector) + { + delete iSelector; + iInterfaceSelector=NULL; + iSelector=NULL; //iSelector has been deleted by "delete iInterfaceSelector" + } + +#endif //RD_SVGT_AUDIO_SUPPORT + + if(iProgressiveRendering) + { + TInt count = 0; + if(iSvgModule) + { + if ( iSvgModule->IsLoading() ) + { + iSvgModule->CancelLoad(); + do + { + User::After( 10 * 1000 ); // milliseconds + }while ( iSvgModule->IsLoading() && count++ < 100 ); + } + } + + if(iThreadController) + { + iThreadController->StopThreadExecution(iMainThread); + } + + iMainThread.Kill(KErrNone); + iMainThread.Close(); + + delete iEventHandlerAO; + + delete iThreadController; + } + + // Hyperlink Handler + if ( iSvgModule ) + { + iSvgModule->RemoveHyperlinkListener( + static_cast< MSvgHyperlinkListener*> ( this ) ); + iSvgModule->RemoveListener( static_cast(this), + ESvgLoadingListener); + iSvgModule->RemoveListener( static_cast(this), + ESvgHyperlinkListener); + iSvgModule->RemoveListener( static_cast(this), ESvgInteractiveElementListener); + } + + // SVG Engine + delete iSvgModule; + + // Free the icons + FreeIcons(); + + // Screen Bitmaps + Masks + delete iSVGTBitMap; + delete iSVGTBitMapMask; + + // delete SVG drmHelper + delete iSvgDrmHelper; + + + // Delete the arrays + iBoundBoxArray.Close(); + iFoundTextArray.Close(); + iTextElemIdArray.Close(); + + // Reset App Observer + iAppObserver = NULL; + + // Reset Progress Bar Draw Implementation Callback + iProgressBarDrawImpl = NULL; + // Current Match is invalid + iIsSearchStrValid = EFalse; + iCurSearchMatchId = KSccConstZero; + + // Backlight Timer + + // Progress Indicator Timer + delete iProgressBarTimer; + + // Pointer Inactivity Hide Timer + delete iInactivityTimer; + + // Pause Blink Timer + delete iBlinker; + + // Framebuffer Bitmap + delete iSVGTFrameBufBitMap; + + // Framebuffer Bitmap Context + delete iSVGTFrameBufContext; + + // Framebuffer Bitmap Device + delete iSVGTFrameBufDevice; + + // Delete the wait dialog + delete iWaitDialog; + + // Delete the info note + delete iInfoNote; + + // Delete the info note remover timer + delete iNoteRemoverTimer; + + // Close the System RProperty + iSystemState.Close(); + + // Reset the loading thread error + iLoadingThreadError = NULL; + + // Reset the exit observer + iExitObserver = NULL; + + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessViewerCommandL +// Process commands for handling SVGT content +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessViewerCommandL( TInt aCommandId ) // Command ID + // be processed + { + //Set the flag to indicate that the selection key is for options selection + iViewerCommand=ETrue; + switch( aCommandId ) + { + case ESvgtDlgSaveCommand: + break; + case ESvgtDlgZoomInCommand: + // Perform Zoom operation + iSvgModule->Zoom( KSccZoomInFactor ); + // Do a Redraw + iSvgModule->Redraw(); + //dummy mouse move + iSvgModule->MouseMove( iPointerX, iPointerY ); + iZoomLevel++; + UpdatePointer(); + break; + case ESvgtDlgZoomOutCommand: + if ( iZoomLevel > KSccConstZero ) + { + iZoomLevel--; + // Perform Zoom operation + iSvgModule->Zoom( KSccZoomOutFactor ); + // Do a Redraw + iSvgModule->Redraw(); + //dummy mouse move + iSvgModule->MouseMove( iPointerX, iPointerY ); + UpdatePointer(); + } + break; + case ESvgtDlgZoomOptimalCommand: + if ( iZoomLevel != KSccConstZero ) + { + //This is to nullify only the zooming effect + //Other transformations(panning, rotation) won't be restored + TReal reducedFactor = 0.0; + Math::Pow(reducedFactor, KSccZoomOutFactor, iZoomLevel); + iZoomLevel = KSccConstZero; + iSvgModule->Zoom(reducedFactor); + iSvgModule->Redraw(); + } + break; + case ESvgtDlgSelectTextCommand: + { + if ( iEnableTextOps ) + { + HBufC* lStrPtr = HBufC::NewLC( KMaxEditorTextLength ); + TPtr lPtr = lStrPtr->Des(); + + if ( iCurrentTextElementId ) + { + if ( iIsCurrentTextElement ) + { + iSvgModule->GetTextForTextElement( + iCurrentTextElementId, + iIsTextEditOn, + lPtr ); + } + else + { + iSvgModule->GetTextForTextAreaElement( + iCurrentTextElementId, + iIsTextEditOn, + lPtr ); + } + + DoTextSelectionL( lPtr ); + } + CleanupStack::PopAndDestroy( lStrPtr ); + } + } + break; + case ESvgtDlgEditTextCommand: + { + if ( iEnableTextOps ) + { + if ( iCurrentTextElementId ) + { + HBufC* lStrPtr = HBufC::NewLC( KMaxEditorTextLength ); + TPtr lPtr = lStrPtr->Des(); + + if ( iIsCurrentTextElement ) + { + iSvgModule->GetTextForTextElement( + iCurrentTextElementId, + iIsTextEditOn, + lPtr ); + } + else + { + iSvgModule->GetTextForTextAreaElement( + iCurrentTextElementId, + iIsTextEditOn, + lPtr ); + } + + + DoTextEditingL( iIsCurrentTextElement, + iCurrentTextElementId, + lPtr ); + CleanupStack::PopAndDestroy( lStrPtr ); + } + } + } + break; + case ESvgtDlgPlayCommand: + ProcessPlayCmd(); + break; + case ESvgtDlgPauseCommand: + ProcessPauseCmd(); + break; + case ESvgtDlgStopCommand: + ProcessStopCmd(); + break; +//TOUCH SUPPORT START +#ifdef RD_SVGT_AUDIO_SUPPORT + case ESvgtDlgSetVolumeCommand: + { + // The volume popup will close itself after 1s + // unless another call to ShowVolumePopupL() is made + if(iIsVolumeMuted) + { + // Set the volume of pop to zero if muted. + iVolumePopup->SetValue( 0 ); + iVolumePopup->ShowVolumePopupL(); + } + else + { + // If not muted, then show the previous volume + iVolumePopup->SetValue( iPrevVolume ); + iVolumePopup->ShowVolumePopupL(); + } + break; + } +#endif //RD_SVGT_AUDIO_SUPPORT +//TOUCH SUPPORT END + case ESvgtDlgLoopOnCommand: + if ( IsContentFinite() ) + { + iIsLoopOn = ETrue; + } + break; + case ESvgtDlgLoopOffCommand: + if ( IsContentFinite() ) + { + iIsLoopOn = EFalse; + } + break; + case ESvgtDlgFindTextCommand: + ProcessFindTextCmdL(); + break; + case ESvgtDlgFullScreenCommand: // Fall Through + case ESvgtDlgNormalScreenCommand: + // No processing here. The Command is processed by the dialog. + // Dialog sets the size of the control, because of which + // SizeChanged() of control is called. This queries the + // layout rectangles and recreates the framebuffer. + break; + case ESvgtDlgViewDetailsCommand: + { + CSvgtFileViewDetailsDialog* fileDetailsDialog = + CSvgtFileViewDetailsDialog::NewL(); + fileDetailsDialog->ExecuteLD( iContentFileHandle ); + + break; + } + case ESvgtDlgAngle90: + { + DoRotation( ERotationAngle90 ); + } + break; + case ESvgtDlgAngle180: + { + DoRotation( ERotationAngle180 ); + } + break; + case ESvgtDlgAngle270: + { + DoRotation( ERotationAngle270 ); + } + break; + case ESvgtDlgHelpCommand: + break; + default: + break; + } + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } +} +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetCurrentZoomLevel +// Get function for current zoom level. Zoom level is the number of times the +// user has zoomed in. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetCurrentZoomLevel( + TInt& aZoomLevel ) const // Current Zoom Level + { + aZoomLevel = iZoomLevel; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetCurrentAnimState +// Get function for current animation state +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetCurrentAnimState( + TSvgtViewerAnimStatus& aAnimState ) const // Playing/Paused/Stopped + { + aAnimState = iAnimState; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetCurrentFullScreenStatus +// Get function for current viewing mode. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetCurrentFullScreenStatus( + TBool& aIsFullScreenOn ) const // Full Screen( ETrue )/Normal( EFalse ) + { + aIsFullScreenOn = iIsFullScreenOn; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetCurrentLoopStatus +// Get function for current loop mode. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetCurrentLoopStatus( + TBool& aIsLoopOn ) const // Loop On( ETrue )/Loop Off( EFalse ) + { + aIsLoopOn = iIsLoopOn; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetNormalScreenLayoutRect +// Gets the normal screen layout rectangle for control from LAF. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetNormalScreenLayoutRect( + TRect& aRect ) const // Rectangle specifying extent of control + { + // Get parent client rect. + TRect myRect = iEikonEnv->EikAppUi()->ClientRect(); + + if ( AknLayoutUtils::ScalableLayoutInterfaceAvailable() ) + { + TAknLayoutRect lNormalLayoutRect; + lNormalLayoutRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane( 0 ) ); // Normal Screen + aRect = lNormalLayoutRect.Rect(); + } + else + { + aRect = myRect; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsLoopAllowed +// Indicates whether the Loop feature is allowed for the Control. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsLoopAllowed() const + { + return ( IsContentFinite() ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsAnimationPresent +// Finds whether the content has any animations +// @return TBool - ETrue indicates content contains animations, +// EFalse otherwise +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsAnimationPresent() const + { + return ( iAnimationStatus != ESvgNoAnimationsPresent ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsContentFinite +// Finds whether the content is of finite duration. +// @return TBool - ETrue indicates Finite Duration, +// EFalse otherwise +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsContentFinite() const + { + // Does it not have any infinite repeat count + // animations + if ( ( iDuration != 0 ) && + ( iDuration != KSccIndefiniteDur ) ) + { + return ETrue; + } + // Content contains atlease one infinite animation + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsProcessDone +// Returns ETrue if loading is done. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsProcessDone() const + { + return iIsLoadingDone; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SetCurrentFullScreenStatus +// Set function for current viewing mode. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SetCurrentFullScreenStatus( + TBool aIsFullScreenOn ) // Full Screen( ETrue )/Normal( EFalse ) + { + iIsFullScreenOn = aIsFullScreenOn; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::HandleApplicationForegroundEvent +// Does the handling of foreground event occurring. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::HandleApplicationForegroundEvent( TBool aForeground ) + { + iIsForeground = aForeground; + if ( !aForeground ) + { + // Application going into background, pause presentation. + // We need to check first if there are any + // animations at all in this presentation and pause + // makes sense or not. + if ( IsAnimationPresent() && iAnimState == ESvgAnimPlayingState ) + { + TRAPD(errProcessViewerCmd, + ProcessViewerCommandL( ESvgtDlgPauseCommand )); + + if ( errProcessViewerCmd != KErrNone ) + { + // Error occurred , Stop Processing + return; + } + + if ( iBlinker->IsActive() ) + { + iBlinker->Cancel(); + iPauseIconVisible = ETrue; + } + } + } + else + { + // Application coming into foreground. + // May need to start a flashing pause indicator so + // that user would come to know presentation is paused. + if ( IsAnimationPresent() && iAnimState == ESvgAnimPausedState ) + { + if ( iPauseIconVisible ) + { + ShowPauseIcon( ETrue ); + } + } + // Perform a redraw to avoid corrupted bitmap + iSvgModule->Redraw(); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsTextSelectOn +// Indicates whether the "Select Text" menu item be displayed. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsTextSelectOn() const + { + return ( iIsTextSelectOn ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsTextEditOn +// Indicates whether the "Edit Text" menu item be displayed. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsTextEditOn() const + { + return ( iIsTextEditOn ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsTextContentChanged +// Indicates whether the text in the content was modified. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsTextContentChanged() const + { + return ( iIsTextChanged ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SaveComplete +// Used to perform any cleanup once save is complete. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SaveComplete( const TInt aError ) + { + if ( !aError ) + { + iIsTextChanged = EFalse; + + //Upadate the MSK label once saving is done + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::UpdateScreen +// Implements MSvgRequestObserver::UpdateScreen. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::UpdateScreen() + { + if ( IsContentFinite() ) + { + ResetBacklightTime(); + } + if ( iSVGTBitMapMask ) + { + // Generate the mask for the bitmap + iSvgModule->GenerateMask( iSVGTBitMapMask ); + } + iSvgModule->IsPanPossibleFourWay(iPanLt,iPanRt,iPanUp,iPanDn); + + // Find the new position of bounding boxes if + // Find Text was performed + if ( iIsSearchStrValid ) + { + CalcFindTextBBox(); + } + if ( iIsLoadingDone ) + { + DrawNow(); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ScriptCall +// Implements MSvgRequestObserver::ScriptCall. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ScriptCall( const TDesC& /*aScript*/, + CSvgElementImpl* /*aCallerElement*/ ) + { + return EFalse; + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::FetchImage +// Implements MSvgRequestObserver::FetchImage. It executes asynchronously. +// To fetch the image each time the KErrGeneral should be return. +// ----------------------------------------------------------------------------- +// +TInt CSVGTCustControl::FetchImage( const TDesC& aUri, + RFs& aSession, RFile& aFileHandle ) + { + + TInt ret = 0; + + iImageFileType = ImageFileType(aUri); + if ( iAppObserver ) + { + ret = iAppObserver->FetchImage( aUri, aSession, aFileHandle ) ; + } + else + { + return KErrNotFound; + } + + if ( !iFetchImageError ) + { + iFetchImageError = ret; + } + + if(iImageFileType == ELocalImageFile) + { + return ret; + } + else + { + return KErrGeneral; + } + } + +TInt CSVGTCustControl::FetchFont( const TDesC& aUri , + RFs& aSession , RFile& aFileHandle ) + { + _LIT(KPath, "C:\\data\\images\\"); + TBuf fileName; + fileName.Copy(KPath); + fileName.Append(aUri); + return aFileHandle.Open( aSession, fileName, EFileShareReadersOnly); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl:: GetSmilFitValue +// Implements the MSvgRequestObserver::GetSmilFitValue. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::GetSmilFitValue( TDes& aSmilValue ) + { + aSmilValue.Copy( KSccSmilFitValue ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::UpdatePresentation +// Implements MSvgRequestObserver::UpdatePresentation. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::UpdatePresentation( const TInt32& aNoOfAnimation ) + { + if ( iTotalNumerOfAnimation == KSccConstMinusOne ) + { + if ( aNoOfAnimation == KSccConstZero ) + { + iAnimationStatus = ESvgNoAnimationsPresent; + return; + } + else + { + // First time Update Presentation is called + // and animations are present. + iTotalNumerOfAnimation = aNoOfAnimation; + } + } + else + { + iTotalNumerOfAnimation -= aNoOfAnimation; + } + + if ( iTotalNumerOfAnimation == KSccConstZero ) + { + iAnimationStatus = ESvgAllAnimationsComplete; + return; + } + + iAnimationStatus = ESvgAnimationsNotComplete; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::OfferKeyEventL +// Handles Key events by reimplementing CCoeControl::OfferKeyEventL. +// Returns: +// EKeyWasConsumed: If this control uses this key. +// EKeyWasNotConsumed: Otherwise. +// ----------------------------------------------------------------------------- +// +TKeyResponse CSVGTCustControl::OfferKeyEventL( + const TKeyEvent& aKeyEvent, // Key Event + TEventCode aType ) // Event Code + { + + TKeyResponse retVal = EKeyWasNotConsumed; + TInt keyScanCode = aKeyEvent.iScanCode; + TInt keyCode = aKeyEvent.iCode; + switch ( aType ) + { + case EEventKeyDown: + { + // reset the repeat count + iKeyRepeatCount = 0; + // Reset the select cause + iSelectCause = ESvgInvalidSelectCause; + // UI Spec: Pointer should be displayed when + // Select Key or Pointer is moved + if ( keyScanCode == EStdKeyEnter || + keyScanCode == EStdKeyDevice3 || + keyScanCode == EStdKeyUpArrow || + keyScanCode == EStdKeyDownArrow || + keyScanCode == EStdKeyLeftArrow || + keyScanCode == EStdKeyRightArrow ) + { + if ( !iInactivityTimer ) + { + // Ignore subsequent key events as the pointer should be + // displayed and no event is to be processed until key + // up event is received. + iIgnorePointerKeyEvent = ETrue; + } + if( keyScanCode != EStdKeyDevice3 && keyScanCode != EStdKeyEnter && !iIsPointerDisplayed ) + { + iScrollKey=ETrue; //needed to check when the pointer hidden + // and scroll key is pressed. + } + + + if( ( keyScanCode == EStdKeyDevice3 || keyScanCode == EStdKeyEnter )&&!iIsPointerDisplayed ) + { + // Key has been lifted, + // Reset the Pointer Delta Values + iPointerDx = KSccConstZero; + iPointerDy = KSccConstZero; + + // UI Spec: Pointer should be hidden after 15 sec of + // user inactivity + if ( iInactivityTimer ) + { + // Should not be the case! + delete iInactivityTimer; + iInactivityTimer = NULL; + } + iInactivityTimer = CSVGTPointerHideTimer::NewL( this ); + iInactivityTimer->After( KSccPointerHideTimerStartAfter ); + } + if(keyScanCode == EStdKeyDevice3 || keyScanCode == EStdKeyEnter ) + { + iDownKeyOccurred = ETrue; + iSvgModule->MouseDown( iPointerX, iPointerY ); + } + SetPointerDisplayStatusAndRedraw( ETrue ); + + retVal = EKeyWasConsumed; + } + } + break; + case EEventKeyUp: + { + if ( keyScanCode == EStdKeyEnter || + keyScanCode == EStdKeyDevice3 || + keyScanCode == EStdKeyUpArrow || + keyScanCode == EStdKeyDownArrow || + keyScanCode == EStdKeyLeftArrow || + keyScanCode == EStdKeyRightArrow ) + { + // Key has been lifted, + // Reset the Pointer Delta Values + iPointerDx = KSccConstZero; + iPointerDy = KSccConstZero; + + // UI Spec: Pointer should be hidden after 15 sec of + // user inactivity + if ( iInactivityTimer ) + { + // Should not be the case! + delete iInactivityTimer; + iInactivityTimer = NULL; + } + iInactivityTimer = CSVGTPointerHideTimer::NewL( this ); + iInactivityTimer->After( KSccPointerHideTimerStartAfter ); + + // Once the pointer is un-hidden, Ignore subsequent key events + // and no event is to be processed until key up event is received. + if ( iIgnorePointerKeyEvent ) + { + iIgnorePointerKeyEvent = EFalse; + retVal = EKeyWasConsumed; + TRAP_IGNORE(SetMSKLabelL()); + } + else + { + // Assume key will be consumed + retVal = EKeyWasConsumed; + + if( ( keyScanCode == EStdKeyDevice3 || keyScanCode == EStdKeyEnter )&& iDownKeyOccurred) + { + iSvgModule->MouseUp(iPointerX,iPointerY); + iDownKeyOccurred= EFalse; + } + } + + } + } + break; + case EEventKey: + { + retVal = EKeyWasConsumed; + iKeyRepeatCount++; + + // Once the pointer is un-hidden, Ignore subsequent joystick + // key events and no joystick event is to be processed until + // key up event is received. + switch ( keyCode /*keyScanCode*/ ) + { + case KSccZoomInKey: // Zoom In Key + { + if ( iKeyRepeatCount == 1 ) + { + ProcessViewerCommandL( ESvgtDlgZoomInCommand ); + } + + break; + } + case EKeyUpArrow: // Pointer Up + { + if ( iIgnorePointerKeyEvent == EFalse) + { + iPointerDx = KSccConstZero; + iPointerDy -= KSccCursorMinDeltaY; + } + break; + } + case EKeyDownArrow: // Pointer Down + if ( iIgnorePointerKeyEvent == EFalse) + { + iPointerDx = KSccConstZero; + iPointerDy += KSccCursorMinDeltaY; + } + break; + case EKeyLeftArrow: // Pointer Left + if ( iIgnorePointerKeyEvent == EFalse) + { + iPointerDx -= KSccCursorMinDeltaX; + iPointerDy = KSccConstZero; + } + break; + case EKeyRightArrow: // Pointer Right + if ( iIgnorePointerKeyEvent == EFalse) + { + iPointerDx += KSccCursorMinDeltaX; + iPointerDy = KSccConstZero; + } + break; + case ENumberKey1: //key 1 + DoRotation(ERotationAngle90); + break; + case ENumberKey3: //key 3 + DoRotation(-ERotationAngle90); + break; + case ENumberKey7: //key 7 + DoRotation(ERotationAngle45); + break; + case ENumberKey9: //key 9 + DoRotation(-ERotationAngle45); + break; + case KSccZoomOutKey: // Zoom out key + // Zoom out if "zoom-out" key was pressed once + { + if ( iKeyRepeatCount == 1 ) + { + ProcessViewerCommandL( ESvgtDlgZoomOutCommand ); + } + else if ( ( iZoomLevel > 0 ) && ( iKeyRepeatCount == 2 ) ) + { + ProcessViewerCommandL(ESvgtDlgZoomOptimalCommand ); + } + break; + } + default: + { + // Unknown Key + retVal = EKeyWasNotConsumed; + } + } + } + break; + default: + { + // Unknown Key + retVal = EKeyWasNotConsumed; + } + break; + } + if ( ( iPointerDx != KSccConstZero ) || + ( iPointerDy != KSccConstZero ) ) + { + UpdatePointer(); + } + return retVal; + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::HandleResourceChange +// This function is called by the framework when there is a layout switch/skin +// change +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::HandleResourceChange( TInt aType ) + { + if ( aType == KAknsMessageSkinChange ) + { + // Recreate the icons + TRAPD( err, CreateIconsL() ); + if ( err != KErrNone ) + { + // No Error Handling done here. + } + // Find Text Highlight Colour + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + // Color is not updated if it not found from the skin + AknsUtils::GetCachedColor(skin, iFindTextHiColor, + KAknsIIDQsnHighlightColors, + EAknsCIQsnHighlightColorsCG2); + SetSize(Rect().Size()); + } + + CCoeControl::HandleResourceChange( aType ); + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::LinkEntered +// Callback Function called by the engine when the pointer enters a hyperlink +// ----------------------------------------------------------------------------- +// + +TBool CSVGTCustControl::LinkEntered( const TDesC& aUri) + { + + CXmlElementImpl* ptr=NULL; + + // Get the elementID + ptr=iSvgModule->GetElementById(iSvgModule->SvgDocument(),aUri); + + // Check for "a" element or an element which has animation on + // mousedown/mouseup + if(!ptr) + { + iAElement=ETrue; + iPointerType = ESvgPointerHand; + // Sets the MSK label + if(iMSKImpl && !iPreviewMode ) + { + TRAP_IGNORE(SetMSKLabelL()); + } + } + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::LinkExited +// Callback Function called by the engine when the pointer exits a hyperlink +// ----------------------------------------------------------------------------- +// + +TBool CSVGTCustControl::LinkExited( const TDesC& /*aUri*/ ) + { + + iPointerType = ESvgPointerDefault; + + // Reset the flag for a element + iAElement=EFalse; + + //Set the MSK label + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + return ETrue; + } +// --------------------------------------------------------------------------- +// CSVGTCustControl::LinkActivated +// Callback Function called by the engine when a hyperlink is activated +// --------------------------------------------------------------------------- +// + +TBool CSVGTCustControl::LinkActivated( + const TDesC& aUri ) + { + if (iSelectCause != ESvgInvalidSelectCause ) + { + // Ignore this callback as it was already processed. + return ETrue; + } + // Set the cause for select operation as Hyperlink so that + // subsequent events trigerred are ignored. + iSelectCause = ESvgHyperLinkSelectCause; + + if( iAppObserver ) + { + if( IsThreadRunning() ) + { + CSvgtEventLinkActivated* event = new + CSvgtEventLinkActivated( aUri ); + iEventHandlerAO->AddEventToList( event ); + iEventHandlerAO->MakeRequestComplete( KErrNone ); + return ETrue; + } + else + { + return iAppObserver->LinkActivated( aUri ); + } + } + else + { + return EFalse; + } + } + +// -------------------------------------------------------------------- +// CSVGTCustControl::LinkActivatedWithShow +// Callback Function called by the engine when a hyperlink with show +// attribute is activated +// -------------------------------------------------------------------- +// +TBool CSVGTCustControl::LinkActivatedWithShow( + const TDesC& aUri , + const TDesC& aShow ) + { + if (iSelectCause != ESvgInvalidSelectCause ) + { + // Ignore this callback as it was already processed. + return ETrue; + } + // Set the cause for select operation as Hyperlink so that + // subsequent events trigerred are ignored. + iSelectCause = ESvgHyperLinkSelectCause; + if( iAppObserver ) + { + if( IsThreadRunning() ) + { + CSvgtEventLinkActivatedWithShow* event = + new CSvgtEventLinkActivatedWithShow( aUri, aShow ); + iEventHandlerAO->AddEventToList( event ); + iEventHandlerAO->MakeRequestComplete( KErrNone ); + + return ETrue; + } + else + { + return iAppObserver->LinkActivatedWithShow( aUri, aShow ); + } + } + else + { + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CreateBitmapsL +// This function is called to create the bitmaps used by the SVG engine +// for rendering. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::CreateBitmapsL( + const TSize& aBitmapSize ) // Bitmap Size used to render content + { + + if( iSVGTBitMap && (iSVGTBitMap->SizeInPixels() == aBitmapSize)) + { + return ; + } + + TDisplayMode dispMode = iEikonEnv->ScreenDevice()->DisplayMode(); + TInt errCode = KErrNone; + // Modes currently supported by SVG engine are: + // EGray2, EColor4K, EColor64K, EColor16M, EColor16MU. + switch ( dispMode ) + { + case EGray2: + case EColor16M: + { + break; + } + case EColor16MU: + { + break; + } + default: + { + dispMode = EColor64K; + break; + } + } + // Create the bitmaps using local variables and assign + // to member variable if successful + CFbsBitmap* lTempBitmap = new ( ELeave ) CFbsBitmap(); + + // Create the bitmap with size and display mode + errCode = lTempBitmap->Create( aBitmapSize, dispMode ); + if ( errCode != KErrNone ) + { + delete lTempBitmap; + User::Leave( errCode ); + } + + // Check and destroy existing bitmap + if ( iSVGTBitMap ) + { + delete iSVGTBitMap; + } + + // Assign newly created bitmap + iSVGTBitMap = lTempBitmap; + + // Create the bitmap mask + lTempBitmap = new ( ELeave ) CFbsBitmap(); + + // Create the bitmap with size and display mode + errCode = lTempBitmap->Create( aBitmapSize, EGray256 ); + if ( errCode != KErrNone ) + { + delete lTempBitmap; + User::Leave( errCode ); + } + + // Check and destroy existing bitmap + if ( iSVGTBitMapMask ) + { + delete iSVGTBitMapMask; + } + + // Assign newly created bitmap + iSVGTBitMapMask = lTempBitmap; + + // Create the Framebuffer Bitmap + lTempBitmap = new ( ELeave ) CFbsBitmap(); + + // Create the bitmap with size and display mode + errCode = lTempBitmap->Create( aBitmapSize, dispMode ); + if ( errCode != KErrNone ) + { + delete lTempBitmap; + User::Leave( errCode ); + } + + // Check and destroy existing bitmap + if ( iSVGTFrameBufBitMap ) + { + delete iSVGTFrameBufBitMap; + } + + // Assign newly created bitmap + iSVGTFrameBufBitMap = lTempBitmap; + + // Create the Bitmap Device and Contexts, used to reduce the number + // of interactions with the windows server + CFbsBitmapDevice* lTempBitmapDev = CFbsBitmapDevice::NewL( + iSVGTFrameBufBitMap ); + + CFbsBitGc* lTempBitmapCtx = NULL; + // Create framebuffer context + errCode = lTempBitmapDev->CreateContext( lTempBitmapCtx ); + if ( errCode != KErrNone ) + { + delete lTempBitmapDev; + User::Leave( errCode ); + } + + // Check and destroy existing bitmap device + if ( iSVGTFrameBufDevice ) + { + delete iSVGTFrameBufDevice; + } + + // Check and destroy existing bitmap context + if ( iSVGTFrameBufContext ) + { + delete iSVGTFrameBufContext; + } + + // Assign newly created bitmap device + iSVGTFrameBufDevice = lTempBitmapDev; + iSVGTFrameBufContext = lTempBitmapCtx; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CreateIconsL +// This function is called to create the icons used by the control. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::CreateIconsL() + { + // Skin instance + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + // Cleanup the old icons. + FreeIcons(); + + // Construct the MBM file name + TParse parse; + parse.Set( KSccIconFile, &KDC_APP_BITMAP_DIR, NULL); + TPtrC iconFile = parse.FullName(); + + //Create icon for drawing the pointer + iPointerIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPointer, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_pointer, + EMbmSvgtuicontrolQgn_indi_viewer_pointer_mask ); + + //Create icon for drawing the hyperlink pointer + iHandIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPointerHand, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_pointer_hand, + EMbmSvgtuicontrolQgn_indi_viewer_pointer_hand_mask ); + + //Create icon for drawing the hyperlink pointer + iTextIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPointerText, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_pointer_text, + EMbmSvgtuicontrolQgn_indi_viewer_pointer_text_mask ); + + // Panning Indicators + // Create icon for drawing the Pan Left + iPanIndLeftIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPanningLeft, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_panning_left, + EMbmSvgtuicontrolQgn_indi_viewer_panning_left_mask ); + + // Create icon for drawing the Pan Right + iPanIndRightIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPanningRight, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_panning_right, + EMbmSvgtuicontrolQgn_indi_viewer_panning_right_mask ); + + // Create icon for drawing the Pan Up + iPanIndUpIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPanningUp, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_panning_up, + EMbmSvgtuicontrolQgn_indi_viewer_panning_up_mask ); + + // Create icon for drawing the Pan Down + iPanIndDownIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiViewerPanningDown, + iconFile, + EMbmSvgtuicontrolQgn_indi_viewer_panning_down, + EMbmSvgtuicontrolQgn_indi_viewer_panning_down_mask ); + + // Create icon for drawing the Pause + iPauseIcon = AknsUtils::CreateGulIconL( + skin, + KAknsIIDQgnIndiCamsPaused, + iconFile, + EMbmSvgtuicontrolQgn_indi_cams_paused, + EMbmSvgtuicontrolQgn_indi_cams_paused_mask ); + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::InitializeEngineL +// Initiliazes the interface with the SVG engine. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::InitializeEngineL() + { + if ( !iSvgModule ) + { + TInt fontId = KLatintFontId; + + switch ( AknLayoutUtils::Variant() ) + { + case EApacVariant: + { + fontId = KApacFontId; + } + break; + case EEuropeanVariant: + default: + break; + } + + const CFont* font = AknLayoutUtils::FontFromId( fontId ); + TFontSpec spec = font->FontSpecInTwips(); + + iSvgModule = CSvgEngineInterfaceImpl::NewL( iSVGTBitMap, + this, spec ); + iSvgModule->SetBackgroundColor( KSccArgbWhite ); + iSvgModule->AddHyperlinkListener( static_cast < MSvgHyperlinkListener* > + (this) ); + // Register for notification of Animation Start/Stop. + iSvgModule->AddAnimationListener( static_cast < MSvgAnimationListener* > + ( this ) ); + iSvgModule->AddListener(static_cast(this), + ESvgLoadingListener); + iSvgModule->AddListener(static_cast(this), + ESvgHyperlinkListener); + iSvgModule->AddListener( static_cast < MSvgInteractiveElementListener* > + (this), ESvgInteractiveElementListener); + +#ifdef SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE + // In DRM protected contents, disable the text operations: + iEnableTextOps = !( iSvgDrmHelper->IsProtected()||iPreviewMode ); + + if ( iEnableTextOps ) + { + // Add textArea element listener + iSvgModule->AddListener( static_cast(this), + ESvgTextAreaListener ); + + // Add text element listener + iSvgModule->AddListener( static_cast(this), + ESvgTextListener ); + } +#endif // SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE + } + + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::LoadContentL +// This function uses the SVG Engine to load the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::LoadContentL( + RFile& aFileHandle ) // Filename of SVGT content + { + // Enable DRM mode of engine + iSvgModule->SetDRMMode( ETrue ); + + // Rewind the file + TInt pos = 0; + aFileHandle.Seek( ESeekStart, pos ); + + iLoadingThreadError = iSvgModule->Load( aFileHandle ); + +#ifdef SVGTUICONTROL_DBG_OPENVG_TESTING_ENABLE + iSvgModule->CustomOption( ETrue ); +#endif // SVGTUICONTROL_DBG_OPENVG_TESTING_ENABLE + } + +TInt CSVGTCustControl::LoadSvgContent(TAny* aAny) + { + CSVGTCustControl& loader = *( CSVGTCustControl* )aAny; + CTrapCleanup* theTrapCleanup = CTrapCleanup::New(); + loader.SetThreadRunning(ETrue); + TRAP_IGNORE( loader.InitSvgContentL() ); + delete theTrapCleanup; + return 0; + } + +void CSVGTCustControl::InitSvgContentL() + { + CActiveScheduler* threadScheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL( threadScheduler ); + CActiveScheduler::Install(threadScheduler); + + // Load the SVGT content + LoadContentL( iContentFileHandle ); + CleanupStack::PopAndDestroy( threadScheduler ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DisplayInfoNoteL +// This is a utility function for displaying the info notes +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DisplayInfoNoteL( TInt aResourceId, // Resource Id of + // string + TBool aIsWaitingDialog ) // Indicate whether \ + // dialog should wait + { + if(iDisplayFlags & ESvgDisplayErrorNotes ) + { + // Show information note + HBufC* prompt = iCoeEnv->AllocReadResourceLC( aResourceId ); + CAknInformationNote* note = new ( ELeave ) CAknInformationNote( + aIsWaitingDialog ); + note->ExecuteLD( *prompt ); + CleanupStack::PopAndDestroy( prompt ); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DoPostLoadFuncL +// This is a utility function for performing post-load functionality +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DoPostLoadFuncL() + { + if ( iSvgModule ) + { +#ifdef RD_SVGT_AUDIO_SUPPORT + SetPresentationVolume( iVolumeLevel ); +#endif //RD_SVGT_AUDIO_SUPPORT + + // give thread normal priority + iMainThread.SetPriority( EPriorityNormal ); + // Attach to property for call state property + User::LeaveIfError( iSystemState.Attach( KPSUidCtsyCallInformation, + KCTsyCallState ) ); + // Attach to property for call type property + User::LeaveIfError( iSystemState.Attach( KPSUidCtsyCallInformation, + KCTsyCallType ) ); + // Indicate that the content loading is complete + iIsLoadingDone = ETrue; + + // Store SVG duration + iDuration = iSvgModule->Duration(); + + // Start the rendering process + iAnimState = ESvgAnimPlayingState; + iSvgModule->Start(); + + //Drawing the MSK label for the first time + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + // Check whether the content is finite, inorder to display the + // progress timer + if ( IsContentFinite() ) + { + // Start immediately so that the first count is displayed + StartProgIndTimer( 0 ); + } + + if ( IsVoiceCallActive() ) + { + ProcessPauseCmd(); + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SaveSvgDom +// This function is a helper function to save the modified svg content +// given the file name. +// ----------------------------------------------------------------------------- +TInt CSVGTCustControl::SaveSvgDom( const TDesC& aFileName ) + { + TInt retVal = KErrNone; + MSvgError* lSvgErr = iSvgModule->SaveSvgDom( + (TInt)iSvgModule->SvgDocument(), aFileName ); + if ( ( !lSvgErr ) || ( lSvgErr->HasError() ) ) + { + if ( lSvgErr ) + { + // Attempt to find the system error code + retVal = lSvgErr->SystemErrorCode(); + } + else + { + // No free memory available + retVal = KErrNoMemory; + } + + // No error code found, indicate general error + if ( retVal == KErrNone ) + { + retVal = KErrGeneral; + } + } + return retVal; + } + // ----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- +void CSVGTCustControl::GetViewPort( TInt getWidth , + TInt getHeight , + TBool isWidthInPercentage, + TBool isHeightInPercentage, + TInt& setWidth, TInt& setHeight ) + { + if(!iSvgModule) + { + return; + } + if(!iSVGTBitMap) + { + return; + } + TSize svgSize = iSvgModule->ContentDimensionsInPercentage(); + TInt per=100; + TSize tempSize = iSvgModule->ContentDimensions(); + TInt scrW = iSVGTBitMap->SizeInPixels().iWidth; + TInt scrH = iSVGTBitMap->SizeInPixels().iHeight; + //both not in percentage + if(!isWidthInPercentage && !isHeightInPercentage) + { + setWidth = tempSize.iWidth; + setHeight = tempSize.iHeight; + } + //if width in percentage + else if(isWidthInPercentage && !isHeightInPercentage) + { + setWidth = svgSize.iWidth * scrW / per; + //if svg had valid height take it else use default + if(tempSize.iHeight) + { + setHeight = getHeight; + } + } + //if height in percentage + else if(!isWidthInPercentage && isHeightInPercentage) + { + setHeight = svgSize.iHeight * scrH / per; + if(tempSize.iWidth) + { + setWidth = getWidth; + } + } + //if both height and width are in percentage + else + { + setHeight = svgSize.iHeight * scrH / per; + setWidth = svgSize.iWidth * scrW / per; + } + + //if height is greater than screenHeight + //or if width is greater than screenwidth + //set the width and height by preserving the aspect ratio + TReal32 sx,sy; + + if(setHeight > scrH || setWidth > scrW) + { + sx = (TReal32) (scrW) / (TReal32) (setWidth); + sy = (TReal32) (scrH) / (TReal32) (setHeight); + if ( sx > sy ) + { + sx = sy; + } + else // ( sx < sy ) + { + sy = sx; + } + setWidth = sx * setWidth; + setHeight = sy * setHeight; + } + + + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DrawPointer +// This function blits the pointer bitmap on the screen at the current mouse +// co-ordinates which are maintained as data-members of CSVGTCustControl. +// ----------------------------------------------------------------------------- +// + +void CSVGTCustControl::DrawPointer() const + { + + iSVGTFrameBufContext->SetPenStyle( CGraphicsContext::ENullPen ); + iSVGTFrameBufContext->SetBrushStyle( CGraphicsContext::ENullBrush ); + + + // Use the aid for the hotspot from the LAF. + // This value is set in the SizeChanged function. + // The hotspot information is used so that the bitmap is drawn in + // correct position with respect to the mouse position. + switch ( iPointerType ) + { + case ESvgPointerHand: + { + // Draw the hand icon at the mouse position + TPoint pointerStart( iPointerX - iHandAidRect.Rect().Width(), + iPointerY - iHandAidRect.Rect().Height() ); + iSVGTFrameBufContext->BitBltMasked( pointerStart, + iHandIcon->Bitmap(), + iHandRect.Rect(), + iHandIcon->Mask(), + EFalse ); + break; + } + case ESvgPointerText: + { + // Draw the hand icon at the mouse position + TPoint pointerStart( iPointerX - iTextAidRect.Rect().Width(), + iPointerY - iTextAidRect.Rect().Height() ); + iSVGTFrameBufContext->BitBltMasked( pointerStart, + iTextIcon->Bitmap(), + iTextRect.Rect(), + iTextIcon->Mask(), + EFalse ); + break; + } + case ESvgPointerDefault: // Fall Through + default: // Fall Through - Should never be the case + { + // Draw the pointer icon at the mouse position + TPoint pointerStart( iPointerX - iPointerAidRect.Rect().Width(), + iPointerY - iPointerAidRect.Rect().Height() ); + iSVGTFrameBufContext->BitBltMasked( pointerStart, + iPointerIcon->Bitmap(), + iPointerRect.Rect(), + iPointerIcon->Mask(), + EFalse ); + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::UpdatePointer +// Called when pointer needs to be redrawn +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::UpdatePointer() + { + // Get the size of the content + TSize svgSize = iSvgModule->Size(); + TInt rgnw = svgSize.iWidth; + TInt rgnh = svgSize.iHeight; + + // This is to store whether the framebuffer changed + TBool lFrameBufChange = EFalse; + + // iPointerDx contains the delta increment in X axis + // Add it to the pointer coordinates + iPointerX += iPointerDx; + + // If pointer coordinate becomes negative then reset it + // and perform panning. + if ( iPointerX < KSccConstZero ) + { + iPointerX = KSccConstZero; + if(iPanLt) + { + iSvgModule->Pan( KSccPanNumPixelsX, KSccConstZero ); + } + lFrameBufChange = ETrue; + } + + // If pointer coordinate becomes greater than content size + // then set it back to (content width - 1) and + // perform panning. + if ( rgnw <= iPointerX ) + { + iPointerX = rgnw - KSccConstOne; + if(iPanRt) + { + iSvgModule->Pan( -KSccPanNumPixelsX, KSccConstZero ); + } + lFrameBufChange = ETrue; + } + + // iPointerDy contains the delta increment in Y axis + // Add it to the pointer coordinates. + iPointerY += iPointerDy; + + // If pointer coordinate becomes negative then reset it + // and perform panning. + if ( iPointerY < KSccConstZero ) + { + iPointerY = KSccConstZero; + if(iPanUp) + { + iSvgModule->Pan( KSccConstZero, KSccPanNumPixelsY ); + } + lFrameBufChange = ETrue; + } + + // If pointer coordinate becomes greater than content size + // then set it back to (content height - 1) and + // perform panning. + if ( iPointerY >= rgnh ) + { + iPointerY = rgnh - KSccConstOne; + if(iPanDn) + { + iSvgModule->Pan( KSccConstZero, -KSccPanNumPixelsY ); + } + lFrameBufChange = ETrue; + } + + // If Framebuffer changed, perform an engine redraw and recalculate + // bound box coordinates + if ( lFrameBufChange ) + { + iSvgModule->Redraw(); + CalcFindTextBBox(); + } + + // Indicate new mouse position to engine + iSvgModule->MouseMove( iPointerX, iPointerY ); + + // Perform a redraw to reflect new position of pointer + DrawDeferred(); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SetMSKLabel +// This function is called to set the MSK labels under various circumstances. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SetMSKLabelL() +{ + TInt lResourceID=0; + TInt lCommandID=0; + if(!iIsPointerDisplayed) + { + if (IsAnimationPresent()) + { + lResourceID=R_SVGT_MSK_LABEL_CONTEXT; + lCommandID=EAknSoftkeyContextOptions; + } + else if ( !IsAnimationPresent() && + (iAppObserver->CanShowSave() || IsTextContentChanged() ) ) + { + lResourceID=R_SVGT_MSK_LABEL_SAVE; + lCommandID=EAknSoftkeySave; + } + else + { + lResourceID=R_SVGT_MSK_LABEL_CONTEXT; + lCommandID=EAknSoftkeyOptions; + } + } + else + { + switch(iPointerType) + { + case ESvgPointerHand: + { + lCommandID=EAknSoftkeySelect; + if(iAElement) + { + lResourceID=R_SVGT_MSK_LABEL_OPEN; + } + else + { + iPlayMSKLabel=ETrue; + lResourceID=R_SVGT_MSK_LABEL_PLAY; + } + } + break; + case ESvgPointerText: + { + lCommandID=EAknSoftkeySelect; + if(IsTextEditOn()) + { + lResourceID=R_SVGT_MSK_LABEL_EDIT; + } + else + { + lResourceID=R_SVGT_MSK_LABEL_SELECT; + } + } + break; + case ESvgPointerDefault: + { + if (IsAnimationPresent()) + { + lResourceID=R_SVGT_MSK_LABEL_CONTEXT; + lCommandID=EAknSoftkeyContextOptions; + } + else if( !IsAnimationPresent() && + ( iAppObserver->CanShowSave() || IsTextContentChanged() ) ) + { + lResourceID=R_SVGT_MSK_LABEL_SAVE; + lCommandID=EAknSoftkeySave; + } + else + { + lResourceID=R_SVGT_MSK_LABEL_CONTEXT; + lCommandID=EAknSoftkeyOptions; + } + } + break; + } + } + iMSKImpl->RemoveMSKLabel(); + iMSKImpl->DrawMSKLabelL(lResourceID,lCommandID); +} + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::GetMSKLabelFlag +// This function is called to get either iPlayMSKLabel or +// iContextMenuActivated flag +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::GetMSKLabelFlag(TInt aButtonId) const +{ + if (aButtonId==EAknSoftkeyContextOptions) + { + return iContextMenuActivated; + } + else //Else the case will be for EAknSoftkeySelect for which the + // iPlayMSKLabel has to be returned + { + return iPlayMSKLabel; + } +} + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SetMSKLabelFlag +// This function is called to set/reset either iPlayMSKLabel or +// iContextMenuActivated flag +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ChangeMSKLabelFlag(TInt aButtonId) +{ + if (aButtonId==EAknSoftkeyContextOptions) + { + iContextMenuActivated = !iContextMenuActivated; + } + else //Else the case will be for EAknSoftkeySelect + { + iPlayMSKLabel=!iPlayMSKLabel; + } +} + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SwitchScreenModeL +// This function is called to change the viewing mode to Normal Screen/Full +// Screen. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SwitchScreenModeL() + { + // When control mode is being switched, following + // processing needs to happen: + // a. Save the current framebuffer + // b. Create the New Framebuffer by calling CreateBitmaps() + // c. Set the framebuffer to the new framebuffer + // d. Pause the content if it was paused. + // e. Also processing in following functions is affected: + // i. UpdateScreen - This is the callback of the engine to indicate + // that it has rendered the frame on the bitmap, and is ready to be + // drawn. Here we need to generate mask with correct bitmap + // ii. Draw - This function needs to bitblt the bitmap + // along with the mask + + if ( iSvgModule ) + { + // Create new bitmaps + CreateBitmapsL( Rect().Size() ); + iSvgModule->Pause(); + // Change the rendering bitmap to the appropriate Screen Bitmap + iSvgModule->SetFrameBuffer( iSVGTBitMap ); + + // Check if content was playing + if ( iAnimState != ESvgAnimPlayingState ) + { + // Stop it, as content is paused + iSvgModule->Pause(); + // Redraw the screen, to prevent blank screen from appearing + iSvgModule->Redraw(); + } + // Find Text Update + // Get new position of Bounding Boxes + CalcFindTextBBox(); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CalcFindTextBBox +// This function is called to recalculate the bounding boxes for the find text. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::CalcFindTextBBox() + { + + // Clear the Arrays + iBoundBoxArray.Reset(); + iFoundTextArray.Reset(); + iTextElemIdArray.Reset(); + + // If the Search String is not valid, then + // no need to do anything. + if ( !iIsSearchStrValid ) + { + return EFalse; + } + + // Invoke Engine call for searching text. + TBool retVal = iSvgModule->SearchForText( + iLastSearchText, + iBoundBoxArray, + iFoundTextArray, + iTextElemIdArray, + EFalse ); + + if ( retVal == EFalse ) + { + // Set the search string as invalid + iIsSearchStrValid = EFalse; + // Reset the string + //Himanshu iLastSearchText.Zero(); + } + + return ( retVal ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::PanToCurBBox +// This function is called to pan the content inorder that the current +// bounding box is visible. +// ----------------------------------------------------------------------------- +// + +void CSVGTCustControl::PanToCurBBox() + { + TPoint lRefPos( Rect().Center() ); + + // We need to pan in such a way that the Top Left of the Bounding box + // coincides with the current view's Center + TPoint lPanAmount( lRefPos - FPRCenter( + iBoundBoxArray[ iCurSearchMatchId ] ) ); + iSvgModule->Pan( lPanAmount.iX, lPanAmount.iY ); + // Do a Redraw + iSvgModule->Redraw(); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessFindTextCmd +// This function is called to perform the necessary processing for the find +// text command. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessFindTextCmdL() + { + // The Processing involved is + // 1. Query the text to be searched for from the User + // 2. Is the text same as the text input before? (Case Insensitive Match) + // 3. If Yes, then + // Perform "Find Next" functionality + // a. If the bounding box is not in view then + // move to the same bound box + // Else, + // Cycle through the list of bound-boxes by incrementing + // with wrap around the iCurSearchMatchId while the text + // is not visible + // else // New text entered + // Perform "Find First" Functionality + // If no Match is found then, + // Display an "Text not found" info note + // Reset the Last Searched Text + // return to caller + // Else, + // Find the List of Bound Boxes + // Set the Current Match as the Index Zero of the BBox Array + // 4. If the current bound box is not in view + // Pan to the Bound Box + // Recalculate the Bound Box Co-ordinates + // 5. Move the mouse to the center of the bound box + // 6. Return to caller. + + TBuf lText( iLastSearchText ); + // Query the text to be searched for from the User + CAknTextQueryDialog* dlg = new ( ELeave ) CAknTextQueryDialog( + iLastSearchText ); + if( dlg->ExecuteLD( R_FIND_TEXT_QUERY_DIALOG ) ) + { + // User entered text + if ( lText.CompareF( iLastSearchText ) == 0 && + iIsSearchStrValid==1 ) // Case insensitive comparison + { + // Searching for same text = Find Next + // If current bound box is not in view and is visible, then + // move to the same bound box + // else ; Bound Box is in view or is Not Visible + // find next visible box with wraparound. + TBool lIsBoxInView = FPRIntersects( + iBoundBoxArray[ iCurSearchMatchId ] , + Rect() ); + if ( lIsBoxInView || + ( !iSvgModule->IsElementVisible( + iTextElemIdArray[ iCurSearchMatchId ] ) ) ) + { + // Store the current match Index so that the end of the list + // can be identified. + TInt lastSearchMatchId = iCurSearchMatchId; + // Increment iIsCurMatchId to point to next matching text + iCurSearchMatchId = ( iCurSearchMatchId + KSccConstOne ) % + ( iBoundBoxArray.Count() ); + while ( ( iCurSearchMatchId != lastSearchMatchId ) && + ( !iSvgModule->IsElementVisible( + iTextElemIdArray[ iCurSearchMatchId ] ) ) ) + { + // Increment iIsCurMatchId to point to next matching text + iCurSearchMatchId = ( iCurSearchMatchId + KSccConstOne ) % + ( iBoundBoxArray.Count() ); + } + if( iCurSearchMatchId == lastSearchMatchId || + (iCurSearchMatchId==0 ) ) + { + ProcessNoTextFoundL(); + return; + } + } + } + else + { + // New Search String + iCurSearchMatchId = KSccConstZero; + iIsSearchStrValid = ETrue; + + if ( !CalcFindTextBBox() ) + { + ProcessNoTextFoundL(); + return; + } + else + { + // Match Found, + // Find the first box in the list that is visible + if ( !iSvgModule->IsElementVisible( + iTextElemIdArray[ iCurSearchMatchId ] ) ) + { + // Store the current match Index so that the end of the + // list can be identified. + TInt lastSearchMatchId = iCurSearchMatchId; + // Increment iIsCurMatchId to point to next matching + // text + iCurSearchMatchId = ( iCurSearchMatchId + + KSccConstOne ) % ( iBoundBoxArray.Count() ); + while ( ( iCurSearchMatchId != lastSearchMatchId ) && + ( !iSvgModule->IsElementVisible( + iTextElemIdArray[ iCurSearchMatchId ] ) ) ) + { + // Increment iIsCurMatchId to point to next + // matching text + iCurSearchMatchId = ( iCurSearchMatchId + + KSccConstOne ) % ( iBoundBoxArray.Count() ); + } + if ( iCurSearchMatchId == lastSearchMatchId ) + { + ProcessNoTextFoundL(); + return; + } + } + } + } + + // To determine if a bounding-box is in view: + // Take the intersection ( TRect::Intersects ) of the + // Cust Control's rect and the bounding-box. If Intersects() + // returns true, bounding-box is in view + TRect myRect= Rect(); + TBool lIsBoxInView = FPRIntersects( iBoundBoxArray[ iCurSearchMatchId ], + myRect ); + + if ( !lIsBoxInView ) + { + // Box is not in view + + // Pan Content to bring the text in view + PanToCurBBox(); + + // Get new position of Bounding Boxes + CalcFindTextBBox(); + } + + // Make the mouse visible + SetPointerDisplayStatusAndRedraw( ETrue ); + // Move Mouse over to the centre of the Bound Box + TPoint lMousePos = + FPRCenter( iBoundBoxArray[ iCurSearchMatchId ] ); + iPointerX = lMousePos.iX; + iPointerY = lMousePos.iY; + + UpdatePointer(); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DrawFindTextBBox +// Draws the Bounding Box for the current match in the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DrawFindTextBBox( + const TRect& aRect ) const // Rectangle which needs to be redrawn + { + // Is there any text to highlight? + if ( iIsSearchStrValid ) + { + // To determine if a bounding-box can be drawn: + // Need to check whether it is in view && It is visible + // + // Check whether it is in view: + // Take the intersection ( TRect::Intersects ) of the CoeControl-rect + // and the bounding-box.if Intersects() returns true, + // bounding-box is in view + // Check whether it is visible: + // Call Engine API to check whether the text elem is visible. + + TBool lCanDrawBox = ( FPRIntersects( + iBoundBoxArray[ iCurSearchMatchId ], aRect ) && + iSvgModule->IsElementVisible( iTextElemIdArray[ + iCurSearchMatchId ] ) ); + + if ( lCanDrawBox ) + { + // Set the Draw Mode to XOR + iSVGTFrameBufContext->SetDrawMode( CGraphicsContext::EDrawModeXOR ); + + // Set the Brush Style to No Fill + iSVGTFrameBufContext->SetBrushStyle( + CGraphicsContext::ESolidBrush ); + + // Set the Pen Style to Solid and color to one obtd from LAF + iSVGTFrameBufContext->SetPenStyle( CGraphicsContext::ESolidPen ); + iSVGTFrameBufContext->SetPenColor( iFindTextHiColor ); + + // Set the line thickness + iSVGTFrameBufContext->SetPenSize( TSize( KSccConstTwo, + KSccConstTwo ) ); + + // Set the brush to White so that when the color is XORed with it + // it is displayed in its complementary colours. + iSVGTFrameBufContext->SetBrushColor( KRgbWhite ); + // Form the clipping rectangle so that text beyound the + // framebuffer is not displayed + TRect lClipRect( TPoint( 0,0 ), iSvgModule->Size() ); + + iSVGTFrameBufContext->SetClippingRect( lClipRect); + CArrayFix* lArray = NULL; + TRAPD( err, + FPR2PointArrayL( iBoundBoxArray[ iCurSearchMatchId ], + lArray ) ); + if ( err != KErrNone ) + { + delete lArray; + return; + } + + iSVGTFrameBufContext->DrawPolygon( + lArray ); + + delete lArray; + lArray = NULL; + + // Reset the graphic context parameters so that subsequent + // Draw() functions are not affected. + iSVGTFrameBufContext->Reset(); + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessNoTextFoundL +// This function is called to perform the necessary procesing when +// text being searched using Find Text command is not found. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessNoTextFoundL() + { + // Set the search string as invalid + iIsSearchStrValid = EFalse; + // Reset the string + //Himanshu iLastSearchText.Zero(); + + // No match found, display an information note + TInt resourceId; + + resourceId = R_SVGT_TEXT_NOT_FOUND; + // Read from Resource + HBufC* prompt = iCoeEnv->AllocReadResourceLC( + resourceId ); + + // Start a timer to delete the note after 3 seconds. + if (!iNoteRemoverTimer->IsActive()) + { + iNoteRemoverTimer->Start( KSccOneSecond * 3, KSccOneSecond * 3, + TCallBack( RemoveInfoNote, this ) ); + } + // Create and display the note + iInfoNote = new ( ELeave ) CAknInformationNote( + ETrue ); // ETrue - Waiting Dialog + iInfoNote->ExecuteLD( *prompt ); + + // Reset the pointer + iInfoNote = NULL; + + CleanupStack::PopAndDestroy( prompt ); + + // Do a deferred draw in order to refresh the highlight + DrawDeferred(); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DrawPanInd +// Draws the Panning indicators for the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DrawPanInd() const + { + // Get current Control Rectangle + TRect myRect = Rect(); + // Set the Brush Style and Pen Style to NULL type + // so that the background of bitmap is correctly blitted. + iSVGTFrameBufContext->SetPenStyle( CGraphicsContext::ENullPen ); + iSVGTFrameBufContext->SetBrushStyle( CGraphicsContext::ENullBrush ); + + if ( iSvgModule ) + { + // Pan Left? + if ( iPanLt ) + { + // Draw the indicator + iSVGTFrameBufContext->BitBltMasked( iPanIndLeftRect.Rect().iTl, + iPanIndLeftIcon->Bitmap(), + myRect, + iPanIndLeftIcon->Mask(), + EFalse ); + + } + + // Pan Right? + if ( iPanRt ) + { + // Draw the indicator + iSVGTFrameBufContext->BitBltMasked( iPanIndRightRect.Rect().iTl, + iPanIndRightIcon->Bitmap(), + myRect, + iPanIndRightIcon->Mask(), + EFalse ); + } + + // Pan Up? + if ( iPanUp ) + { + // Draw the indicator + iSVGTFrameBufContext->BitBltMasked( iPanIndUpRect.Rect().iTl, + iPanIndUpIcon->Bitmap(), + myRect, + iPanIndUpIcon->Mask(), + EFalse ); + } + + // Pan Down? + if ( iPanDn ) + { + // Draw the indicator + iSVGTFrameBufContext->BitBltMasked( iPanIndDownRect.Rect().iTl, + iPanIndDownIcon->Bitmap(), + myRect, + iPanIndDownIcon->Mask(), + EFalse ); + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CountAnimStarted +// Counts the number of animations started in the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::CountAnimStarted() + { + iNumAnimInProgress++; +#ifdef _DEBUG + iDbgNumAnimStarted++; +#endif + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CountAnimPaused +// Counts the number of animations paused in the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::CountAnimPaused() + { + // Pause is for the whole content, rather than per animation. + // Do not reset the count of animations in progress. Once the + // animation is resumed it would receive as many AnimStopped()(as in + // iNumAnimInProgress) as the animation progresses towards completion. +#ifdef _DEBUG + iDbgNumAnimPaused++; +#endif + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::CountAnimStopped +// Counts the number of animations stopped in the SVGT content. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::CountAnimStopped() + { + iNumAnimInProgress--; +#ifdef _DEBUG + iDbgNumAnimStopped++; +#endif + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsAnimFirst +// Function indicates whether the animation currently in progress is first one. +// @return TBool - ETrue - First one +// EFalse Otherwise. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsAnimFirst() const + { + return( iNumAnimInProgress == 0 ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsAnimLast +// Function indicates whether the animation currently in progress is the last +// one. +// @return TBool - ETrue - Last one +// EFalse Otherwise. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsAnimLast() const + { + return( iNumAnimInProgress == 0 ); + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SetPointerDisplayStatusAndRedraw +// Function sets the Pointer display status and redraws the whole control +// inorder to update display status. Called when Pointer Hide Timer times out. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SetPointerDisplayStatusAndRedraw( + TBool aIsPointerDisplayed ) + { + if ( iIsPointerDisplayed != aIsPointerDisplayed ) + { + iIsPointerDisplayed = aIsPointerDisplayed; + //Set the MSK label + if(iMSKImpl && iScrollKey && !iPreviewMode ) + { + iScrollKey=EFalse; + TRAP_IGNORE(SetMSKLabelL()); + } + DrawDeferred(); + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ShowPauseIcon() +// This function updates the pause indicator display in the main pane +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ShowPauseIcon( + TBool aPauseIconVisible ) // ETrue - Start Pause Blink + { + if ( iDisplayFlags & ESvgDrawPauseIndicator ) + { + if (aPauseIconVisible && !iBlinker->IsActive()) + { + iBlinker->Start( KSccOneSecond/2, KSccOneSecond/2, + TCallBack( BlinkPauseIcon, this ) ); + } + if (!aPauseIconVisible && iBlinker->IsActive()) + { + iBlinker->Cancel(); + } + iPauseIconVisible = aPauseIconVisible; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::BlinkPauseIcon +// Callback function of blink timer +// ----------------------------------------------------------------------------- +// +TInt CSVGTCustControl::BlinkPauseIcon( TAny* aPtr ) + { + if ( aPtr ) + { + static_cast< CSVGTCustControl* >( aPtr )->DoBlinkPauseIcon(); + } + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DoBlinkPauseIcon +// Function which does the actual work of toggling pause indicator +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DoBlinkPauseIcon() + { + iPauseIconVisible = !iPauseIconVisible; + DrawDeferred(); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::FreeIcons +// Function which frees the icons created by CreateIcons +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::FreeIcons() + { + // Pointer Icons - owned + delete iPointerIcon; + iPointerIcon = NULL; + + delete iHandIcon; + iHandIcon = NULL; + + delete iTextIcon; + iTextIcon = NULL; + + // Panning Indicator Icons - owned + delete iPanIndLeftIcon; + iPanIndLeftIcon = NULL; + + delete iPanIndRightIcon; + iPanIndRightIcon = NULL; + + delete iPanIndUpIcon; + iPanIndUpIcon = NULL; + + delete iPanIndDownIcon; + iPanIndDownIcon = NULL; + + // Pause Indicator Icons - owned + delete iPauseIcon; + iPauseIcon = NULL; + } + +// ---------------------------------------------------------------------------- +// CSVGTCustControl::LaunchWaitNoteL +// Helper function for launching wait note. +// ---------------------------------------------------------------------------- +// +void CSVGTCustControl::LaunchWaitNoteL( + TInt aResourceId ) // Resource ID indicating + // string to be displayed + // while waiting. + { + if ( iDisplayFlags & ESvgDisplayWaitNote ) + { + if( iWaitDialog ) + { + delete iWaitDialog; + iWaitDialog = NULL; + } + + iWaitDialog = new( ELeave ) CAknWaitDialog( + reinterpret_cast( + &iWaitDialog ), + ETrue /* No visibility delay = + Display Wait note immediately */ ); + + iWaitDialog->PrepareLC( R_SVGT_WAIT_NOTE ); + + HBufC* lNoteTextPtr = StringLoader::LoadLC( aResourceId ); + iWaitDialog->SetTextL( *lNoteTextPtr ); + CleanupStack::PopAndDestroy( lNoteTextPtr ); + + // Launch dialog + iWaitDialog->RunLD(); + } + } + +// ---------------------------------------------------------------------------- +// CSVGTCustControl::DismissWaitNote +// Helper function for dismissing wait note. +// ---------------------------------------------------------------------------- +// +void CSVGTCustControl::DismissWaitNote() + { + if ( iDisplayFlags & ESvgDisplayWaitNote ) + { + if( iWaitDialog ) + { + TRAPD( err, iWaitDialog->ProcessFinishedL() ); + if( err ) + { + delete iWaitDialog; + iWaitDialog = NULL; + } + } + } + } + +// ---------------------------------------------------------------------------- +// CSVGTCustControl::StartProgIndTimer +// Helper function for starting the progress indicator timer. +// ---------------------------------------------------------------------------- +// +void CSVGTCustControl::StartProgIndTimer( TInt aAfter ) // Time period in + // micro-seconds after + // after which timer + // expires + { + // Stop the progress indicator timer if exists + StopProgIndTimer(); + + TRAPD(err, iProgressBarTimer = + CSVGTProgressBarTimer::NewL( this, + iDisplayFlags & ESvgUseBackLight ) ); + + if ( err == KErrNone ) + { + // Expire after aAfter microseconds. + iProgressBarTimer->After( aAfter ); + } + } + +// ---------------------------------------------------------------------------- +// CSVGTCustControl::StopProgIndTimer +// Helper function for stopping the progress indicator timer. +// ---------------------------------------------------------------------------- +// +void CSVGTCustControl::StopProgIndTimer() + { + // Delete the Progress Bar timer + if ( iProgressBarTimer ) + { + delete iProgressBarTimer; + iProgressBarTimer = NULL; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessPlayCmd +// This function is called to perform the necessary processing for the Play +// command. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessPlayCmd() + { + // Play Command is applicable only if animations are present + if ( IsAnimationPresent() ) + { + if ( iAnimState != ESvgAnimPlayingState ) + { + // Start the backlight timer if the content is of finite duration + if ( IsContentFinite() ) + { + if ( ( iDisplayFlags & ESvgUseBackLight ) ) + { +#ifdef _DEBUG + iEikonEnv->InfoMsg( KSccBacklightOnStr ); +#endif +/* + TRAPD( err, iBacklightTimer = CSVGTBacklightTimer::NewL() ); + if ( err == KErrNone ) + { + iBacklightTimer->After( KSccBacklightTimerStartAfter ); + } +*/ + } + } + + // Start the Progress Ind Timer if the content is of finite duration + if ( IsContentFinite() ) + { + // Start immediately so that current count is updated. + StartProgIndTimer( 0 ); + } + + if ( iAnimState == ESvgAnimStoppedState ) + { + // Rewind the content + iSvgModule->Replay(); + } + else + { + // Resume playback of the content + iSvgModule->Resume(); + } + // Set the state variable to indicate content is playing + iAnimState = ESvgAnimPlayingState; + + // Hide the display of Pause content + ShowPauseIcon( EFalse ); + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessPauseCmd +// This function is called to perform the necessary processing for the Pause +// command. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessPauseCmd() + { + // Pause Command is applicable only if animations are present + if ( IsAnimationPresent() ) + { + if ( iAnimState == ESvgAnimPlayingState ) + { + if ( IsContentFinite() ) + { + // Stop the progress Bar timer + StopProgIndTimer(); + } + // Set the state variable. + iAnimState = ESvgAnimPausedState; + // Pause the content + iSvgModule->Pause(); + // Show the pause indicator + ShowPauseIcon( ETrue ); + } + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ProcessStopCmd +// This function is called to perform the necessary processing for the Stop +// command. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ProcessStopCmd() + { + // Stop Command is applicable only if animations are present + if ( IsAnimationPresent() ) + { + if ( IsContentFinite() ) + { + // Stop the progress Bar timer + StopProgIndTimer(); + } + // Stop playing the content + // Do a pause so that the content is not rewound. + iSvgModule->Stop(); + + // Reset the state variables + iAnimState = ESvgAnimStoppedState; + iProgIndTimeElap = 0; + + // Reset the number of animations in progress. + iNumAnimInProgress = 0; + + // Stop the display of the Pause indicator + ShowPauseIcon( EFalse ); + + // Redraw the screen - so that pause icon is cleaned up + DrawDeferred(); + } + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::IsVoiceCallActive +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::IsVoiceCallActive() + { + TBool call; + TInt type = 0; + // Check whether a call is a voice call + TInt error = iSystemState.Get( KPSUidCtsyCallInformation, + KCTsyCallType, type ); + if ( !error && type == EPSCTsyCallTypeCSVoice ) + { + call = ETrue; + } + else + { + call = EFalse; + } + + TInt state = 0; + // Check whether the voice call is active + error = iSystemState.Get( KPSUidCtsyCallInformation, + KCTsyCallState, state ); + if ( call && !error && state == EPSCTsyCallStateConnected ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::RemoveInfoNote +// This function is called by the periodic timer to remove the info note that +// is not removed because of starvation. +// ----------------------------------------------------------------------------- +// +TInt CSVGTCustControl::RemoveInfoNote( TAny* aPtr ) + { + CSVGTCustControl* thisPtr = static_cast< CSVGTCustControl* >( aPtr ); + if ( thisPtr && thisPtr->iInfoNote ) + { + delete thisPtr->iInfoNote; + thisPtr->iInfoNote = NULL; + } + if ( thisPtr ) + { + if ( thisPtr->iNoteRemoverTimer->IsActive() ) + { + thisPtr->iNoteRemoverTimer->Cancel(); + } + } + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DoRotation() +// This function rotates the presentation in clockwise direction with given +// angle about bitmap center +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DoRotation( const TInt aAngle ) + { + const TInt xCenter = iSVGTBitMap->SizeInPixels().iWidth / 2; + const TInt yCenter = iSVGTBitMap->SizeInPixels().iHeight / 2; + const TReal32 angleInRadians = KDegreesToRadiansFactor * TReal32( aAngle ); + iSvgModule->Rotate( angleInRadians, xCenter, yCenter ); + // Do a Redraw + iSvgModule->Redraw(); + UpdatePointer(); + } + +#ifdef SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DoTextSelectionL() +// This function displays the existing text in the text/textArea in a +// read-only dialog so that the user can copy text into system clipboard +// from it. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DoTextSelectionL( + TDes& aText // Text Content descriptor + ) const + { + CAknTextQueryDialog* dlgPtr = CAknTextQueryDialog::NewL( aText ); + dlgPtr->ExecuteLD( R_SVGT_TEXT_SELECTION_DIALOG ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DoTextEditingL() +// This function displays the existing text in the text/textArea element which +// is editable and returns the modified text in the same descriptor. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::DoTextEditingL( + TBool aIsTextElement, // Bool indicating whether element is text/textArea + TInt aElemHandle, // Element handle from engine + TDes& aText ) // Text Content descriptor + { + const TChar KOpeningBraces ='<'; + const TChar KClosingBraces ='>'; + TBool lTextQueryDone = EFalse; + + while ( !lTextQueryDone ) + { + CAknTextQueryDialog* dlgPtr = CAknTextQueryDialog::NewL( aText ); + dlgPtr->SetPredictiveTextInputPermitted( ETrue ); + TInt retVal = dlgPtr->ExecuteLD( R_SVGT_EDIT_TEXT_QUERY_DIALOG ); + if (retVal) + { + if ( !iIsTextChanged ) + { + // Set iIsTextChanged to indicate that text content is + // changed and changes need to be saved + iIsTextChanged = ETrue; + } + + if( aText.Locate( KOpeningBraces ) != KErrNotFound || + aText.Locate( KClosingBraces ) != KErrNotFound ) + { + // display a error not with the msg that the text area + // cant contain < or > since it will fuddle up the xml parsing + DisplayInfoNoteL(R_SVGT_BRACES_FOUND_IN_TEXTAREA, ETrue ); + } + else + { + // User entered valid text, go out of loop + lTextQueryDone = ETrue; + } + } + else + { + // User pressed cancel, no need to change the text + // return back to caller + return; + } + } + + if ( aIsTextElement ) + { + // Update the text element in the engine + iSvgModule->SetTextForTextElement( aElemHandle, aText ); + } + else + { + // Update the textArea element in the engine + iSvgModule->SetTextForTextAreaElement( aElemHandle, aText ); + } + // Redraw the screen to reflect the new changes + iSvgModule->Redraw(); + + + } +#endif // SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::FPRCenter() +// This function calculates the center of the four point rectangle +// ----------------------------------------------------------------------------- +// +TPoint CSVGTCustControl::FPRCenter( + const MRect* aBBoxRect // Four point rect + ) const + { + TPoint pt1( 0, 0 ), pt2( 0, 0 ), pt3( 0, 0 ), pt4( 0, 0 ); + TPoint lCentre; + + if ( aBBoxRect ) + { + aBBoxRect->GetPoints( pt1, pt2, pt3, pt4 ); + // Center of the rectangle is the center of the diagonal as + // diagonals are congruent in a rectangle + lCentre = TPoint( ( pt1.iX + pt3.iX ) / 2, ( pt1.iY + pt3.iY )/2 ); + } + return lCentre; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::FPRIntersects() +// This function calculates whether the FPR intersects with the rectangle +// ----------------------------------------------------------------------------- +TBool CSVGTCustControl::FPRIntersects( + const MRect* aBBoxRect, // Four point rect + const TRect& aRect // Rectangle + ) const + { + TPoint pt1( 0, 0 ), pt2( 0, 0 ), pt3( 0, 0 ), pt4( 0, 0 ); + if ( aBBoxRect ) + { + aBBoxRect->GetPoints( pt1, pt2, pt3, pt4 ); + // TODO: Need to use clipping algorithm here - to check whether line is + // within rectangle. + TInt32 maxx,maxy,minx,miny; + + maxx = pt1.iX; + if(pt2.iX > maxx) + maxx = pt2.iX; + if(pt3.iX > maxx) + maxx = pt3.iX; + if(pt4.iX > maxx) + maxx = pt4.iX; + + maxy = pt1.iY; + if(pt2.iY > maxy) + maxy = pt2.iY; + if(pt3.iY > maxy) + maxy = pt3.iY; + if(pt4.iY > maxy) + maxy = pt4.iY; + + minx = pt1.iX; + if(pt2.iX < minx) + minx = pt2.iX; + if(pt3.iX < minx) + minx = pt3.iX; + if(pt4.iX < minx) + minx = pt4.iX; + + miny = pt1.iY; + if(pt2.iY < miny) + miny = pt2.iY; + if(pt3.iY < miny) + miny = pt3.iY; + if(pt4.iY < miny) + miny = pt4.iY; + + + TPoint topleft(aRect.iTl); + TPoint bottomright(aRect.iBr); + + if ( ( bottomright.iX < minx ) || ( maxx < topleft.iX ) || + ( bottomright.iY < miny) || ( maxy < topleft.iY ) ) + { + return EFalse; + } + + return ETrue; + } + return EFalse; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::FPR2PointArrayL() +// This function converts a Four Point Rect into an array of points +// ----------------------------------------------------------------------------- +void CSVGTCustControl::FPR2PointArrayL( + const MRect* aBBoxRect, // Four Point Rect + CArrayFix*& aArrayPtr // Array of Points + ) const + { + aArrayPtr = new (ELeave) CArrayFixFlat ( 4 ); + CleanupStack::PushL( aArrayPtr ); + TPoint pt1( 0, 0 ), pt2( 0, 0 ), pt3( 0, 0 ), pt4( 0, 0 ); + + if ( aBBoxRect ) + { + aBBoxRect->GetPoints( pt1, pt2, pt3, pt4 ); + } + aArrayPtr->AppendL( pt1 ); + aArrayPtr->AppendL( pt2 ); + aArrayPtr->AppendL( pt4 ); + aArrayPtr->AppendL( pt3 ); + + CleanupStack::Pop( aArrayPtr ); // Ownership transferred to caller + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::Draw +// Reimplements CCoeControl::Draw to draw this control's view to the screen +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::Draw( + const TRect& aRect ) const + { + iSVGTFrameBufContext->Clear(); + + if ( iSVGTBitMap && iSVGTBitMapMask ) + { + iSVGTFrameBufContext->BitBltMasked( iViewerPaneRect.Rect().iTl, + iSVGTBitMap, + iViewerPaneRect.Rect(), + iSVGTBitMapMask, + ETrue ); + } + + // Draw the bounding box + DrawFindTextBBox( aRect ); + + if ( iDisplayFlags & ESvgDrawPanIndicator ) + { + // Draw Panning Indicator + DrawPanInd(); + } + + // draw paused icon + if ( iPauseIconVisible ) + { + iSVGTFrameBufContext->BitBltMasked( iPauseRect.Rect().iTl, + iPauseIcon->Bitmap(), + Rect(), + iPauseIcon->Mask(), + EFalse ); + } + + + // Draw Pointer + if ( iIsPointerDisplayed && iDisplayFlags & ESvgDrawPointer ) + { + DrawPointer(); + } + + // Get the standard graphics context + CWindowGc& gc = SystemGc(); + // Blit our framebuffer bitmap to the System GC + gc.BitBlt( iViewerPaneRect.Rect().iTl, iSVGTFrameBufBitMap ); + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ConstructFromResourceL +// Since this control is to be displayed in a dialog, this function is +// reimplented from CCoeControl::ConstructFromResourceL inorder to read +// resource values from resource file. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ConstructFromResourceL( + TResourceReader& /*aReader*/) // Resource Reader + { + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::SizeChanged +// Handles resizing of control reimplementing CCoeControl::SizeChanged. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::SizeChanged() + { + TRect myRect = Rect(); + + // Commented this section because,Indicators were not displaying in + // case of theme change + // if ( myRect == iCurrentLayout ) + // { + // Layout has not changed, do nothing + // return; + // } + // + + if ( AknLayoutUtils::ScalableLayoutInterfaceAvailable() ) + { + TInt lVariety = 0; // Normal Screen + if ( iIsFullScreenOn ) + { + lVariety = 1; // Full Screen + } + + // Main Viewer Pane + iViewerPaneRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane( lVariety ) ); + + // Panning Indicators + iPanIndLeftRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g3( lVariety ) ); + iPanIndRightRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g4( lVariety ) ); + iPanIndUpRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g1( lVariety ) ); + iPanIndDownRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g2( lVariety ) ); + // Panning Indicators Rectangle for Touch Area + iPanIndLeftAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_main_viewer_pane_g3( lVariety ) ); + iPanIndRightAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_main_viewer_pane_g4( lVariety ) ); + iPanIndUpAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_main_viewer_pane_g1( lVariety ) ); + iPanIndDownAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_main_viewer_pane_g2( lVariety ) ); + + // Pointers + iPointerRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g5( lVariety ) ); + iHandRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g7( lVariety ) ); + iTextRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g7( lVariety ) ); + + // Pause Indicator + iPauseRect.LayoutRect( myRect, + AknLayoutScalable_Apps::main_viewer_pane_g8( lVariety ) ); + + // Aid for display of pointer + // In order to draw the cursor in the correct location on + // the screen, the viewer needs to know the offsetX and offSetY + // of the cursor hotspot in the icon bitmap. + // Because of Scalable UI the size of the icons can be changed + // and this would result in the change of these co-ordinates. + // he viewer needs to get this information from the LAF + // so that viewer can draw the cursor in the correct position + // on the screen. + + iPointerAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_hotspot_pointer_arrow_pane() ); + iHandAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_hotspot_pointer_hand_pane() ); + iTextAidRect.LayoutRect( myRect, + AknLayoutScalable_Apps::aid_hotspot_pointer_text2_pane() ); + } + else + { + // Hardcode the values for normal resolution (172x208) + + iViewerPaneRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, myRect.Width(), myRect.Height() ); + + iPanIndLeftRect.LayoutRect( myRect, + 0, 0, ( myRect.Height() / KSccConstTwo ) - 8, 0, 0, 6, 15 ); + iPanIndRightRect.LayoutRect( myRect, + 0, ( myRect.Width() - 6 ), + (myRect.Height() / KSccConstTwo ) - 8, 0, 0, 6, 15 ); + iPanIndUpRect.LayoutRect( myRect, + 0, ( ( myRect.Width() / KSccConstTwo ) - 8 ), 0, 0, 0, + 15, 6 ); + iPanIndDownRect.LayoutRect( myRect, + 0, ( ( myRect.Width() / KSccConstTwo ) - 8 ), + myRect.Height() - 6, 0, 0, 15, 6 ); + + iPointerRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 18, 24 ); + iHandRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 18, 24 ); + iTextRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 18, 24 ); + + + iPauseRect.LayoutRect(myRect, + 0, 0, 0, 0, 0, 13, 13 ); + + iPointerAidRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 0, 0 ); + iHandAidRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 0, 0 ); + iTextAidRect.LayoutRect( myRect, + 0, 0, 0, 0, 0, 0, 0 ); + } + + // Set the size of the bitmaps + // No Error Handling for SetSize + // Pointers + AknIconUtils::SetSize( iPointerIcon->Bitmap(), iPointerRect.Rect().Size() ); + AknIconUtils::SetSize( iHandIcon->Bitmap(), iHandRect.Rect().Size() ); + AknIconUtils::SetSize( iTextIcon->Bitmap(), iTextRect.Rect().Size() ); + + // Panning Indicators + + // Left Ind + AknIconUtils::SetSize( iPanIndLeftIcon->Bitmap(), + iPanIndLeftRect.Rect().Size() ); + + // Right Ind + AknIconUtils::SetSize( iPanIndRightIcon->Bitmap(), + iPanIndRightRect.Rect().Size() ); + + // Up Ind + AknIconUtils::SetSize( iPanIndUpIcon->Bitmap(), + iPanIndUpRect.Rect().Size() ); + + // Down Ind + AknIconUtils::SetSize( iPanIndDownIcon->Bitmap(), + iPanIndDownRect.Rect().Size() ); + + // Pause Ind + AknIconUtils::SetSize( iPauseIcon->Bitmap(), + iPauseRect.Rect().Size() ); + + // Recreate the framebuffer. + TRAPD( errSwitchMode, SwitchScreenModeL() ); + if ( errSwitchMode != KErrNone ) + { + // Let environment handle error + iCoeEnv->HandleError( errSwitchMode ); + } + + // Dummy mouse-move to the engine + iSvgModule->MouseMove( iPointerX, iPointerY ); + + // Save current layout so that we know if the Layout changed. + iCurrentLayout = myRect; + } + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::AnimationStarted +// Handles callback notification from SVG engine indicating Animation Started. +// Reimplements MSvgAnimationListener::AnimationStarted. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::AnimationStarted( TBool aIsAnimationIndefinite ) + { + // If the content contains any infinite animations - then the + // backlight behaves normally. + if ( !IsContentFinite() ) + { + return ETrue; + } + + if ( aIsAnimationIndefinite ) + { +#ifdef _DEBUG + iEikonEnv->InfoMsg( KSccBacklightOffStr ); +#endif + + } + else + { + if ( IsAnimFirst() ) + { +#ifdef _DEBUG + iEikonEnv->InfoMsg( KSccBacklightOnStr ); +#endif + if ( ( iDisplayFlags & ESvgUseBackLight ) ) + { + + } + } + CountAnimStarted(); + } + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::AnimationEnded +// Handles callback notification from SVG engine indicating Animation Ended. +// Reimplements MSvgAnimationListener::AnimationEnded. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::AnimationEnded() + { + // If the content contains any infinite animations - then the + // backlight behaves normally. + if ( !IsContentFinite() ) + { + return ETrue; + } + + CountAnimStopped(); + if ( IsAnimLast() ) + { +#ifdef _DEBUG + iEikonEnv->InfoMsg( KSccBacklightOffStr ); +#endif + // All animations have ended + + } + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::AnimationPaused +// Handles callback notification from SVG engine indicating Animation Paused. +// Reimplements MSvgAnimationListener::AnimationPaused. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::AnimationPaused() + { + // If the content contains any infinite animations - then the + // backlight behaves normally. + if ( !IsContentFinite() ) + { + return ETrue; + } + +#ifdef _DEBUG + iEikonEnv->InfoMsg( KSccBacklightOffStr ); +#endif + // Animation is paused, + CountAnimPaused(); + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::UpdateProgressBar +// This function updates the progress bar in the navi pane. It is called back +// by the progress bar timer. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::UpdateProgressBar() + { + + TReal lSecElapsedRounded = 0.0; + TReal lSecElapsedReal = 0.0; + TReal lTotalTimeReal = 0.0; + TReal lTotalTimeRounded = 0.0; + TUint32 lTimeElapsed = 0; + + lSecElapsedReal = (TReal)iSvgModule->MediaTime() + / KSccNumMSecPerSec; + + lTotalTimeReal = (TReal)iDuration / KSccNumMSecPerSec; + if ( iProgressBarDrawImpl ) + { + + + // Round off the Elapsed time inorder to display time accurately. + Math::Round( lSecElapsedRounded, lSecElapsedReal, 0 ); + + // Round off the Total time inorder to display time accurately. + Math::Round( lTotalTimeRounded, lTotalTimeReal, 0 ); + + lTimeElapsed = lSecElapsedRounded; + TRAPD( err, iProgressBarDrawImpl->DrawProgressBarL( lTimeElapsed, + lTotalTimeRounded ) ); + if ( err != KErrNone ) + { + // Error Case, Nothing is done now. + } + + + // Stop the Progress Bar timer + StopProgIndTimer(); + iProgIndTimeElap = lSecElapsedReal ; + + } + + // Check whether end of animation is reached. + // 01-Feb-2008 Fix for TSW Id "CGSR-7B6DFW" + // Earlier this check was happening only if iProgressBarDrawImpl is there + // for screen saver iProgressBarDrawImpl is not there but still the animation + // should work for the duration set for ScreenSaver + + if ( lSecElapsedReal >= (TReal)iDuration / KSccNumMSecPerSec ) + { + TInt err = 0; + // Reset the state variables + iProgIndTimeElap = 0; + + // Stop the animation and rewind. + TRAP(err, ProcessViewerCommandL( ESvgtDlgStopCommand ) ); + if ( err != KErrNone ) + { + // Error Case, Nothing is done now. + } + // If loop is on then replay the content. + if ( !iIsLoopOn ) + { + // Animation is done, no need to continue progress bar. + return; + } + else + { + // Loop option enabled. Replay content. + TRAP( err, ProcessViewerCommandL( ESvgtDlgPlayCommand )); + if ( err != KErrNone ) + { + // Error Case, Nothing is done now. + } + return; + } + } + + + + + // Restart the timer + StartProgIndTimer( KSccProgIndTimerYieldDur ); + } + + + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::PointerInactivityTimeout() +// This function updates the pointer display status in the navi pane. +// It is called back by the pointer hide timer. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::PointerInactivityTimeout() + { + // UI Spec: Hide Pointer as time of inactivity has passed + SetPointerDisplayStatusAndRedraw( EFalse ); + + //Set the MSK label + if(iMSKImpl && !iPreviewMode ) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + // Delete the inactivity timer + delete iInactivityTimer; + iInactivityTimer = NULL; + } + +#ifdef SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextAreaEntered() +// This callback is called to notify when a pointer enters a textbox element. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextAreaEntered( TInt aTextAreaHandle ) + { + // Save the current element handle + iCurrentTextElementId = aTextAreaHandle; + + // Indicate that it is a text area element + iIsCurrentTextElement = EFalse; + + // check if there is a 'a' element or interactive element + // within which text is present + + if(iAElement || iPointerDownAnimation) + { + iPointerType=ESvgPointerHand; + } + else + { + // Text symbol to indicate user can perform some action by clicking + iPointerType = ESvgPointerText; + } + // Remember that textArea element is entered, so that + // subsequent text element notifications are ignored + iTextAreaEntered = ETrue; + + // Enable Select Menu Option + iIsTextSelectOn = ETrue; + HBufC* lStrPtr = HBufC::New( KSccMaxTextLength ); + if ( !lStrPtr ) + { + // Error while allocation, no memory + iCoeEnv->HandleError( KErrNoMemory ); + return ETrue; + } + TPtr lPtr = lStrPtr->Des(); + + // Check whether the Text is editable + iSvgModule->GetTextForTextAreaElement( aTextAreaHandle, + iIsTextEditOn, + lPtr ); + + delete lStrPtr; + + //Display MSK label Select/Edit + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextAreaExited() +// This callback is called to notify when a pointer exits a textbox element. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextAreaExited( TInt /* aTextAreaHandle */) + { + // Reset the current element handle + iCurrentTextElementId = 0; + + // Reset the element flag to text element + iIsCurrentTextElement = ETrue; + + // check if there is a 'a' element or interactive element + // within which text is present + if(iAElement || iPointerDownAnimation) + { + iPointerType=ESvgPointerHand; + } + else + { + // Reset the pointer to default pointer + iPointerType = ESvgPointerDefault; + } + // Remember that textArea element is exitted + iTextAreaEntered = EFalse; + + // Disable the Select and Edit menu option + iIsTextSelectOn = EFalse; + iIsTextEditOn = EFalse; + //Set the MSK label + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextAreaActivated() +// This callback is called to notify that a text element has been activated. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextAreaActivated( TInt aTextAreaHandle ) + { + if (iSelectCause != ESvgInvalidSelectCause ) + { + // Ignore this callback as it was already processed. + return ETrue; + } + // Set the cause for select operation as text area so that + // subsequent events trigerred are ignored. + iSelectCause = ESvgTextAreaSelectCause; + + HBufC* lStrPtr = HBufC::New( KMaxEditorTextLength ); + if ( !lStrPtr ) + { + // Error while allocation, no memory + iCoeEnv->HandleError( KErrNoMemory ); + return ETrue; + } + TPtr lPtr = lStrPtr->Des(); + + // Check whether the Text is editable + iSvgModule->GetTextForTextAreaElement( aTextAreaHandle, + iIsTextEditOn, + lPtr ); + + if ( iIsTextEditOn && !iSvgModule->IsLoading() ) + { + TRAPD( err, DoTextEditingL( + EFalse, // Text Area Element + aTextAreaHandle, // Element Handle + lPtr ) ); // buffer pointer + if ( err != KErrNone ) + { + // No error handling done. + } + + } + else + { + TRAPD( err, + DoTextSelectionL( lPtr ); + ); + if ( err != KErrNone ) + { + // No error handling done. + } + } + + delete lStrPtr; + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextEntered() +// This callback is called to notify that a text element has been entered. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextEntered( TInt aTextHandle ) + { + if ( iTextAreaEntered ) + { + // Ignore all text element notifications when cursor is + // within a textArea element + return ETrue; + } + + // Save the current element handle + iCurrentTextElementId = aTextHandle; + + // Set the flag to indicate element type is text element + iIsCurrentTextElement = ETrue; + + // check if there is a 'a' element or interactive element + // within which text is present + + if(iAElement || iPointerDownAnimation) + { + iPointerType=ESvgPointerHand; + } + else + { + // Text symbol to indicate user can perform some action by clicking + iPointerType = ESvgPointerText; + } + // Enable Select Menu Option + iIsTextSelectOn = ETrue; + + HBufC* lStrPtr = HBufC::New( KSccMaxTextLength ); + + if ( !lStrPtr ) + { + // Error while allocation, no memory + iCoeEnv->HandleError( KErrNoMemory ); + return ETrue; + } + + TPtr lPtr = lStrPtr->Des(); + + // Check whether the Text is editable + iSvgModule->GetTextForTextElement( aTextHandle, + iIsTextEditOn, + lPtr ); + + delete lStrPtr; + // Display MSK label Select/Edit + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextExited() +// This callback is called to notify that a text element has been exited. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextExited( TInt /* aTextHandle */ ) + { + if ( iTextAreaEntered ) + { + // Ignore all text element notifications when cursor is + // within a textArea element + return ETrue; + } + + // Reset the current element handle + iCurrentTextElementId = 0; + + // check if there is a 'a' element or interactive element + // within which text is present + if(iAElement || iPointerDownAnimation) + { + iPointerType=ESvgPointerHand; + } + else + { + // Reset the pointer to default + iPointerType = ESvgPointerDefault; + } + // Disable the Select and Edit menu option + iIsTextSelectOn = EFalse; + iIsTextEditOn = EFalse; + + //Set the MSK label + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::TextActivated() +// This callback is called to notify that a text element has been activated. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::TextActivated( TInt aTextHandle ) + { + if (iSelectCause != ESvgInvalidSelectCause ) + { + // Ignore this callback as it was already processed. + return ETrue; + } + // Set the cause for select operation as text so that + // subsequent events trigerred are ignored. + iSelectCause = ESvgTextSelectCause; + HBufC* lStrPtr = HBufC::New( KMaxEditorTextLength ); + if ( !lStrPtr ) + { + // Error while allocation, no memory + iCoeEnv->HandleError( KErrNoMemory ); + return ETrue; + } + TPtr lPtr = lStrPtr->Des(); + + // Check whether the Text is editable + iSvgModule->GetTextForTextElement( aTextHandle, + iIsTextEditOn, + lPtr ); + + if ( iIsTextEditOn && !iSvgModule->IsLoading()) + { + TRAPD( err, + DoTextEditingL( ETrue, // Text Element + aTextHandle , // Element Handle + lPtr ); // Buffer Pointer + ); + if ( err != KErrNone ) + { + // No Error handling done. + } + } + else + { + TRAPD( err, + DoTextSelectionL( lPtr ); + ); + if ( err != KErrNone ) + { + // No Error handling done. + } + } + delete lStrPtr; + return ETrue; + } + +#endif // SVGTUICONTROL_DBG_TEXT_EDIT_SELECT_API_ENABLE + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::InteractiveElementEntered() +// This callback is called to notify that an interactive element has been entered. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::InteractiveElementEntered(TPtrC /*aElementIdPtr*/, TUint16 aInteractonTypeList ) + { + + if( (aInteractonTypeList & ESvgInteractiveEventClick )|| + (aInteractonTypeList & ESvgInteractiveEventMousedown ) || + (aInteractonTypeList & ESvgInteractiveEventMouseup ) ) + { + + iPointerType = ESvgPointerHand; + + // Increment the count maintained for overlapping interactive elements + // with pointer-down events so that the iPointertype is set properly + iInteractiveElementEnteredCnt++; + + // Need to set flag so that when the element is within + // textarea or text + iPointerDownAnimation=ETrue; + + // Sets the MSK label + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + } + return ETrue; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::InteractiveElementExited() +// This callback is called to notify that an interactive element has been exited. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::InteractiveElementExited(TPtrC /*aElementIdPtr*/) + { + + // The count of interactive elements with pointer down events registered + // is decremented + if(iPointerDownAnimation) + { + iInteractiveElementEnteredCnt--; + } + + + if(!iInteractiveElementEnteredCnt) + { + iPointerType = ESvgPointerDefault; + + iPointerDownAnimation=EFalse; + //Set the MSK label + if(iMSKImpl && !iPreviewMode) + { + TRAP_IGNORE(SetMSKLabelL()); + } + } + + return ETrue; + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ReportAllElements +// Implements MSvgLoadingListener::ReportAllElements. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ReportAllElements() + { + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::WillAssignImageData +// Implements MSvgLoadingListener::WillAssignImageData. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::WillAssignImageData() + { + // Return ETrue to indicate that AssignImageData will be used to + // asynchronously load the image in the engine + if(iProgressiveRendering) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ImageDataReference +// Implements MSvgLoadingListener::ImageDataReference. +// ----------------------------------------------------------------------------- +// +void CSVGTCustControl::ImageDataReference( const TDesC& aUri ) + { + CSvgtEvent* event = NULL; + if ( aUri.Length() > KEmbededImageTagLength && + aUri.Left(KEmbededImageTagLength) == KDataTagName ) + { + event = new CSvgtEventEmbededImage(aUri); + } + else + { + event = new CSvgtEventFetchImage(aUri); + } + if ( iEventHandlerAO ) + { + iEventHandlerAO->AddEventToList( event ); + iEventHandlerAO->MakeRequestComplete( KErrNone ); + } + } +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ReportAllElements +// Implements MSvgLoadingListener::DocumentStart. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::DocumentStart() + { + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::DocumentEnd +// Implements MSvgLoadingListener::DocumentEnd. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::DocumentEnd() + { + if(iProgressiveRendering) + { + iEventHandlerAO->SetDocumentComplete(); + iEventHandlerAO->AddRedrawEventToList( ETrue ); + iEventHandlerAO->MakeRequestComplete( KErrNone ); + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ElementStart +// Implements MSvgLoadingListener::ElementStart. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ElementStart( const TDesC& aTagName, + MSvgAttributeList& /*aAttributeList*/) + { + if ( iProgressiveRendering && aTagName == KSvgTagName && iEngineInitialized + == EFalse ) + { + iEngineInitialized = ETrue; + iSvgModule->AddListener( static_cast < MSvgViewPortListener*>(this), ESvgViewPortListener ); + iSvgModule->InitializeEngine( NULL, EFalse); + } + else if ( iProgressiveRendering ) + { +// iEventHandlerAO->RequestRedraw(); +// User::After( 10 * 1000 ); + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ElementEnd +// Implements MSvgLoadingListener::ElementEnd. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ElementEnd( const TDesC& /* aTagName */) + { + if(iProgressiveRendering) + { + iEventHandlerAO->AddRedrawEventToList(); + iEventHandlerAO->MakeRequestComplete( KErrNone ); + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ExternalDataRequested +// Implements MSvgLoadingListener::ExternalDataRequested. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ExternalDataRequested( const TDesC& /* aUri */) + { + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ExternalDataReceived +// Implements MSvgLoadingListener::ExternalDataReceived. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ExternalDataReceived( const TDesC& /* aUri */) + { + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::ExternalDataRequestFailed +// Implements MSvgLoadingListener::ExternalDataRequestFailed. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::ExternalDataRequestFailed( const TDesC& /* aUri */) + { + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSVGTCustControl::UnsupportedElement +// Implements MSvgLoadingListener::UnsupportedElement. +// ----------------------------------------------------------------------------- +// +TBool CSVGTCustControl::UnsupportedElement( const TDesC& /* aTagName */, + MSvgAttributeList& /* aAttributeList*/ ) + { + return EFalse; + } +void CSVGTCustControl::ImagesLoaded(TInt aError) + { + if(aError != KErrNone) + { + if(!iIsWaitNoteDisplayed) + { + iIsWaitNoteDisplayed = ETrue; + TRAP_IGNORE( DisplayInfoNoteL( R_SVGT_FILE_NOT_COMPLETE, ETrue ) ); + } + } + } + +void CSVGTCustControl::DoExitFromDialogL() + { + if ( iExitObserver ) + { + iExitObserver->HandleApplicationExitL(EEikCmdExit); + } + } + +void CSVGTCustControl::AssignImageData( const TDesC& aUri, HBufC8* aData ) + { + if(aData) + { + iSvgModule->AssignImageData(aUri, aData); + // Do a redraw to reflect the image loaded + iSvgModule->Redraw(); + } + else + { + // Show information note + if(!iIsWaitNoteDisplayed) + { + iIsWaitNoteDisplayed = ETrue; + TRAP_IGNORE( DisplayInfoNoteL( R_SVGT_FILE_NOT_COMPLETE, ETrue ) ); + } + } + } +TInt CSVGTCustControl::DoHandleLoadingThreadError() + { + TInt lErrCode = KErrNone; + // An error note "Unable to open file" for eg. should be displayed + // in the following conditions + // a. Error Object contains NULL. This means possible out of memory + // when create error object. + // b. Error Object has an error which is not a warning - This + // indicates unrecoverable error in parsing - + // invalid/corrupted content + if ( (! iLoadingThreadError ) || ( iLoadingThreadError && + iLoadingThreadError->HasError() && + !iLoadingThreadError->IsWarning() ) ) + { + TRAP_IGNORE( DisplayInfoNoteL( R_SVGT_FILE_OPEN_FAILURE, ETrue ) ); + + // Exiting from the dialog + if ( iLoadingThreadError ) + { + lErrCode = iLoadingThreadError->SystemErrorCode(); + if ( lErrCode == KErrNone ) + { + lErrCode = KErrGeneral; + } + } + else + { + lErrCode = KErrNoMemory; + } + } + + if ( lErrCode == KErrNone ) + { +// Placed into the DoPostLoadFuncL + } + + return lErrCode; + } + +CSVGTCustControl::TFileType + CSVGTCustControl::ImageFileType( const TDesC& aUri ) const + { + + TUriParser UriParser; + + TBuf localUri; + // url starts with www so append http:// + if ( !aUri.Left( KSchemaLength ).Compare( KWww ) ) + { + localUri.Append( KHttp ); + localUri.Append( aUri ); + if ( UriParser.Parse( localUri ) ) + { + return ( EInvalidFilePath ); + } + } + else + { + if ( UriParser.Parse( aUri ) ) + { + return ( EInvalidFilePath ); + } + } + + if ( UriParser.IsPresent( EUriHost ) ) + { + // Extract the Path, filename and extension from the uri + TFileName filename = UriParser.Extract( EUriPath ); + TParsePtrC fileParser( filename ); + + if ( fileParser.NamePresent() && fileParser.ExtPresent() ) + { + if ( fileParser.Ext().Compare( KJpg ) == 0 || + fileParser.Ext().Compare( KJpeg ) == 0 || + fileParser.Ext().Compare( KBmp ) == 0 || + fileParser.Ext().Compare( KPng ) == 0 || + fileParser.Ext().Compare( KSvg ) == 0 || + fileParser.Ext().Compare( KSvgz ) == 0 ) + { + // file name and ext present and + // it is amy of the supported image types + return ERemoteImageFile; + } + else + { + //file Extension present but not a supported image ext, + //may be some html file + return ENotAnImageFile; + } + } + else + { + //Should be a domain name so return ENotAnImageFile + return ENotAnImageFile; + } + } + else + { + return ELocalImageFile; + } + } + +/** +* CSVGTCustControl::ResetBacklightTime +* Resets the backlight time for finite content +*/ +void CSVGTCustControl::ResetBacklightTime() + { + TTimeIntervalSeconds secondCount; + TTime currTime; + currTime.HomeTime(); + currTime.SecondsFrom(iPreviousBackLightTimeStamp, secondCount); + + if ( iDisplayFlags & ESvgUseBackLight ) + { + if(secondCount.Int() >= KBackLightTimeInterval) + { + User::ResetInactivityTime(); + iPreviousBackLightTimeStamp = currTime; + } + } + } + +void CSVGTCustControl::StopEventHandler() + { + if ( iEventHandlerAO ) + { + iEventHandlerAO->Cancel(); + } + } + +void CSVGTCustControl::SetThreadRunning(TBool aIsRunning) + { + iIsThreadRunning = aIsRunning; + } + +TBool CSVGTCustControl::IsThreadRunning() const + { + return iIsThreadRunning; + } + +void CSVGTCustControl::PerformEngineRedraw() + { + iSvgModule->Redraw(); + } + +//TOUCH SUPPORT START +#ifdef RD_SCALABLE_UI_V2 +void CSVGTCustControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + { + if(aPointerEvent.iType == TPointerEvent::EButton1Down) + { + if(iPntrObserver && iPntrObserver->HandleCustControlPointerEventL(aPointerEvent)) + return; + + // Reset the select cause + iSelectCause = ESvgInvalidSelectCause; + + TIndicatorType indicatorType = + ActiveIndicator(aPointerEvent.iPosition); + if (indicatorType != ENoIndicator) + { + if(indicatorType == EPauseIndicator) + { + ProcessPlayCmd(); + } + else + { + PanPresentation( indicatorType ); + } + } + + // Get the size of the content + TSize svgSize = iSvgModule->Size(); + TInt rgnw = svgSize.iWidth; + TInt rgnh = svgSize.iHeight; + if ( aPointerEvent.iPosition.iX >= rgnw || aPointerEvent.iPosition.iY >= rgnh ) + return; + iPointerX = aPointerEvent.iPosition.iX; + iPointerY = aPointerEvent.iPosition.iY; + iSvgModule->MouseDown( iPointerX, iPointerY ); + + SetPointerDisplayStatusAndRedraw(ETrue); + UpdatePointer(); + + Window().RequestPointerRepeatEvent(KInitRepeatInterval, ActiveIndicatorRect(indicatorType)); + } + else if(aPointerEvent.iType == TPointerEvent::EButtonRepeat) + { + UpdatePointer(); + TIndicatorType indicatorType = + ActiveIndicator(aPointerEvent.iPosition); + PanPresentation( indicatorType ); + Window().RequestPointerRepeatEvent(KInitRepeatInterval, ActiveIndicatorRect(indicatorType)); + } + else if(aPointerEvent.iType == TPointerEvent::EButton1Up) + { + Window().CancelPointerRepeatEventRequest(); + // UI Spec: Pointer should be hidden after 15 sec of + // user inactivity + if ( iInactivityTimer ) + { + // Should not be the case! + delete iInactivityTimer; + iInactivityTimer = NULL; + } + iInactivityTimer = CSVGTPointerHideTimer::NewL( this ); + iInactivityTimer->After( KSccPointerHideTimerStartAfter ); + + TIndicatorType indicatorType = + ActiveIndicator(aPointerEvent.iPosition); + if (indicatorType == ENoIndicator) + { + iSvgModule->MouseUp( iPointerX, iPointerY ); + } + } + else if(aPointerEvent.iType == TPointerEvent::EDrag) + { + // Get the size of the content + TSize svgSize = iSvgModule->Size(); + TInt rgnw = svgSize.iWidth; + TInt rgnh = svgSize.iHeight; + if ( aPointerEvent.iPosition.iX >= rgnw || aPointerEvent.iPosition.iY >= rgnh ) + return; + iPointerX = aPointerEvent.iPosition.iX; + iPointerY = aPointerEvent.iPosition.iY; + + iSvgModule->MouseMove( iPointerX, iPointerY ); + SetPointerDisplayStatusAndRedraw(ETrue); + UpdatePointer(); + } + } + +void CSVGTCustControl::SetContainerWindowL(const CCoeControl &aContainer) + { + CCoeControl::SetContainerWindowL(aContainer); + EnableDragEvents(); + } + +void CSVGTCustControl::PanPresentation( + const CSVGTCustControl::TIndicatorType aIndicatorType ) + { + switch( aIndicatorType ) + { + case ELeftIndicator: + { + iSvgModule->Pan( KSccPanNumPixelsX, KSccConstZero ); + break; + } + case ERightIndicator: + { + iSvgModule->Pan( -KSccPanNumPixelsX, KSccConstZero ); + break; + } + case EUpIndicator: + { + iSvgModule->Pan( KSccConstZero, KSccPanNumPixelsY ); + break; + } + case EDownIndicator: + { + iSvgModule->Pan( KSccConstZero, -KSccPanNumPixelsY ); + break; + } + } + iSvgModule->Redraw(); + DrawDeferred(); + } + +CSVGTCustControl::TIndicatorType CSVGTCustControl::ActiveIndicator( + const TPoint aPosition ) const + { + TIndicatorType indicatorType = ENoIndicator; + + if( iPanIndLeftAidRect.Rect().Contains( aPosition ) && iPanLt) + { + indicatorType = ELeftIndicator; + } + else if( iPanIndRightAidRect.Rect().Contains( aPosition ) && iPanRt) + { + indicatorType = ERightIndicator; + } + else if( iPanIndUpAidRect.Rect().Contains( aPosition ) && iPanUp) + { + indicatorType = EUpIndicator; + } + else if( iPanIndDownAidRect.Rect().Contains( aPosition ) && iPanDn) + { + indicatorType = EDownIndicator; + } + + return indicatorType ; + } + +TRect CSVGTCustControl::ActiveIndicatorRect( TIndicatorType aIndicator) const + { + TRect indicatorRect(0,0,0,0); + + switch(aIndicator) + { + case ELeftIndicator: + { + indicatorRect = iPanIndLeftAidRect.Rect(); + } + break; + case ERightIndicator: + { + indicatorRect = iPanIndRightAidRect.Rect(); + } + break; + case EUpIndicator: + { + indicatorRect = iPanIndUpAidRect.Rect(); + } + break; + case EDownIndicator: + { + indicatorRect = iPanIndDownAidRect.Rect(); + } + break; + } + + return indicatorRect; + } + +#endif //RD_SCALABLE_UI_V2 + +#ifdef RD_SVGT_AUDIO_SUPPORT +void CSVGTCustControl::HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType) + { + if((aControl == iVolumePopup) && ( aEventType == MCoeControlObserver::EEventStateChanged)) + { +#ifdef _DEBUG + TName msg; + msg.Format(_L("Volume level: %d"), iVolumePopup->Value()); + iEikonEnv->InfoMsgWithAlignment(TGulAlignment(EHCenterVCenter), msg); +#endif + // Save the current volume as previous volume before setting + // new volume level + iPrevVolume=iVolumeLevel; + iVolumeLevel = iVolumePopup->Value(); + SetPresentationVolume( iVolumeLevel ); + } + } + +void CSVGTCustControl::SetPresentationVolume( TInt aVolumeLevel ) + { + TInt volumeInPercent = aVolumeLevel * 10; + + if(volumeInPercent) + { + + iSvgModule->SetAudioVolume(volumeInPercent); + if(iIsVolumeMuted) + { + iIsVolumeMuted = EFalse; + if(iAudioMuteListener) + { + iAudioMuteListener->VolumeMuted(EFalse); + } + + } + } + + else + { + iSvgModule->MuteAudioVolume(); + if(!iIsVolumeMuted) + { + iIsVolumeMuted = ETrue; + if(iAudioMuteListener) + { + iAudioMuteListener->VolumeMuted(ETrue); + } + + } + + } + + } + +TInt CSVGTCustControl::PresentationVolume() const + { + return iVolumeLevel; + } + +void CSVGTCustControl::MrccatoCommand(TRemConCoreApiOperationId aOperationId, + TRemConCoreApiButtonAction aButtonAct ) + { + switch(aOperationId) + { + case ERemConCoreApiVolumeUp: + { + switch (aButtonAct) + { + case ERemConCoreApiButtonPress: + { + break; + } + case ERemConCoreApiButtonRelease: + { + break; + } + case ERemConCoreApiButtonClick: + { + FilterAndSendCommand(EStdKeyIncVolume); + break; + } + default: + { + break; + } + } + break; + } + case ERemConCoreApiVolumeDown: + { + switch (aButtonAct) + { + case ERemConCoreApiButtonPress: + { + break; + } + case ERemConCoreApiButtonRelease: + { + break; + } + case ERemConCoreApiButtonClick: + { + FilterAndSendCommand(EStdKeyDecVolume); + break; + } + default: + { + break; + } + } + break; + } + default: + { + break; + } + } + } + +void CSVGTCustControl::FilterAndSendCommand(TInt aCommandId) + { + TInt currentVolume = iVolumeLevel; + + if(!iIsForeground) + { + return; + } + + switch(aCommandId) + { + case EStdKeyIncVolume: + currentVolume=(currentVolume< KMaxVolume)? ++currentVolume : KMaxVolume; + break; + case EStdKeyDecVolume: + currentVolume=(currentVolume> KMinVolume)? --currentVolume : KMinVolume; + break; + default: + break; + } + + iVolumePopup->SetValue( currentVolume ); + TRAP_IGNORE(iVolumePopup->ShowVolumePopupL()); + iVolumePopup->DrawNow(); + + TRAP_IGNORE(HandleControlEventL( iVolumePopup, MCoeControlObserver::EEventStateChanged )); +} + +EXPORT_C void CSVGTCustControl::AddListener(MSvgCustControlListener *aListener, TCustControlListener aType) + { + if(aType == EAudioListener) + { + iAudioMuteListener = (MSvgAudioMuteListener *)aListener; + } + + } +TInt CSVGTCustControl::GetPrevVolume() const + { + return iPrevVolume; + } +#endif //RD_SVGT_AUDIO_SUPPORT + +//TOUCH SUPPORT END + +// End of File