MCL/sf/app/videoplayer: comparison videoplayback/videoplaybackcontrols/src/mpxvideoplaybackmediadetailsviewer.cpp

equal deleted inserted replaced

-:ce5ada96ab30
+:5294c000a26d
 *
 * Description: Media Details Viewer
 *
 */
-// Version : %version:  e003sa33#14 %
+// Version : %version:  e003sa33#16 %
 // INCLUDE FILES
 #include <eikenv.h>
 #include <eiklabel.h>
 const TInt KMediaDetailsViewerOffsetDivisorMax = 20;
 const TInt KMediaDetailsViewerMaxBufLen = 255;
 // UID of this interface
 const TUid KFileDetailsCntlPluginUid = {0x2002A59D};
-const TUid KFileDetailsInterfaceUid = {0x2002A5A0};
-// ---------------------------------------------------------------------------
+const TUint32 KScrollTimerDelayTickCounts = 2000;   // 2000 milliseconds
-// Local function to cleanup an array
+const TUint32 KInvalidTick = 0;
-// ---------------------------------------------------------------------------
-//
-static void CleanupEcomArray( TAny* aArray )
-{
-( static_cast<RImplInfoPtrArray*>( aArray ) )->ResetAndDestroy();
-( static_cast<RImplInfoPtrArray*>( aArray ) )->Close();
-}
 // ============================ MEMBER FUNCTIONS ===================================================
 CMPXVideoPlaybackMediaDetailsViewer::CMPXVideoPlaybackMediaDetailsViewer(
 CMPXVideoPlaybackControlsController* aController )
 : iController( aController )
