/*
* Copyright (c) 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 a control which displays svg files using
* renderframes engine api, used by Screen Saver application
*
*/
#include <eikenv.h>
#include <eikappui.h>
#include <gdi.h>
#include <AknUtils.h>
#include <SVGEngineInterfaceImpl.h>
#include <SVGTUIDialog.hrh>
#include <SVGTAppObserver.h>
#include <flogger.h>
#include "SvgRenderFrameControl.h"
#include "SvgRenderFrameTimer.h"
const TUint KConvertToMicroSecond = 1000;
const TInt KMilliSecondsBetweenFrame = 50;
// 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 KIndefiniteDur = 0xffffffff;
#ifdef _DEBUG
_LIT( KFileLoggingDir, "ScreenSaver" );
_LIT( KFileLog, "FromSvgPlugin.txt" );
#endif
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::NewL
// -----------------------------------------------------------------------------
//
CSvgRenderFrameControl* CSvgRenderFrameControl::NewL(
const CCoeControl* aParent,
RFile& aFileHandle ,
MSvgtAppObserver* aObserver )
{
CSvgRenderFrameControl* self = CSvgRenderFrameControl::NewLC( aParent,
aFileHandle,
aObserver );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::NewL
// -----------------------------------------------------------------------------
//
CSvgRenderFrameControl* CSvgRenderFrameControl::NewLC(
const CCoeControl* aParent,
RFile& aFileHandle ,
MSvgtAppObserver* aObserver )
{
CSvgRenderFrameControl* self = new (ELeave) CSvgRenderFrameControl(
aFileHandle, aObserver );
CleanupStack::PushL( self );
self->ConstructL( aParent );
return self;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::~CSvgRenderFrameControl
// -----------------------------------------------------------------------------
//
CSvgRenderFrameControl::~CSvgRenderFrameControl()
{
DeleteEngine();
delete iBmap;
delete iRenderFrameTimer;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::SizeChanged
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::SizeChanged()
{
iRect = iParent->Rect();
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::UpdateScreen
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::UpdateScreen()
{
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::ScriptCall
// -----------------------------------------------------------------------------
//
TBool CSvgRenderFrameControl::ScriptCall( const TDesC& /*aScript*/,
CSvgElementImpl* /*aCallerElement*/ )
{
return ETrue;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::FetchImage
// -----------------------------------------------------------------------------
//
TInt CSvgRenderFrameControl::FetchImage( const TDesC& aUri, RFs& aSession,
RFile& aFileHandle )
{
if ( iAppObserver )
{
return iAppObserver->FetchImage( aUri, aSession, aFileHandle );
}
else
{
return KErrNotFound;
}
}
TInt CSvgRenderFrameControl::FetchFont( const TDesC& /* aUri */,
RFs& /* aSession */, RFile& /* aFileHandle */ )
{
return KErrNotSupported;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::GetSmilFitValue
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::GetSmilFitValue(TDes& /*aSmilValue*/)
{
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::UpdatePresentation
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::UpdatePresentation( const TInt32&
/*aNoOfAnimation*/ )
{
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::Draw
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::Draw(const TRect& /*aRect*/) const
{
// Calculate rectangle for the whole bitmap
TRect bmpPieceRect(TPoint(0,0), iRect.Size() );
// Get the standard graphics context
CWindowGc& gc = SystemGc();
gc.SetBrushColor(CGraphicsContext::ENullBrush );
gc.SetPenColor( CGraphicsContext::ENullPen );
gc.BitBlt( TPoint(0,0),iBitmapFrames[iCurrentFrame],
bmpPieceRect );
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::SetTimer
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::SetTimer()
{
if ( !iRenderFrameTimer )
{
TRAP_IGNORE( iRenderFrameTimer =
CSvgRenderFrameTimer::NewL( this ) );
}
if ( iCanPlay )
{
// Since the number of delay intervals is one less than
// the number of bitmaps need to have a bound check
iRenderFrameTimer->SetTimeOut( iDelayIntervals[
iCurrentFrame >= iDelayIntervals.Count() ? 0 : iCurrentFrame]
* KConvertToMicroSecond );
}
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::CancelTimer
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::CancelTimer()
{
if (iRenderFrameTimer)
{
iRenderFrameTimer->Cancel();
delete iRenderFrameTimer;
iRenderFrameTimer = NULL;
}
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::ProcessViewerCommandL
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::ProcessViewerCommandL( TInt aCommandId )
{
if ( aCommandId == ESvgtDlgPlayCommand )
{
_LIT(msg1, "start event " );
PrintDebugMsg( msg1 );
iCanPlay = ETrue;
SetTimer();
}
if ( aCommandId == ESvgtDlgPauseCommand )
{
_LIT(msg1, "end event " );
PrintDebugMsg( msg1 );
iCanPlay = EFalse;
CancelTimer();
}
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::GetCurrentIndex
// -----------------------------------------------------------------------------
//
TInt CSvgRenderFrameControl::GetCurrentIndex() const
{
return iCurrentFrame;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::SetCurrentIndex
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::SetCurrentIndex( TInt aIndex )
{
iCurrentFrame = aIndex;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::AnimationTimeOut
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::AnimationTimeOut()
{
DrawNow();
SetTimer();
MoveIndex();
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::InitializeEngineL
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::InitializeEngineL( TBool aCheckFile,
MSvgRequestObserver* aObserver )
{
iBmap = new ( ELeave ) CFbsBitmap();
TSize dummyScreenSize( 10,10 );
iBmap->Create( dummyScreenSize, EColor16MU );
if ( !iSvgEngine )
{
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();
iSvgEngine = CSvgEngineInterfaceImpl::NewL( iBmap,
aObserver,
spec );
if ( iSvgEngine && !iSvgDom )
{
if ( aCheckFile )
{
/* Set Thumbnail Mode if check file mode
* so that the rights wont be consumed
*/
iSvgEngine->SetThumbNailMode( ETrue );
}
MSvgError* parseResult = iSvgEngine->PrepareDom( *iFileHandle,
iSvgDom );
if ( aCheckFile )
{
/* Reset Thumbnail Mode */
iSvgEngine->SetThumbNailMode( EFalse );
}
if ( parseResult &&
parseResult->HasError() &&
!parseResult->IsWarning() )
{
if ( parseResult->HasError() == ESvgNoMemory )
{
User::Leave( KErrNoMemory );
}
else
{
User::Leave( KErrGeneral );
}
}
if ( !aCheckFile )
{
MSvgError* pResult = iSvgEngine->UseDom( iSvgDom, iBmap );
if ( pResult->HasError() && !pResult->IsWarning() )
{
User::Leave( KErrGeneral );
}
}
}
else
{
User::Leave( KErrGeneral );
}
}
else
{
User::Leave( KErrGeneral );
}
return;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::DeleteEngine
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::DeleteEngine()
{
for ( TInt i = 0; i < iBitmapFrames.Count(); i++ )
{
delete iBitmapFrames[i];
}
for ( TInt i = 0; i < iMaskFrames.Count(); i++ )
{
delete iMaskFrames[i];
}
iBitmapFrames.Reset();
iMaskFrames.Reset();
iDelayIntervals.Reset();
iBitmapFrames.Close();
iMaskFrames.Close();
iDelayIntervals.Close();
iCurrentFrame = 0;
iDuration = 0;
if ( iSvgDom )
{
iSvgEngine->DeleteDom( iSvgDom );
iSvgDom = 0;
}
delete iSvgEngine;
iSvgEngine = NULL;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::RenderMyFrames
// -----------------------------------------------------------------------------
//
TInt CSvgRenderFrameControl::RenderMyFrames()
{
TUint interval = iSvgEngine->Duration();
if ( interval == KIndefiniteDur || interval > KMaxTimeDuration )
{
// Infinite content
// Dont try to handle using Render Frames
// return Error
return KErrGeneral;
}
MSvgError* result = iSvgEngine->RenderFrames(
iSvgDom,
iRect.Size(),
0,
interval,
KMilliSecondsBetweenFrame,
EColor64K, EGray2,
iBitmapFrames,
iMaskFrames,
iDelayIntervals,
ETrue /*Remove redundant frames*/ );
if ( result->HasError() && !result->IsWarning() )
{
return KErrGeneral;
}
else
{
return KErrNone;
}
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::MoveIndex
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::MoveIndex()
{
TBuf<64> buffer1;
_LIT(msg1, "Index is : %d" );
buffer1.Format( msg1, iCurrentFrame );
PrintDebugMsg( buffer1 );
iCurrentFrame++;
if ( iCurrentFrame == iBitmapFrames.Count() )
{
iCurrentFrame = 0;
}
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::CSvgRenderFrameControl
// -----------------------------------------------------------------------------
//
CSvgRenderFrameControl::CSvgRenderFrameControl( RFile& aFileHandle,
MSvgtAppObserver* aObserver )
{
iCurrentFrame = 0;
iDuration = 0;
iSvgEngine = NULL;
iSvgDom = 0;
iFileHandle = &aFileHandle;
iCanPlay = EFalse;
iParent = NULL;
iAppObserver = aObserver;
}
// -----------------------------------------------------------------------------
// CSvgRenderFrameControl::ConstructL
// -----------------------------------------------------------------------------
//
void CSvgRenderFrameControl::ConstructL( const CCoeControl* aParent )
{
if ( aParent )
{
CreateWindowL(aParent);
iParent = aParent;
iRect = aParent->Rect();
}
InitializeEngineL( EFalse /*Not checkFile mode*/ , this );
User::LeaveIfError(RenderMyFrames());
SetRect( iRect );
ActivateL();
}
// -----------------------------------------------------------------------------
// CScreenSaverAnimPlugin::PrintDebugMsg
// -----------------------------------------------------------------------------
//
#ifndef _DEBUG
void CSvgRenderFrameControl::PrintDebugMsg( const TDesC& /* aMsg */ ) const
#else
void CSvgRenderFrameControl::PrintDebugMsg( const TDesC& aMsg ) const
#endif
{
#ifdef _DEBUG
RFileLogger::Write( KFileLoggingDir, KFileLog,
EFileLoggingModeAppend, aMsg );
#endif
}
// End Of file.