/*

* 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, " x ");

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

// UID of this interface

const TUid KFileDetailsCntlPluginUid = {0x2002A59D};

const TUid KFileDetailsInterfaceUid = {0x2002A5A0};

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

// Local function to cleanup an array

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

//

static void CleanupEcomArray( TAny* aArray )

{

  ( static_cast<RImplInfoPtrArray*>( aArray ) )->ResetAndDestroy();

  ( static_cast<RImplInfoPtrArray*>( aArray ) )->Close();

}

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

CMPXVideoPlaybackMediaDetailsViewer::CMPXVideoPlaybackMediaDetailsViewer(

    CMPXVideoPlaybackControlsController* aController )

    : iController( aController )

{

}

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

// CMPXVideoPlaybackMediaDetailsViewer::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackMediaDetailsViewer::ConstructL()

{

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

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

{      

    iController->iContainer->HandleCommandL(EMPXPbvLaunchDRMDetails);

}

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

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

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

    }    

    // Filename

    if ( iController->FileDetails()->iClipName )

    {   

        // file name gets populated by HandleScrollFilenameTimer method         

        iClipnameLabel->SetExtent( TPoint(Rect().iTl.iX, Rect().iTl.iY + (labelHeight*rowsAdded) ) , 

                                   TSize(labelWidth,labelHeight) );

        iClipnameLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);        

        iClipnameLabel->MakeVisible( ETrue );

        rowsAdded++;

    }    

    // Mime Type (Format)

    if ( iController->FileDetails()->iMimeType )

    {

        iFormatLabel->SetExtent( TPoint(Rect().iTl.iX, Rect().iTl.iY + (labelHeight*rowsAdded) ) , 

                                 TSize(labelWidth,labelHeight) );

        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FORMAT_HEADING );     

        formatField.Append(KLeftMargin);

        formatField.Append( *heading );

        formatField.Append( KHeadingValueSeperator );

        iFormatLabel->SetTextL(formatField);

        iFormatLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);

        iFormatLabel->MakeVisible( ETrue ); 

        rowsAdded++;

    }    

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

        resolutionField.Append(KLeftMargin);

        resolutionField.Append( *heading );

        resolutionField.Append( KHeadingValueSeperator );

        resolutionField.AppendNum( iController->FileDetails()->iVideoWidth );   

        resolutionField.Append( KWidthHeightSeparator );

        resolutionField.AppendNum( iController->FileDetails()->iVideoHeight);

        iResolutionLabel->SetTextL(resolutionField);

        iResolutionLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);

        iResolutionLabel->MakeVisible( ETrue ); 

        rowsAdded++;

    } 

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

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

    }     

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

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

    }         

    // Title

    if ( iController->FileDetails()->iTitle )

    {

        iTitleLabel->SetExtent( TPoint(Rect().iTl.iX, Rect().iTl.iY + (labelHeight*rowsAdded) ) , 

                                TSize(labelWidth,labelHeight) );

        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_TITLE_HEADING );     

        titleField.Append(KLeftMargin);

        titleField.Append( *heading );

        titleField.Append( KHeadingValueSeperator );

        iTitleLabel->SetTextL(titleField);

        iTitleLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);

        iTitleLabel->MakeVisible( ETrue );

        rowsAdded++;

    }    

    // Artist

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

    {

        iArtistLabel->SetExtent( TPoint(Rect().iTl.iX, Rect().iTl.iY + (labelHeight*rowsAdded) ) , 

                                TSize(labelWidth,labelHeight) );

        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_ARTIST_HEADING );     

        artistField.Append(KLeftMargin);

        artistField.Append( *heading );

        artistField.Append( KHeadingValueSeperator );

        iArtistLabel->SetTextL(artistField);

        iArtistLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);

        iArtistLabel->MakeVisible( ETrue );

        rowsAdded++;

    } 

    // Additional Label

    if ( iAdditionalString && iAdditionalString->Length() ) 

    {    

        iAdditionalLabel->SetExtent( TPoint(Rect().iTl.iX, Rect().iTl.iY + (labelHeight*rowsAdded) ) , 

                                     TSize(labelWidth,labelHeight) );  

        titleField.Append(KLeftMargin);

        iAdditionalLabel->SetTextL(titleField);

        iAdditionalLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);

        iAdditionalLabel->MakeVisible( ETrue );

        rowsAdded++;

    }

}

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

// CMPXVideoPlaybackMediaDetailsViewer::CountComponentControls()

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

//

TInt CMPXVideoPlaybackMediaDetailsViewer::CountComponentControls() const

{

    return 9;

}

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

// CMPXVideoPlaybackMediaDetailsViewer::ComponentControl

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

//