/*

* Copyright (c) 2008 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: Media Details Viewer

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <eiklabel.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <gulicon.h>

#include <gdi.h>

#include <e32base.h>

#include <mpxfiledetailscntlpluginif.h>

#include <mpxvideoplaybackcontrols.rsg>

#include <mpxvideoplaybackcontrols.mbg>

#include <avkon.rsg>

#include "mpxvideoplaybackcontrol.hrh"

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackmediadetailsviewer.h"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackcontainer.h"

// Constants

_LIT(KHeadingValueSeperator, ": ");

_LIT(KWidthHeightSeparator, " \xd7 ");

_LIT(KLeftMargin, " " );

const TInt KMediaDetailsViewerMaxItems = 11;  // used to determine the height of each item

const TInt KMediaDetailsViewerItemMargin = 3;

const TInt KMediaDetailsViewerVisibleCharacters = 30;

const TInt KMediaDetailsViewerFilenameMedium = 45;

const TInt KMediaDetailsViewerOffsetDivisorMedium = 12;

const TInt KMediaDetailsViewerOffsetDivisorMax = 20;

const TInt KMediaDetailsViewerMaxBufLen = 255;

// UID of this interface

const TUid KFileDetailsCntlPluginUid = {0x2002A59D};

const TUint32 KScrollTimerDelayTickCounts = 2000;   // 2000 milliseconds

const TUint32 KInvalidTick = 0;

// ============================ MEMBER FUNCTIONS ===================================================

CMPXVideoPlaybackMediaDetailsViewer::CMPXVideoPlaybackMediaDetailsViewer(

    CMPXVideoPlaybackControlsController* aController )

    : iController( aController )

{

}

// -------------------------------------------------------------------------------------------------

// CMPXVideoPlaybackMediaDetailsViewer::ConstructL()

// Symbian 2nd phase constructor can leave.

// -------------------------------------------------------------------------------------------------

//

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 ) );

    iScrollingTextTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iScrollingTextTimer->Start(

                0,

                175000,

                TCallBack( CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer, this ) );

}

// -------------------------------------------------------------------------------------------------

// CMPXVideoPlaybackMediaDetailsViewer::NewL()

// Two-phased constructor.

// -------------------------------------------------------------------------------------------------

//

CMPXVideoPlaybackMediaDetailsViewer* CMPXVideoPlaybackMediaDetailsViewer::NewL(

                                                CMPXVideoPlaybackControlsController* aController )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::NewL()"));

    CMPXVideoPlaybackMediaDetailsViewer* self = new ( ELeave ) CMPXVideoPlaybackMediaDetailsViewer( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

// -------------------------------------------------------------------------------------------------

// CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()

// Destructor.

// -------------------------------------------------------------------------------------------------

//

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()

// -------------------------------------------------------------------------------------------------

//

void CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL()"));

    switch ( aPointerEvent.iType )

    {

        case TPointerEvent::EButton1Down:

        {

            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()

{

}

// -------------------------------------------------------------------------------------------------

// CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()

// -------------------------------------------------------------------------------------------------

//

void CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()

{

}

// -------------------------------------------------------------------------------------------------

//   CMPXVideoPlaybackMediaDetailsViewer::Draw()

// -------------------------------------------------------------------------------------------------

//

void CMPXVideoPlaybackMediaDetailsViewer::Draw( const TRect& aRect ) const

{

    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) ) ,

                             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 );

    }

    // Title

    HBufC* fileTitle = iController->FileDetails()->GenerateFileTitleL();

    if ( fileTitle && fileTitle->Length() )

    {

        // Title gets populated by UpdateTitle method

        iTitleLabel->SetExtent(

                          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,

                          TSize( labelWidth, labelHeight )

                          );

        iTitleLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );

        iTitleLabel->MakeVisible( ETrue );

        rowsAdded++;

    }

    delete fileTitle;

    // Filename

    HBufC* fileName = iController->FileDetails()->GenerateFileNameL();

    if ( fileName && fileName->Length() )

    {

        // file name gets populated by UpdateFilename method

        iClipnameLabel->SetExtent(

                             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 && iController->FileDetails()->iMimeType->Length() )

    {

        iFormatLabel->SetExtent(

                          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 &&  iController->FileDetails()->iVideoWidth )

    {

        iResolutionLabel->SetExtent(

                               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) ) ,

                             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 ) ) ,

                          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 );

    }

    // Artist

    if ( iController->FileDetails()->iArtist && iController->FileDetails()->iArtist->Length() )

    {

        iArtistLabel->SetExtent(

                          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 ) ) ,