/*
* Copyright (c) 2003-2006 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: SmilDefaultRenderer implementation
*
*/
// INCLUDE FILES
#include <smilregioninterface.h>
#include <data_caging_path_literals.hrh>
#include <gulicon.h>
#include <AknsUtils.h>
#include <AknsConstants.h>
#include "SmilDefaultRenderer.h"
#include <uniutils.mbg>
_LIT( KUniUtilsBitmapFile, "uniutils.mbm" );
#ifdef DEFAULT_DEBUG
#include "SmilMediaLogging.h"
#endif
// LOCAL FUNCTION PROTOTYPES
// LOCAL CONSTANTS
// ==================== LOCAL FUNCTIONS ====================
// ================= MEMBER FUNCTIONS =======================
// ---------------------------------------------------------
// CSmilDefaultRenderer::CSmilDefaultRenderer
// C++ constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------
CSmilDefaultRenderer::CSmilDefaultRenderer( MSmilMedia* aMedia,
DRMCommon& aDrmCommon,
CDRMHelper& aDrmHelper ) :
CSmilMediaRendererBase( EMsgMediaUnknown, aMedia, aDrmCommon, aDrmHelper )
{
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::ConstructL
// Symbian 2nd phase constructor can leave. Retrieves the correct
// icon for this media type depending on the situation. If correct
// mediatype is not detected then blank default renderer is created.
// Icon size is retrived from LAF if scalable LAF is present.
// Current icon size & position is defined on MMS LAF but we
// only use the size so we can use that value.Icon is drawn
// on its original size or scaled so that aspect ratio is kept
// and icon is shown as large as possible.
// ---------------------------------------------------------
void CSmilDefaultRenderer::ConstructL( RFile& aFileHandle,
TBool aDRMError,
TMsgMediaType aMediaType )
{
#ifdef DEFAULT_DEBUG
SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" );
SMILUILOGGER_ENTERFN( "[SMILUI] Default: ConstructL" );
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: aDRMError=%d"), aDRMError );
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: aMediaType=%d"), aMediaType );
#endif
BaseConstructL( aFileHandle );
TParse fileParse;
fileParse.Set( KUniUtilsBitmapFile, &KDC_APP_BITMAP_DIR, NULL );
TAknsItemID itemID( KAknsIIDNone );
TInt bitmapIndex( -1 );
TInt maskIndex( 0 );
TBool sendingAllowed( ETrue );
if ( aDRMError )
{
sendingAllowed = SendingDrmFileAllowedL( aFileHandle );
}
switch ( aMediaType )
{
case EMsgMediaImage:
{
if ( aDRMError )
{
if ( sendingAllowed )
{
itemID = KAknsIIDQgnGrafMmsImageDrm;
bitmapIndex = EMbmUniutilsQgn_graf_mms_image_drm;
maskIndex = EMbmUniutilsQgn_graf_mms_image_drm_mask;
}
else
{
itemID = KAknsIIDQgnGrafMmsImageDrmInvalidSendForbid;
bitmapIndex = EMbmUniutilsQgn_graf_mms_image_drm_invalid_send_forbid;
maskIndex = EMbmUniutilsQgn_graf_mms_image_drm_invalid_send_forbid_mask;
}
}
else
{
itemID = KAknsIIDQgnGrafMmsImageCorrupted;
bitmapIndex = EMbmUniutilsQgn_graf_mms_image_corrupted;
maskIndex = EMbmUniutilsQgn_graf_mms_image_corrupted_mask;
}
break;
}
case EMsgMediaVideo:
{
if ( aDRMError )
{
if ( sendingAllowed )
{
itemID = KAknsIIDQgnGrafMmsVideoDrm;
bitmapIndex = EMbmUniutilsQgn_graf_mms_video_drm;
maskIndex = EMbmUniutilsQgn_graf_mms_video_drm_mask;
}
else
{
itemID = KAknsIIDQgnGrafMmsVideoDrmInvalidSendForbid;
bitmapIndex = EMbmUniutilsQgn_graf_mms_video_drm_invalid_send_forbid;
maskIndex = EMbmUniutilsQgn_graf_mms_video_drm_invalid_send_forbid_mask;
}
}
else
{
itemID = KAknsIIDQgnGrafMmsVideoCorrupted;
bitmapIndex = EMbmUniutilsQgn_graf_mms_video_corrupted;
maskIndex = EMbmUniutilsQgn_graf_mms_video_corrupted_mask;
}
break;
}
case EMsgMediaSvg:
{
if ( aDRMError )
{
if ( sendingAllowed )
{
itemID = KAknsIIDQgnGrafMmsPresDrmInvalidSend;
bitmapIndex = EMbmUniutilsQgn_graf_mms_pres_drm_invalid_send;
maskIndex = EMbmUniutilsQgn_graf_mms_pres_drm_invalid_send_mask;
}
else
{
itemID = KAknsIIDQgnGrafMmsPresDrmInvalidSendForbid;
bitmapIndex = EMbmUniutilsQgn_graf_mms_pres_drm_invalid_send_forbid;
maskIndex = EMbmUniutilsQgn_graf_mms_pres_drm_invalid_send_forbid_mask;
}
}
else
{
itemID = KAknsIIDQgnGrafMmsPresCorrupted;
bitmapIndex = EMbmUniutilsQgn_graf_mms_pres_corrupted;
maskIndex = EMbmUniutilsQgn_graf_mms_pres_corrupted_mask;
}
break;
}
default:
{
break;
}
}
if ( bitmapIndex != -1 )
{
TSize regionSize( iMedia->GetRectangle().Size() );
#ifdef DEFAULT_DEBUG
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: regionSize=%d %d"), regionSize.iWidth, regionSize.iHeight );
#endif
iIcon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(),
itemID,
fileParse.FullName(),
bitmapIndex,
maskIndex );
TSize originalSize( RetrieveIconSize() );
TSize iconSize;
if ( originalSize.iHeight > regionSize.iHeight ||
originalSize.iWidth > regionSize.iWidth )
{
iconSize = CalculateIconFitSize( regionSize, originalSize );
}
else
{
iconSize = originalSize;
}
iIconRect.SetRect( CalculateIconCenterPosition( regionSize, iconSize ), iconSize );
#ifdef DEFAULT_DEBUG
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: iIconRect=%d %d"),
iIconRect.Size().iWidth,
iIconRect.Size().iHeight );
#endif
User::LeaveIfError( AknIconUtils::SetSize( iIcon->Bitmap(), iIconRect.Size() ) );
}
#ifdef DEFAULT_DEBUG
SMILUILOGGER_LEAVEFN( "[SMILUI] Default: ConstructL" );
#endif
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::NewL
// Static constructor.
// ---------------------------------------------------------
CSmilDefaultRenderer* CSmilDefaultRenderer::NewL( RFile& aFileHandle,
MSmilMedia* aMedia,
DRMCommon& aDrmCommon,
CDRMHelper& aDrmHelper,
TMsgMediaType aMediaType,
TBool aDRMError )
{
CSmilDefaultRenderer* self = new(ELeave) CSmilDefaultRenderer( aMedia,
aDrmCommon,
aDrmHelper );
CleanupStack::PushL( self );
self->ConstructL( aFileHandle, aDRMError, aMediaType );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::~CSmilDefaultRenderer
// Destructor
// ---------------------------------------------------------
CSmilDefaultRenderer::~CSmilDefaultRenderer()
{
delete iIcon;
// Not owned
iMedia = NULL; //For LINT
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::IsVisual
// Default icon is visual (i.e. draws something to the screen.
// (other items were commented in a header).
// ---------------------------------------------------------
//
TBool CSmilDefaultRenderer::IsVisual() const
{
return ETrue;
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::IntrinsicWidth
// (other items were commented in a header).
// ---------------------------------------------------------
//
TInt CSmilDefaultRenderer::IntrinsicWidth() const
{
return iMedia->GetRectangle().Size().iWidth;
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::IntrinsicHeight
// (other items were commented in a header).
// ---------------------------------------------------------
//
TInt CSmilDefaultRenderer::IntrinsicHeight() const
{
return iMedia->GetRectangle().Size().iHeight;
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::IntrinsicDuration
// Returns zero as default icon is static.
// (other items were commented in a header).
// ---------------------------------------------------------
//
TSmilTime CSmilDefaultRenderer::IntrinsicDuration() const
{
return 0;
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::Draw
// Performs the drawing of the icon to specific place and size.
// Transition effects are not supported with default renderer.
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::Draw( CGraphicsContext& aGc,
const TRect& /*aRect*/,
CSmilTransitionFilter* /*aTransitionFilter*/,
const MSmilFocus* aFocus )
{
#ifdef DEFAULT_DEBUG
SMILUILOGGER_ENTERFN( "[SMILUI] Default: Draw" );
#endif
if ( iVisible )
{
if ( iIcon )
{
//Top left corner of bitmap should be in this coordinate
TPoint tlc( iMedia->GetRectangle().iTl );
tlc += iIconRect.iTl;
// Source rectangle.
TRect sourceRect( TPoint( 0, 0 ), iIconRect.Size() );
// Cast graphics context to CFbsBitGc
CBitmapContext* tmpBitmapContext = static_cast<CBitmapContext*>( &aGc );
#ifdef DEFAULT_DEBUG
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: tlc=%d %d"),
tlc.iX,
tlc.iY );
SMILUILOGGER_WRITEF( _L("[SMILUI] Default: sourceRect=%d %d %d %d"),
sourceRect.iTl.iX,
sourceRect.iTl.iY,
sourceRect.iBr.iX,
sourceRect.iBr.iY );
#endif
if ( iIcon->Mask() )
{
tmpBitmapContext->BitBltMasked( tlc,
iIcon->Bitmap(),
sourceRect,
iIcon->Mask(),
EFalse );
}
else
{
tmpBitmapContext->BitBlt( tlc,
iIcon->Bitmap(),
sourceRect );
}
}
DrawFocus( aGc, aFocus );
}
#ifdef DEFAULT_DEBUG
SMILUILOGGER_LEAVEFN( "[SMILUI] Default: Draw" );
#endif
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::PrepareMediaL
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::PrepareMediaL()
{
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::SeekMediaL
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::SeekMediaL( const TSmilTime& /*aTime*/ )
{
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::ShowMediaL
// Sets renderer visible and draws it to the screen.
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::ShowMediaL()
{
#ifdef DEFAULT_DEBUG
SMILUILOGGER_ENTERFN( "[SMILUI] Default: ShowMediaL" );
#endif
if ( !iVisible )
{
iVisible = ETrue;
iMedia->Redraw();
}
#ifdef DEFAULT_DEBUG
SMILUILOGGER_LEAVEFN( "[SMILUI] Default: ShowMediaL" );
#endif
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::HideMedia
// Hides the renderer and redraws the occupied area.
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::HideMedia()
{
#ifdef DEFAULT_DEBUG
SMILUILOGGER_ENTERFN( "[SMILUI] Default: HideMedia" );
#endif
if ( iVisible )
{
iVisible = EFalse;
iMedia->Redraw();
}
#ifdef DEFAULT_DEBUG
SMILUILOGGER_LEAVEFN( "[SMILUI] Default: HideMedia" );
#endif
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::FreezeMedia
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::FreezeMedia()
{
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::ResumeMedia
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::ResumeMedia()
{
}
// ---------------------------------------------------------
// CSmilDefaultRenderer::Close
// Deletes the renderer.
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CSmilDefaultRenderer::Close()
{
delete this;
}
// ----------------------------------------------------------------------------
// CSmilDefaultRenderer::CalculateIconFitSize
// Calculates correct icon size so that icon aspect ratio is preserved
// and it is shown fully on region as large as possible).
// ----------------------------------------------------------------------------
//
TSize CSmilDefaultRenderer::CalculateIconFitSize( const TSize& aRegion,
const TSize& aIcon ) const
{
TSize result;
if ( aIcon.iWidth != 0 &&
aIcon.iHeight != 0 )
{
TInt targetWidth = aRegion.iWidth;
TInt scaledWidth = aRegion.iHeight * aIcon.iWidth / aIcon.iHeight;
if ( targetWidth < scaledWidth )
{
result.iWidth = aRegion.iWidth;
result.iHeight = aIcon.iHeight * aRegion.iWidth / aIcon.iWidth;
}
else
{
result.iWidth = aIcon.iWidth * aRegion.iHeight / aIcon.iHeight;
result.iHeight = aRegion.iHeight;
}
}
return result;
}
// ----------------------------------------------------------------------------
// CSmilDefaultRenderer::CalculateIconCenterPosition
// Calculates correct icon position inside overall renderer region so that
// icon is centeralized according height and width.
// ----------------------------------------------------------------------------
//
TPoint CSmilDefaultRenderer::CalculateIconCenterPosition( const TSize& aRegion,
const TSize& aIcon ) const
{
return TPoint( ( aRegion.iWidth - aIcon.iWidth ) / 2,
( aRegion.iHeight - aIcon.iHeight ) / 2 );
}
// End of File