297 ); |
293 ); |
298 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_LICENSE_HEADING ); |
294 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_LICENSE_HEADING ); |
299 CleanupStack::PushL( heading ); |
295 CleanupStack::PushL( heading ); |
300 |
296 |
301 TBuf<KMediaDetailsViewerMaxBufLen> licenseField; |
297 TBuf<KMediaDetailsViewerMaxBufLen> licenseField; |
302 licenseField.Append(KLeftMargin); |
298 licenseField.Append( KLeftMargin ); |
303 licenseField.Append( *heading ); |
299 licenseField.Append( *heading ); |
304 iLicenseLabel->OverrideColorL(EColorLabelText, KRgbDarkBlue); |
300 iLicenseLabel->OverrideColorL( EColorLabelText, KRgbDarkBlue ); |
305 iLicenseLabel->SetTextL(licenseField); |
301 iLicenseLabel->SetTextL( licenseField ); |
306 iLicenseLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin); |
302 iLicenseLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin ); |
307 iLicenseLabel->SetLabelAlignment(ELayoutAlignCenter); |
303 iLicenseLabel->SetLabelAlignment( ELayoutAlignCenter ); |
308 iLicenseLabel->SetUnderlining(ETrue); |
304 iLicenseLabel->SetUnderlining( ETrue ); |
309 iLicenseLabel->MakeVisible( ETrue ); |
305 iLicenseLabel->MakeVisible( ETrue ); |
310 rowsAdded++; |
306 rowsAdded++; |
311 |
307 |
312 CleanupStack::PopAndDestroy( heading ); |
308 CleanupStack::PopAndDestroy( heading ); |
313 } |
309 } |
|
310 |
|
311 // Title |
|
312 HBufC* fileTitle = iController->FileDetails()->GenerateFileTitleL(); |
|
313 |
|
314 if ( fileTitle && fileTitle->Length() ) |
|
315 { |
|
316 // Title gets populated by UpdateTitle method |
|
317 iTitleLabel->SetExtent( |
|
318 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
|
319 TSize( labelWidth, labelHeight ) |
|
320 ); |
|
321 iTitleLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin ); |
|
322 iTitleLabel->MakeVisible( ETrue ); |
|
323 rowsAdded++; |
|
324 } |
|
325 |
|
326 delete fileTitle; |
314 |
327 |
315 // Filename |
328 // Filename |
316 HBufC* fileName = iController->FileDetails()->GenerateFileNameL(); |
329 HBufC* fileName = iController->FileDetails()->GenerateFileNameL(); |
317 |
330 |
318 if ( fileName && fileName->Length() ) |
331 if ( fileName && fileName->Length() ) |
319 { |
332 { |
320 // file name gets populated by HandleScrollFilenameTimer method |
333 // file name gets populated by UpdateFilename method |
321 iClipnameLabel->SetExtent( |
334 iClipnameLabel->SetExtent( |
322 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
335 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
323 TSize( labelWidth, labelHeight ) |
336 TSize( labelWidth, labelHeight ) |
324 ); |
337 ); |
325 iClipnameLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin); |
338 iClipnameLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin ); |
326 iClipnameLabel->MakeVisible( ETrue ); |
339 iClipnameLabel->MakeVisible( ETrue ); |
327 rowsAdded++; |
340 rowsAdded++; |
328 |
341 } |
329 delete fileName; |
342 |
330 } |
343 delete fileName; |
331 |
344 |
332 // Mime Type (Format) |
345 // Mime Type (Format) |
333 if ( iController->FileDetails()->iMimeType && iController->FileDetails()->iMimeType->Length() ) |
346 if ( iController->FileDetails()->iMimeType && iController->FileDetails()->iMimeType->Length() ) |
334 { |
347 { |
335 iFormatLabel->SetExtent( |
348 iFormatLabel->SetExtent( |
336 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
349 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
432 ); |
445 ); |
433 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_BITRATE_HEADING ); |
446 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_BITRATE_HEADING ); |
434 CleanupStack::PushL( heading ); |
447 CleanupStack::PushL( heading ); |
435 |
448 |
436 TBuf<KMediaDetailsViewerMaxBufLen> bitrateField; |
449 TBuf<KMediaDetailsViewerMaxBufLen> bitrateField; |
437 bitrateField.Append(KLeftMargin); |
450 bitrateField.Append( KLeftMargin ); |
438 bitrateField.Append( *heading ); |
451 bitrateField.Append( *heading ); |
439 bitrateField.Append( KHeadingValueSeperator ); |
452 bitrateField.Append( KHeadingValueSeperator ); |
440 |
453 |
441 HBufC* formattedBitrate = |
454 HBufC* formattedBitrate = |
442 StringLoader::LoadLC(R_MPX_BITRATE_UNITS,iController->FileDetails()->iBitRate / 1000 ); |
455 StringLoader::LoadLC(R_MPX_BITRATE_UNITS,iController->FileDetails()->iBitRate / 1000 ); |
443 |
456 |
444 bitrateField.Append( *formattedBitrate ); |
457 bitrateField.Append( *formattedBitrate ); |
445 iBitrateLabel->SetTextL(bitrateField); |
458 iBitrateLabel->SetTextL( bitrateField ); |
446 iBitrateLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin); |
459 iBitrateLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin ); |
447 iBitrateLabel->MakeVisible( ETrue ); |
460 iBitrateLabel->MakeVisible( ETrue ); |
448 rowsAdded++; |
461 rowsAdded++; |
449 |
462 |
450 CleanupStack::PopAndDestroy( formattedBitrate ); // formattedBitrate |
463 CleanupStack::PopAndDestroy( formattedBitrate ); // formattedBitrate |
451 CleanupStack::PopAndDestroy( heading ); |
|
452 } |
|
453 |
|
454 // Title |
|
455 if ( iController->FileDetails()->iTitle && iController->FileDetails()->iTitle->Length() ) |
|
456 { |
|
457 iTitleLabel->SetExtent( |
|
458 TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) , |
|
459 TSize( labelWidth, labelHeight ) |
|
460 ); |
|
461 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_TITLE_HEADING ); |
|
462 CleanupStack::PushL( heading ); |
|
463 |
|
464 TBuf<KMediaDetailsViewerMaxBufLen> titleField; |
|
465 titleField.Append(KLeftMargin); |
|
466 titleField.Append( *heading ); |
|
467 titleField.Append( KHeadingValueSeperator ); |
|
468 TInt allowLen = KMediaDetailsViewerMaxBufLen-titleField.Length(); |
|
469 titleField.Append( (iController->FileDetails()->iTitle)->Left(allowLen) ); |
|
470 iTitleLabel->SetTextL(titleField); |
|
471 iTitleLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin); |
|
472 iTitleLabel->MakeVisible( ETrue ); |
|
473 rowsAdded++; |
|
474 |
|
475 CleanupStack::PopAndDestroy( heading ); |
464 CleanupStack::PopAndDestroy( heading ); |
476 } |
465 } |
477 |
466 |
478 // Artist |
467 // Artist |
479 if ( iController->FileDetails()->iArtist && iController->FileDetails()->iArtist->Length() ) |
468 if ( iController->FileDetails()->iArtist && iController->FileDetails()->iArtist->Length() ) |
683 |
672 |
684 iBackgroundBitmap->UnlockHeap(); |
673 iBackgroundBitmap->UnlockHeap(); |
685 } |
674 } |
686 |
675 |
687 // ------------------------------------------------------------------------------------------------- |
676 // ------------------------------------------------------------------------------------------------- |
688 // CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer |
677 // CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer |
689 // ------------------------------------------------------------------------------------------------- |
678 // ------------------------------------------------------------------------------------------------- |
690 // |
679 // |
691 TInt CMPXVideoPlaybackMediaDetailsViewer::ScrollFilenameTimer( TAny* aPtr ) |
680 TInt CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer( TAny* aPtr ) |
692 { |
681 { |
693 TRAP_IGNORE( |
682 TRAP_IGNORE( |
694 static_cast<CMPXVideoPlaybackMediaDetailsViewer*>(aPtr)->HandleScrollFilenameTimerL() |
683 static_cast<CMPXVideoPlaybackMediaDetailsViewer*>(aPtr)->HandleScrollTimerL() |
695 ); |
684 ); |
696 return KErrNone; |
685 return KErrNone; |
697 } |
686 } |
698 |
687 |
699 // ------------------------------------------------------------------------------------------------- |
688 // ------------------------------------------------------------------------------------------------- |
700 // CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL |
689 // CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL |
701 // ------------------------------------------------------------------------------------------------- |
690 // ------------------------------------------------------------------------------------------------- |
702 // |
691 // |
703 void CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL() |
692 void CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL() |
704 { |
693 { |
705 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::HandleScrollFilenameTimerL" ) ); |
694 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL" ) ); |
706 |
695 |
|
696 if ( iFilenameScroller.IsUpdateNeeded() ) |
|
697 { |
|
698 UpdateFilenameL(); |
|
699 } |
|
700 |
|
701 if ( iTitleScroller.IsUpdateNeeded() ) |
|
702 { |
|
703 UpdateTitleL(); |
|
704 } |
|
705 |
|
706 if ( !iFilenameScroller.IsScrollNeeded() && !iTitleScroller.IsScrollNeeded() ) |
|
707 { |
|
708 iScrollingTextTimer->Cancel(); // no need to keep the timer active |
|
709 } |
|
710 |
|
711 if ( iScrolledTextUpdated ) |
|
712 { |
|
713 iScrolledTextUpdated = EFalse; |
|
714 DrawNow(); |
|
715 } |
|
716 } |
|
717 |
|
718 // ------------------------------------------------------------------------------------------------- |
|
719 // CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewer |
|
720 // ------------------------------------------------------------------------------------------------- |
|
721 // |
|
722 TInt CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewerL() |
|
723 { |
|
724 TInt numOfItems = 0; |
|
725 |
|
726 if ( iController->FileDetails()->iDrmProtected ) |
|
727 { |
|
728 numOfItems++; |
|
729 } |
|
730 |
|
731 if ( iController->FileDetails()->iClipName ) |
|
732 { |
|
733 numOfItems++; |
|
734 } |
|
735 |
|
736 if ( iController->FileDetails()->iMimeType ) |
|
737 { |
|
738 numOfItems++; |
|
739 } |
|
740 |
|
741 if ( iController->FileDetails()->iVideoHeight && |
|
742 iController->FileDetails()->iVideoWidth ) |
|
743 { |
|
744 numOfItems++; |
|
745 } |
|
746 |
|
747 if ( iController->FileDetails()->iDuration > 0 ) |
|
748 { |
|
749 numOfItems++; |
|
750 } |
|
751 |
|
752 if ( iController->FileDetails()->iBitRate > 0 ) |
|
753 { |
|
754 numOfItems++; |
|
755 } |
|
756 |
|
757 HBufC* title = NULL; |
|
758 TRAP_IGNORE ( title = iController->FileDetails()->GenerateFileTitleL() ); |
|
759 |
|
760 if ( title ) |
|
761 { |
|
762 numOfItems++; |
|
763 delete title; |
|
764 } |
|
765 |
|
766 if ( iController->FileDetails()->iArtist ) |
|
767 { |
|
768 numOfItems++; |
|
769 } |
|
770 |
|
771 // Additional File Details |
|
772 CMPXFileDetailsPlugin* addPlugin( NULL ); |
|
773 |
|
774 // Use the interface to load the ecom plugin |
|
775 TRAPD ( err, addPlugin = CMPXFileDetailsPlugin::NewL( KFileDetailsCntlPluginUid ) ); |
|
776 |
|
777 // If plugin loaded successfully |
|
778 if ( ! err ) |
|
779 { |
|
780 TPtrC addLabel; |
|
781 addLabel.Set( addPlugin->GetAdditionalLabelLC( iController->FileDetails()->iFourCCCode ) ); |
|
782 iAdditionalString = addLabel.AllocL(); |
|
783 |
|
784 if ( iAdditionalString->Length() ) |
|
785 { |
|
786 numOfItems++; |
|
787 } |
|
788 |
|
789 CleanupStack::PopAndDestroy(); // addLabel |
|
790 } |
|
791 |
|
792 delete addPlugin; |
|
793 |
|
794 return numOfItems; |
|
795 } |
|
796 |
|
797 // ------------------------------------------------------------------------------------------------- |
|
798 // CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRect |
|
799 // ------------------------------------------------------------------------------------------------- |
|
800 // |
|
801 TRect CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRectL() |
|
802 { |
|
803 TInt numOfItems = NumOfItemsShownInViewerL(); |
|
804 TRect viewerRect; |
|
805 |
|
806 // optimize viewer's width for the clipname |
|
807 TInt horizontalOffset = 0; |
|
808 TInt filenameLength = iController->FileDetails()->iClipName->Des().Length(); |
|
809 |
|
810 if ( filenameLength <= KMediaDetailsViewerFilenameMedium ) |
|
811 { |
|
812 horizontalOffset = |
|
813 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMedium; |
|
814 } |
|
815 else |
|
816 { |
|
817 horizontalOffset = |
|
818 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMax; |
|
819 } |
|
820 |
|
821 TInt eachItemHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems; |
|
822 |
|
823 TInt verticalHalf = iController->iContainer->Rect().iBr.iY / 2; |
|
824 |
|
825 TInt tLX = (iController->iContainer->Rect().iTl.iX) + horizontalOffset; |
|
826 TInt bRX = (iController->iContainer->Rect().iBr.iX) - horizontalOffset; |
|
827 |
|
828 TInt tLY = verticalHalf - ( eachItemHeight * numOfItems/2 ); |
|
829 |
|
830 // pad for the margins on top and bottom of viewer |
|
831 TInt bRY = |
|
832 verticalHalf + ( eachItemHeight * numOfItems/2 ) + ( KMediaDetailsViewerItemMargin * 2 ); |
|
833 |
|
834 viewerRect = TRect( tLX, tLY, bRX, bRY ); |
|
835 |
|
836 return viewerRect; |
|
837 } |
|
838 |
|
839 // ------------------------------------------------------------------------------------------------- |
|
840 // CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL |
|
841 // ------------------------------------------------------------------------------------------------- |
|
842 // |
|
843 void CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL() |
|
844 { |
|
845 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL" ) ); |
|
846 |
|
847 HBufC* fileName = iController->FileDetails()->GenerateFileNameL(); |
|
848 CleanupStack::PushL( fileName ); |
|
849 |
|
850 if ( fileName && fileName->Length() ) |
|
851 { |
|
852 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_FILENAME_HEADING ); |
|
853 CleanupStack::PushL( heading ); |
|
854 |
|
855 TBuf<KMediaDetailsViewerMaxBufLen> filenameField; |
|
856 filenameField.Append( KLeftMargin ); |
|
857 filenameField.Append( *heading ); |
|
858 filenameField.Append( KHeadingValueSeperator ); |
|
859 |
|
860 iFilenameScroller.ScrollText( *fileName, filenameField ); |
|
861 |
|
862 iClipnameLabel->SetTextL( filenameField ); |
|
863 |
|
864 iScrolledTextUpdated = ETrue; |
|
865 |
|
866 CleanupStack::PopAndDestroy( heading ); |
|
867 } |
|
868 |
|
869 CleanupStack::PopAndDestroy( fileName ); |
|
870 } |
|
871 |
|
872 // ------------------------------------------------------------------------------------------------- |
|
873 // CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL |
|
874 // ------------------------------------------------------------------------------------------------- |
|
875 // |
|
876 void CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL() |
|
877 { |
|
878 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL" ) ); |
|
879 |
|
880 HBufC* fileTitle = iController->FileDetails()->GenerateFileTitleL(); |
|
881 CleanupStack::PushL( fileTitle ); |
|
882 |
|
883 if ( fileTitle && fileTitle->Length() ) |
|
884 { |
|
885 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_TITLE_HEADING ); |
|
886 CleanupStack::PushL( heading ); |
|
887 |
|
888 TBuf<KMediaDetailsViewerMaxBufLen> titleField; |
|
889 titleField.Append( KLeftMargin ); |
|
890 titleField.Append( *heading ); |
|
891 titleField.Append( KHeadingValueSeperator ); |
|
892 |
|
893 iTitleScroller.ScrollText( *fileTitle, titleField ); |
|
894 |
|
895 iTitleLabel->SetTextL( titleField ); |
|
896 |
|
897 iScrolledTextUpdated = ETrue; |
|
898 |
|
899 CleanupStack::PopAndDestroy( heading ); |
|
900 } |
|
901 |
|
902 CleanupStack::PopAndDestroy( fileTitle ); |
|
903 } |
|
904 |
|
905 // ------------------------------------------------------------------------------------------------- |
|
906 // CMPXVideoPlaybackMediaDetailsViewer::ViewerRect |
|
907 // ------------------------------------------------------------------------------------------------- |
|
908 // |
|
909 TRect CMPXVideoPlaybackMediaDetailsViewer::ViewerRect() |
|
910 { |
|
911 return iViewerRect; |
|
912 } |
|
913 |
|
914 // ------------------------------------------------------------------------------------------------- |
|
915 // CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::TTextScroller |
|
916 // ------------------------------------------------------------------------------------------------- |
|
917 // |
|
918 CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::TTextScroller() |
|
919 : iDelayBeginningTick( KInvalidTick ) |
|
920 , iTextScrollPos( 0 ) |
|
921 , iDelay( EFalse ) |
|
922 , iScroll( ETrue ) |
|
923 , iSrcTextLen( 0 ) |
|
924 { |
|
925 } |
|
926 |
|
927 // ------------------------------------------------------------------------------------------------- |
|
928 // CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsScrollNeeded |
|
929 // ------------------------------------------------------------------------------------------------- |
|
930 // |
|
931 TBool CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsScrollNeeded() |
|
932 { |
|
933 return iScroll; |
|
934 } |
|
935 |
|
936 // ------------------------------------------------------------------------------------------------- |
|
937 // CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded |
|
938 // ------------------------------------------------------------------------------------------------- |
|
939 // |
|
940 TBool CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded() |
|
941 { |
|
942 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded" ) ); |
|
943 |
|
944 // skip the scrolling operation if the loop for delay is going on |
707 TBool skipForTimerDelay = EFalse; |
945 TBool skipForTimerDelay = EFalse; |
708 |
946 |
709 // add a delay after each complete scrolling |
947 // add a delay after each complete scrolling |
710 if ( iScrollTimerDelayBeginningTick != KInvalidTick ) |
948 if ( iScroll && iDelayBeginningTick != KInvalidTick ) |
711 { |
949 { |
712 if ( ( User::NTickCount() - iScrollTimerDelayBeginningTick ) >= KScrollTimerDelayTickCounts ) |
950 if ( ( User::NTickCount() - iDelayBeginningTick ) >= KScrollTimerDelayTickCounts ) |
713 { |
951 { |
714 iScrollTimerDelayBeginningTick = KInvalidTick; |
952 iDelayBeginningTick = KInvalidTick; |
715 } |
953 } |
716 else |
954 else |
717 { |
955 { |
718 skipForTimerDelay = ETrue; |
956 skipForTimerDelay = ETrue; |
719 } |
957 } |
720 } |
958 } |
721 |
959 |
722 if ( !skipForTimerDelay && iShouldPauseScrolling ) |
960 // start delay |
723 { |
961 if ( iScroll && !skipForTimerDelay && iDelay ) |
724 iShouldPauseScrolling = EFalse; |
962 { |
725 iScrollTimerDelayBeginningTick = User::NTickCount(); |
963 iDelay = EFalse; |
|
964 iDelayBeginningTick = User::NTickCount(); |
726 skipForTimerDelay = ETrue; |
965 skipForTimerDelay = ETrue; |
727 } |
966 } |
728 |
967 |
729 // skip the scrolling operation if the loop for delay is going on |
968 return iScroll && !skipForTimerDelay; |
730 if ( !skipForTimerDelay ) |
969 } |
731 { |
970 |
732 HBufC* fileName = iController->FileDetails()->GenerateFileNameL(); |
971 // ------------------------------------------------------------------------------------------------- |
733 |
972 // CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText |
|
973 // ------------------------------------------------------------------------------------------------- |
|
974 // |
|
975 void CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText( |
|
976 const TDesC& aSrcText, |
|
977 TDes& aDesText ) |
|
978 { |
|
979 MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText" ) ); |
|
980 |
|
981 if ( 0 == iSrcTextLen ) |
|
982 { |
|
983 iSrcTextLen = aSrcText.Length(); |
|
984 } |
|
985 |
|
986 ASSERT( aSrcText.Length() == iSrcTextLen ); |
|
987 if ( aSrcText.Length() >= KMediaDetailsViewerVisibleCharacters ) |
|
988 { |
|
989 aDesText.Append( aSrcText.Mid( iTextScrollPos, |
|
990 KMediaDetailsViewerVisibleCharacters ) ); |
|
991 |
|
992 if ( iTextScrollPos == ( iSrcTextLen - KMediaDetailsViewerVisibleCharacters ) ) |
|
993 { |
|
994 iTextScrollPos = 0; |
|
995 iDelay = ETrue; |
|
996 } |
|
997 else |
|
998 { |
|
999 iTextScrollPos++; |
|
1000 } |
|
1001 iScroll = ETrue; |
734 |
1002 |
735 if ( fileName && fileName->Length() ) |
|
736 { |
|
737 CleanupStack::PushL( fileName ); |
|
738 |
|
739 TInt length = fileName->Length(); |
|
740 |
|
741 HBufC* heading = iEikonEnv->AllocReadResourceL( R_MPX_FILENAME_HEADING ); |
|
742 CleanupStack::PushL( heading ); |
|
743 |
|
744 TBuf<KMediaDetailsViewerMaxBufLen> filenameField; |
|
745 filenameField.Append(KLeftMargin); |
|
746 filenameField.Append( *heading ); |
|
747 filenameField.Append( KHeadingValueSeperator ); |
|
748 |
|
749 if ( length >= KMediaDetailsViewerVisibleCharacters ) |
|
750 { |
|
751 filenameField.Append( fileName->Mid( iScrollPosition, |
|
752 KMediaDetailsViewerVisibleCharacters ) ); |
|
753 |
|
754 if ( iScrollPosition == (length - KMediaDetailsViewerVisibleCharacters) ) |
|
755 { |
|
756 iScrollPosition = 0; |
|
757 iShouldPauseScrolling = ETrue; |
|
758 } |
|
759 else |
|
760 { |
|
761 iScrollPosition++; |
|
762 } |
|
763 } |
|
764 else |
|
765 { |
|
766 filenameField.Append( *fileName ); |
|
767 iScrollingTextTimer->Cancel(); // no need to keep the timer active |
|
768 } |
|
769 |
|
770 iClipnameLabel->SetTextL(filenameField); |
|
771 DrawNow(); |
|
772 |
|
773 CleanupStack::PopAndDestroy( heading ); |
|
774 CleanupStack::PopAndDestroy( fileName ); |
|
775 } |
|
776 } |
|
777 } |
|
778 |
|
779 |
|
780 // ------------------------------------------------------------------------------------------------- |
|
781 // CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewer |
|
782 // ------------------------------------------------------------------------------------------------- |
|
783 // |
|
784 TInt CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewerL() |
|
785 { |
|
786 TInt numOfItems = 0; |
|
787 |
|
788 if ( iController->FileDetails()->iDrmProtected ) |
|
789 { |
|
790 numOfItems++; |
|
791 } |
|
792 |
|
793 if ( iController->FileDetails()->iClipName ) |
|
794 { |
|
795 numOfItems++; |
|
796 } |
|
797 |
|
798 if ( iController->FileDetails()->iMimeType ) |
|
799 { |
|
800 numOfItems++; |
|
801 } |
|
802 |
|
803 if ( iController->FileDetails()->iVideoHeight && |
|
804 iController->FileDetails()->iVideoWidth ) |
|
805 { |
|
806 numOfItems++; |
|
807 } |
|
808 |
|
809 if ( iController->FileDetails()->iDuration > 0 ) |
|
810 { |
|
811 numOfItems++; |
|
812 } |
|
813 |
|
814 if ( iController->FileDetails()->iBitRate > 0 ) |
|
815 { |
|
816 numOfItems++; |
|
817 } |
|
818 |
|
819 if ( iController->FileDetails()->iTitle ) |
|
820 { |
|
821 numOfItems++; |
|
822 } |
|
823 |
|
824 if ( iController->FileDetails()->iArtist ) |
|
825 { |
|
826 numOfItems++; |
|
827 } |
|
828 |
|
829 // Additional File Details |
|
830 CMPXFileDetailsPlugin* addPlugin( NULL ); |
|
831 |
|
832 // Use the interface to load the ecom plugin |
|
833 TRAPD ( err, addPlugin = CMPXFileDetailsPlugin::NewL( KFileDetailsCntlPluginUid ) ); |
|
834 |
|
835 // If plugin loaded successfully |
|
836 if ( ! err ) |
|
837 { |
|
838 TPtrC addLabel; |
|
839 addLabel.Set( addPlugin->GetAdditionalLabelLC( iController->FileDetails()->iFourCCCode ) ); |
|
840 iAdditionalString = addLabel.AllocL(); |
|
841 |
|
842 if ( iAdditionalString->Length() ) |
|
843 { |
|
844 numOfItems++; |
|
845 } |
|
846 |
|
847 CleanupStack::PopAndDestroy(); // addLabel |
|
848 } |
|
849 |
|
850 delete addPlugin; |
|
851 |
|
852 return numOfItems; |
|
853 } |
|
854 |
|
855 // ------------------------------------------------------------------------------------------------- |
|
856 // CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRect |
|
857 // ------------------------------------------------------------------------------------------------- |
|
858 // |
|
859 TRect CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRectL() |
|
860 { |
|
861 TInt numOfItems = NumOfItemsShownInViewerL(); |
|
862 TRect viewerRect; |
|
863 |
|
864 // optimize viewer's width for the clipname |
|
865 TInt horizontalOffset = 0; |
|
866 TInt filenameLength = iController->FileDetails()->iClipName->Des().Length(); |
|
867 |
|
868 if ( filenameLength <= KMediaDetailsViewerFilenameMedium ) |
|
869 { |
|
870 horizontalOffset = |
|
871 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMedium; |
|
872 } |
1003 } |
873 else |
1004 else |
874 { |
1005 { |
875 horizontalOffset = |
1006 aDesText.Append( aSrcText ); |
876 iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMax; |
1007 iScroll = EFalse; |
877 } |
1008 } |
878 |
1009 } |
879 TInt eachItemHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems; |
|
880 |
|
881 TInt verticalHalf = iController->iContainer->Rect().iBr.iY / 2; |
|
882 |
|
883 TInt tLX = (iController->iContainer->Rect().iTl.iX) + horizontalOffset; |
|
884 TInt bRX = (iController->iContainer->Rect().iBr.iX) - horizontalOffset; |
|
885 |
|
886 TInt tLY = verticalHalf - ( eachItemHeight * numOfItems/2 ); |
|
887 |
|
888 // pad for the margins on top and bottom of viewer |
|
889 TInt bRY = |
|
890 verticalHalf + ( eachItemHeight * numOfItems/2 ) + ( KMediaDetailsViewerItemMargin * 2 ); |
|
891 |
|
892 viewerRect = TRect( tLX, tLY, bRX, bRY ); |
|
893 |
|
894 return viewerRect; |
|
895 } |
|
896 |
|
897 // ------------------------------------------------------------------------------------------------- |
|
898 // CMPXVideoPlaybackMediaDetailsViewer::ViewerRect |
|
899 // ------------------------------------------------------------------------------------------------- |
|
900 // |
|
901 TRect CMPXVideoPlaybackMediaDetailsViewer::ViewerRect() |
|
902 { |
|
903 return iViewerRect; |
|
904 } |
|
905 |
|
906 |
1010 |
907 // End of File |
1011 // End of File |