+, iScrollTimerDelayBeginningTick( KInvalidTick )
 {
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::ConstructL()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::ConstructL()
 {
 MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::ConstructL()"));
 iViewerRect = CalculateViewerRectL();
 SetRect( TRect(0, 0, iViewerRect.Width(), iViewerRect.Height()) );
 CreateLabelsL();
 SkinChangeL();
 iBackgroundBitmap = new ( ELeave ) CFbsBitmap();
 TSize bitmapSize = Rect().Size();
 User::LeaveIfError( iBackgroundBitmap->Create( bitmapSize, EColor16MA ) );
 iScrollPosition = 0;
 iScrollingTextTimer = CPeriodic::NewL( CActive::EPriorityStandard );
 iScrollingTextTimer->Start(
 0,
 175000,
 TCallBack( CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer, this ) );
 iShouldPauseScrolling = EFalse;
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::NewL()
 // Two-phased constructor.
 // -------------------------------------------------------------------------------------------------
 //
 CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()
 {
 MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()"));
 if ( iClipnameLabel )
 {
 delete iClipnameLabel;
 iClipnameLabel = NULL;
 }
 if ( iTitleLabel )
 {
 delete iTitleLabel;
 iTitleLabel = NULL;
 }
 if ( iArtistLabel )
 {
 delete iArtistLabel;
 iArtistLabel = NULL;
 }
 if ( iFormatLabel )
 {
 delete iFormatLabel;
 iFormatLabel = NULL;
 }
 if ( iResolutionLabel )
 {
 delete iResolutionLabel;
 iResolutionLabel = NULL;
 }
 if ( iDurationLabel )
 {
 delete iDurationLabel;
 iDurationLabel = NULL;
 }
 if ( iBitrateLabel )
 {
 delete iBitrateLabel;
 iBitrateLabel = NULL;
 }
 if ( iLicenseLabel )
 {
 delete iLicenseLabel;
 iLicenseLabel = NULL;
 }
 if ( iBackgroundBitmap )
 {
 delete iBackgroundBitmap;
 iBackgroundBitmap = NULL;
 }
 if ( iScrollingTextTimer )
 {
 iScrollingTextTimer->Cancel();
 delete iScrollingTextTimer;
 iScrollingTextTimer = NULL;
 }
 if ( iAdditionalLabel )
 {
 delete iAdditionalLabel;
 iAdditionalLabel = NULL;
 }
 if ( iAdditionalString )
 {
 delete iAdditionalString;
 iAdditionalString = NULL;
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL()
 // -------------------------------------------------------------------------------------------------
 break;
 }
 case TPointerEvent::EButton1Up:
 {
 TRect expandedRect;  //make it a bit easier to click the License label
 if ( iLicenseLabel )
 {
 expandedRect = TRect(iLicenseLabel->Rect().iTl,
 TPoint(iLicenseLabel->Rect().iBr.iX,
 iLicenseLabel->Rect().iBr.iY * 2 ) );
 }
 if ( iLicenseLabel && expandedRect.Contains(aPointerEvent.iPosition) )
 {
 LaunchDRMDetailsL();
 }
 else
 {
 iController->HandleEventL( EMPXControlCmdCloseFileDetailsViewer );
 }
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::LaunchDRMDetailsL()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::LaunchDRMDetailsL()
 {
 iController->iContainer->HandleCommandL(EMPXPbvLaunchDRMDetails);
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()
 {
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackMediaDetailsViewer::Draw()
 // -------------------------------------------------------------------------------------------------
 //
 {
 MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::Draw()"));
 CWindowGc& gc = SystemGc();
 gc.SetClippingRect( aRect );
 this->DrawableWindow()->SetCornerType(EWindowCorner5);
 TRAP_IGNORE( UpdateBackgroundBitmapL() );
 gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );
 gc.BitBlt( Rect().iTl, iBackgroundBitmap );
 TRAP_IGNORE( FormatLabelsL() );
 gc.SetBrushStyle( CGraphicsContext::ENullBrush );
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::FormatLabelsL()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::FormatLabelsL() const
 {
 // FORMAT LABELS
 TInt labelWidth = Rect().iBr.iX;
 TInt labelHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems;
 TInt rowsAdded = 0;
 // License
 if ( iController->FileDetails()->iDrmProtected )
 {
 iLicenseLabel->SetExtent(
-		             TPoint(Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
+TPoint(Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_LICENSE_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> licenseField;
 licenseField.Append(KLeftMargin);
 licenseField.Append( *heading );
 iLicenseLabel->OverrideColorL(EColorLabelText, KRgbDarkBlue);
 iLicenseLabel->SetTextL(licenseField);
 iLicenseLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iLicenseLabel->SetLabelAlignment(ELayoutAlignCenter);
 iLicenseLabel->SetUnderlining(ETrue);
 iLicenseLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( heading );
 }
 // Filename
 HBufC* fileName = iController->FileDetails()->GenerateFileNameL();
 if ( fileName && fileName->Length() )
 {
 // file name gets populated by HandleScrollFilenameTimer method
 iClipnameLabel->SetExtent(
-		             TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 iClipnameLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iClipnameLabel->MakeVisible( ETrue );
 rowsAdded++;
 delete fileName;
 }
 // Mime Type (Format)
-if ( iController->FileDetails()->iMimeType
+if ( iController->FileDetails()->iMimeType && iController->FileDetails()->iMimeType->Length() )
-		&& iController->FileDetails()->iMimeType->Length() )
+{
-{
+iFormatLabel->SetExtent(
-iFormatLabel->SetExtent(
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
-		          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FORMAT_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> formatField;
 formatField.Append(KLeftMargin);
 formatField.Append( *heading );
 formatField.Append( KHeadingValueSeperator );
 TInt allowLen = KMediaDetailsViewerMaxBufLen-formatField.Length();
 formatField.Append( (iController->FileDetails()->iMimeType)->Left(allowLen) );
 iFormatLabel->SetTextL(formatField);
 iFormatLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iFormatLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( heading );
 }
 // Resolution
-if ( iController->FileDetails()->iVideoHeight &&
+if ( iController->FileDetails()->iVideoHeight &&  iController->FileDetails()->iVideoWidth )
-iController->FileDetails()->iVideoWidth )
+{
-{
+iResolutionLabel->SetExtent(
-iResolutionLabel->SetExtent(
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
-		               TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_RESOLUTION_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> resolutionField;
 resolutionField.Append(KLeftMargin);
 resolutionField.Append( *heading );
 resolutionField.Append( KHeadingValueSeperator );
 resolutionField.AppendNum( iController->FileDetails()->iVideoWidth );
 resolutionField.Append( KWidthHeightSeparator );
 resolutionField.AppendNum( iController->FileDetails()->iVideoHeight);
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( resolutionField );
 iResolutionLabel->SetTextL(resolutionField);
 iResolutionLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iResolutionLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( heading );
 }
 // Duration
 if ( iController->FileDetails()->iDuration > 0 )
 {
 iDurationLabel->SetExtent(
-		             TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_DURATION_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> durationField;
 durationField.Append(KLeftMargin);
 durationField.Append( *heading );
 durationField.Append( KHeadingValueSeperator );
 TInt64 durationInSeconds =  iController->FileDetails()->iDuration / 1000;
 HBufC* unitFormatString;
 if ( durationInSeconds < 3600 )  // one hour
 {
 unitFormatString = StringLoader::LoadLC(R_QTN_TIME_DURAT_MIN_SEC);
 }
 else
 {
 unitFormatString = StringLoader::LoadLC(R_QTN_TIME_DURAT_LONG);
 }
 TBuf<64> dur;
 TTime durTime = TTime(durationInSeconds * 1000000);
 durTime.FormatL(dur, *unitFormatString);
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( dur );
 durationField.Append( dur );
 iDurationLabel->SetTextL(durationField);
 iDurationLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iDurationLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( unitFormatString ); // unitFormatString
 CleanupStack::PopAndDestroy( heading );
+}
-}
 // Bitrate
 if ( iController->FileDetails()->iBitRate > 0 )
 {
 iBitrateLabel->SetExtent(
-		          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_BITRATE_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> bitrateField;
 bitrateField.Append(KLeftMargin);
 bitrateField.Append( *heading );
 bitrateField.Append( KHeadingValueSeperator );
 HBufC* formattedBitrate =
 StringLoader::LoadLC(R_MPX_BITRATE_UNITS,iController->FileDetails()->iBitRate / 1000 );
 bitrateField.Append( *formattedBitrate );
 iBitrateLabel->SetTextL(bitrateField);
 iBitrateLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iBitrateLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( formattedBitrate ); // formattedBitrate
 CleanupStack::PopAndDestroy( heading );
 }
 // Title
-if ( iController->FileDetails()->iTitle
+if ( iController->FileDetails()->iTitle && iController->FileDetails()->iTitle->Length() )
-		&& iController->FileDetails()->iTitle->Length() )
+{
-{
+iTitleLabel->SetExtent(
-iTitleLabel->SetExtent(
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
-		          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
+TSize( labelWidth, labelHeight )
-TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_TITLE_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> titleField;
 titleField.Append(KLeftMargin);
 titleField.Append( *heading );
 titleField.Append( KHeadingValueSeperator );
 TInt allowLen = KMediaDetailsViewerMaxBufLen-titleField.Length();
 titleField.Append( (iController->FileDetails()->iTitle)->Left(allowLen) );
 iTitleLabel->SetTextL(titleField);
 iTitleLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iTitleLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( heading );
 }
 // Artist
-if ( iController->FileDetails()->iArtist
+if ( iController->FileDetails()->iArtist && iController->FileDetails()->iArtist->Length() )
-		&& iController->FileDetails()->iArtist->Length() )
+{
-{
+iArtistLabel->SetExtent(
-iArtistLabel->SetExtent(
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
-		          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_ARTIST_HEADING );
 CleanupStack::PushL( heading );
 TBuf<KMediaDetailsViewerMaxBufLen> artistField;
 artistField.Append(KLeftMargin);
 artistField.Append( *heading );
 artistField.Append( KHeadingValueSeperator );
 TInt allowLen = KMediaDetailsViewerMaxBufLen-artistField.Length();
 artistField.Append( (iController->FileDetails()->iArtist)->Left( allowLen ) );
 iArtistLabel->SetTextL(artistField);
 iArtistLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
 iArtistLabel->MakeVisible( ETrue );
 rowsAdded++;
 CleanupStack::PopAndDestroy( heading );
 }
 // Additional Label
 if ( iAdditionalString && iAdditionalString->Length() )
 {
 iAdditionalLabel->SetExtent(
-		               TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
+TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
 TSize( labelWidth, labelHeight )
 );
 TBuf<KMediaDetailsViewerMaxBufLen> titleField;
 titleField.Append(KLeftMargin);
 TInt allowLen = KMediaDetailsViewerMaxBufLen-titleField.Length();
 titleField.Append( iAdditionalString->Left(allowLen) );
 iAdditionalLabel->SetTextL(titleField);
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::ComponentControl
 // -------------------------------------------------------------------------------------------------
 //
 CCoeControl* CMPXVideoPlaybackMediaDetailsViewer::ComponentControl(TInt aIndex) const
 {
 CCoeControl* control = NULL;
 switch ( aIndex )
 {
 case 0:
 control = iClipnameLabel;
 break;
 control = iAdditionalLabel;
 break;
 default:
 break;
 }
 return control;
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::Reset
 // CMPXVideoPlaybackMediaDetailsViewer::CreateLabelsL
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::CreateLabelsL()
 {
 // Licence / DRM
 iLicenseLabel = new (ELeave) CEikLabel;
 iLicenseLabel->SetContainerWindowL( *this );
 iLicenseLabel->SetTextL( KNullDesC );
 // Filename
 iClipnameLabel = new (ELeave) CEikLabel;
 iClipnameLabel->SetContainerWindowL( *this );
 iClipnameLabel->SetTextL( KNullDesC );
 iClipnameLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Title
 iTitleLabel = new (ELeave) CEikLabel;
 iTitleLabel->SetContainerWindowL( *this );
 iTitleLabel->SetTextL( KNullDesC );
 iTitleLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Artist
 iArtistLabel = new (ELeave) CEikLabel;
 iArtistLabel->SetContainerWindowL( *this );
 iArtistLabel->SetTextL( KNullDesC );
 iArtistLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Format
 iFormatLabel = new (ELeave) CEikLabel;
 iFormatLabel->SetContainerWindowL( *this );
 iFormatLabel->SetTextL( KNullDesC );
 iFormatLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Resolution
 iResolutionLabel = new (ELeave) CEikLabel;
 iResolutionLabel->SetContainerWindowL( *this );
 iResolutionLabel->SetTextL( KNullDesC );
 iResolutionLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Duration
 iDurationLabel = new (ELeave) CEikLabel;
 iDurationLabel->SetContainerWindowL( *this );
 iDurationLabel->SetTextL( KNullDesC );
 iDurationLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Bitrate
 iBitrateLabel = new (ELeave) CEikLabel;
 iBitrateLabel->SetContainerWindowL( *this );
 iBitrateLabel->SetTextL( KNullDesC );
 iBitrateLabel->SetLabelAlignment( ELayoutAlignBidi );
 // Additional Labels
 iAdditionalLabel = new (ELeave) CEikLabel;
 iAdditionalLabel->SetContainerWindowL( *this );
 iAdditionalLabel->SetTextL( KNullDesC );
 iAdditionalLabel->SetLabelAlignment( ELayoutAlignBidi );
+}
-}
 // -----------------------------------------------------------------------------
 // CMPXVideoPlaybackMediaDetailsViewer::UpdateBackgroundBitmapL
 // Update background bitmap
 // -----------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackMediaDetailsViewer::UpdateBackgroundBitmapL() const
 {
 TSize bitmapSize = Rect().Size();
-CFbsBitmapDevice* bgBitmapDevice =
+CFbsBitmapDevice* bgBitmapDevice = CFbsBitmapDevice::NewL( iBackgroundBitmap );
-CFbsBitmapDevice::NewL( iBackgroundBitmap );
 CleanupStack::PushL( bgBitmapDevice );
 CFbsBitGc* bgBitGc( NULL );
 User::LeaveIfError( bgBitmapDevice->CreateContext( bgBitGc ) );
 CleanupStack::PushL( bgBitGc );
 bgBitGc->SetBrushColor( TRgb(0x708090) );  // slate gray
 bgBitGc->Clear();
 CleanupStack::PopAndDestroy( bgBitGc );
 CleanupStack::PopAndDestroy( bgBitmapDevice );
 // Dither alpha channel for semitransparency
 //
 // Scan line length in 32-bit words
 TInt scanLineLengthWord = CFbsBitmap::ScanLineLength( bitmapSize.iWidth, EColor16MA) / 4;
 iBackgroundBitmap->LockHeap();
-TUint32* dataAddr =
+TUint32* dataAddr = reinterpret_cast<TUint32*>( iBackgroundBitmap->DataAddress() );
-reinterpret_cast<TUint32*>( iBackgroundBitmap->DataAddress() );
 for ( TInt y = 0; y < bitmapSize.iHeight; y++ )
+{
+for ( TInt x = 0; x < bitmapSize.iWidth; x++ )
+{
+if ( ( y + x ) & 1 )
 {
-for ( TInt x = 0; x < bitmapSize.iWidth; x++ )
+// Make this pixel transparent
+dataAddr[y * scanLineLengthWord + x] = 0x00000000;
+}
+}
+}
+iBackgroundBitmap->UnlockHeap();
+}
+// -------------------------------------------------------------------------------------------------
+// CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer
+// -------------------------------------------------------------------------------------------------
+//
+TInt CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer( TAny* aPtr )
+{
+TRAP_IGNORE(
+static_cast<CMPXVideoPlaybackMediaDetailsViewer*>(aPtr)->HandleScrollFilenameTimerL()
+);
+return KErrNone;
+}
+// -------------------------------------------------------------------------------------------------
+// CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL
+// -------------------------------------------------------------------------------------------------
+//
+void CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL()
+{
+MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL" ) );
+TBool skipForTimerDelay = EFalse;
+// add a delay after each complete scrolling
+if ( iScrollTimerDelayBeginningTick != KInvalidTick )
+{
+if ( ( User::NTickCount() - iScrollTimerDelayBeginningTick ) >= KScrollTimerDelayTickCounts )
+{
+iScrollTimerDelayBeginningTick = KInvalidTick;
+}
+else
+{
+skipForTimerDelay = ETrue;
+}
+}
+if ( !skipForTimerDelay && iShouldPauseScrolling )
+{
+iShouldPauseScrolling = EFalse;
+iScrollTimerDelayBeginningTick = User::NTickCount();
+skipForTimerDelay = ETrue;
+}
+// skip the scrolling operation if the loop for delay is going on
+if ( !skipForTimerDelay )
+{
+HBufC* fileName = iController->FileDetails()->GenerateFileNameL();
+if ( fileName && fileName->Length() )
+{
+CleanupStack::PushL( fileName );
+TInt length = fileName->Length();
+HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FILENAME_HEADING );
+CleanupStack::PushL( heading );
+TBuf<KMediaDetailsViewerMaxBufLen> filenameField;
+filenameField.Append(KLeftMargin);
+filenameField.Append( *heading );
+filenameField.Append( KHeadingValueSeperator );
+if ( length >= KMediaDetailsViewerVisibleCharacters )
+{
+filenameField.Append( fileName->Mid( iScrollPosition,
+KMediaDetailsViewerVisibleCharacters ) );
+if ( iScrollPosition ==  (length - KMediaDetailsViewerVisibleCharacters) )
 {
-if ( ( y + x ) & 1 )
+iScrollPosition = 0;
-{
+iShouldPauseScrolling = ETrue;
-// Make this pixel transparent
-dataAddr[y * scanLineLengthWord + x] = 0x00000000;
-}
 }
-}
+else
+{
-iBackgroundBitmap->UnlockHeap();
+iScrollPosition++;
 }
-// -------------------------------------------------------------------------------------------------
-// CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer
-// -------------------------------------------------------------------------------------------------
-//
-TInt CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer( TAny* aPtr )
-{
-	TRAP_IGNORE(
-			static_cast<CMPXVideoPlaybackMediaDetailsViewer*>(aPtr)->HandleScrollFilenameTimerL()
-			);
-return KErrNone;
-}
-// -------------------------------------------------------------------------------------------------
-// CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL
-// -------------------------------------------------------------------------------------------------
-//
-void CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL()
-{
-HBufC* fileName = iController->FileDetails()->GenerateFileNameL();
-	if ( fileName && fileName->Length() )
-{
-CleanupStack::PushL( fileName );
-if ( iShouldPauseScrolling )
-{
-iShouldPauseScrolling = EFalse;
-User::After( 2000000 );  // add a 2 second delay after each complete scrolling
-}
-TInt length = fileName->Length();
-HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FILENAME_HEADING );
-CleanupStack::PushL( heading );
-TBuf<KMediaDetailsViewerMaxBufLen> filenameField;
-filenameField.Append(KLeftMargin);
-filenameField.Append( *heading );
-filenameField.Append( KHeadingValueSeperator );
-if ( length >= KMediaDetailsViewerVisibleCharacters )
-{
-filenameField.Append( fileName->Mid( iScrollPosition,
-		KMediaDetailsViewerVisibleCharacters ) );
-if ( iScrollPosition ==  (length - KMediaDetailsViewerVisibleCharacters) )
-{
-iScrollPosition = 0;
-iShouldPauseScrolling = ETrue;
 }
 else
 {
-iScrollPosition++;
+filenameField.Append( *fileName );
+iScrollingTextTimer->Cancel();   // no need to keep the timer active
 }
+iClipnameLabel->SetTextL(filenameField);
+DrawNow();
+CleanupStack::PopAndDestroy( heading );
+CleanupStack::PopAndDestroy( fileName );
 }
-else
+}
-{
-filenameField.Append( *fileName );
-iScrollingTextTimer->Cancel();   // no need to keep the timer active
-}
-iClipnameLabel->SetTextL(filenameField);
-DrawNow();
-CleanupStack::PopAndDestroy( heading );
-CleanupStack::PopAndDestroy( fileName );
-}
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewer
 // -------------------------------------------------------------------------------------------------
 //
 TInt CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewerL()
 {
 TInt numOfItems = 0;
 if ( iController->FileDetails()->iDrmProtected )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iClipName )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iMimeType )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iVideoHeight &&
 iController->FileDetails()->iVideoWidth )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iDuration > 0 )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iBitRate > 0 )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iTitle )
 {
 numOfItems++;
 }
 if ( iController->FileDetails()->iArtist )
 {
 numOfItems++;
 }
 // Additional File Details
 CMPXFileDetailsPlugin* addPlugin( NULL );
 // Use the interface to load the ecom plugin
 TRAPD ( err, addPlugin = CMPXFileDetailsPlugin::NewL( KFileDetailsCntlPluginUid ) );
 // If plugin loaded successfully
-if (!err )
+if ( ! err )
 {
 TPtrC addLabel;
 addLabel.Set( addPlugin->GetAdditionalLabelLC( iController->FileDetails()->iFourCCCode ) );
 iAdditionalString = addLabel.AllocL();
 if ( iAdditionalString->Length() )
 {
 numOfItems++;
 }
 CleanupStack::PopAndDestroy();  // addLabel
 }
 delete addPlugin;
 return numOfItems;
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRect
 // -------------------------------------------------------------------------------------------------
 //
 TRect CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRectL()
 {
 TInt numOfItems = NumOfItemsShownInViewerL();
 TRect viewerRect;
 // optimize viewer's width for the clipname
 TInt horizontalOffset = 0;
 TInt filenameLength = iController->FileDetails()->iClipName->Des().Length();
-if ( filenameLength <= KMediaDetailsViewerFilenameMedium  )
+if ( filenameLength <= KMediaDetailsViewerFilenameMedium )
 {
 horizontalOffset =
 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMedium;
 }
 else
 {
 horizontalOffset =
 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMax;
 }
-TInt eachItemHeight =
+TInt eachItemHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems;
-iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems;
+TInt verticalHalf = iController->iContainer->Rect().iBr.iY / 2;
-TInt verticalHalf = iController->iContainer->Rect().iBr.iY / 2;
 TInt tLX = (iController->iContainer->Rect().iTl.iX) + horizontalOffset;
 TInt bRX = (iController->iContainer->Rect().iBr.iX) - horizontalOffset;
 TInt tLY = verticalHalf - ( eachItemHeight * numOfItems/2 );
 // pad for the margins on top and bottom of viewer
-TInt bRY = verticalHalf + ( eachItemHeight * numOfItems/2 ) + (KMediaDetailsViewerItemMargin * 2);
+TInt bRY =
+verticalHalf + ( eachItemHeight * numOfItems/2 ) + ( KMediaDetailsViewerItemMargin * 2 );
 viewerRect = TRect( tLX, tLY, bRX, bRY );
 return viewerRect;
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackMediaDetailsViewer::ViewerRect
 {
 return iViewerRect;
 }
 //  End of File

branch	RCL_3
changeset 9	5294c000a26d
parent 8	ce5ada96ab30
child 11	8970fbd719ec