/*

* Copyright (c) 2003-2010 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:  Implementation of CDRMRightsMgrDetailsContainer class

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <aknlists.h>

#include <CDirectoryLocalizer.h>

#include <DRMRights.h>

#include <DRMRightsManager.rsg>

#include "DRMRightsMgrDetailsContainer.h"

#include "DRMCommonUtilities.h"

#include "drmutilityinternaltypes.h"

// CONSTANTS

LOCAL_C const TInt KMsgLineLength = 100;

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

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

// CDRMRightsMgrDetailsContainer::CDRMRightsMgrDetailsContainer

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

//

CDRMRightsMgrDetailsContainer::CDRMRightsMgrDetailsContainer(

                                                        TDetails& aDetails,

                                                        TBool aStartEmbedded )

: iDetails( aDetails ),

  iStartEmbedded( aStartEmbedded ),

  iListBox( NULL )

    {

    }

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

// CDRMRightsMgrDetailsContainer::ConstructL

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

//

void CDRMRightsMgrDetailsContainer::ConstructL( const TRect& aRect )

    {

    iListBox = new( ELeave )CAknDoubleStyleListBox;     // Creates new object

    CreateWindowL(); //makes the control a window-owning control

    ConstructListBoxL();

    if ( iListBox )

        {

        // set iListBox to be contained in this container

        iListBox->SetContainerWindowL( *this );

        SetScrollBarL();

        }

    SetRect( aRect );

    ActivateL();

    SetIconsL();

    }

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

// CDRMRightsMgrDetailsContainer::~CDRMRightsMgrDetailsContainer

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

//

CDRMRightsMgrDetailsContainer::~CDRMRightsMgrDetailsContainer()

    {

    delete iListBox;

    }

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

// CDRMRightsMgrDetailsContainer::SizeChanged

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

//

void CDRMRightsMgrDetailsContainer::SizeChanged()

   {

    if ( iListBox )

        {

        iListBox->SetRect( Rect() ); // Sets rectangle of listbox.

        }

    }

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

// CDRMRightsMgrDetailsContainer::CountComponentControls

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

//

TInt CDRMRightsMgrDetailsContainer::CountComponentControls() const

    {

    TInt count( 0 );

    if ( iListBox )

        {

        count++;

        }

    return count; // Returns number of controls inside this container.

    }

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

// CDRMRightsMgrDetailsContainer::ComponentControl

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

//

CCoeControl* CDRMRightsMgrDetailsContainer::ComponentControl( TInt aIndex ) const

    {

    switch ( aIndex )

        {

        case 0:

            return iListBox;    // Returns the pointer to listbox object.

        default:

            return NULL;        // Exception : Returns NULL.

        }

    }

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

// CDRMRightsMgrDetailsContainer::HandleResourceChange

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

//

void CDRMRightsMgrDetailsContainer::HandleResourceChange( TInt aType )

    {

    CCoeControl::HandleResourceChange( aType );

    }

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

// CDRMRightsMgrDetailsContainer::SetScrollBarL

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

//

void CDRMRightsMgrDetailsContainer::SetScrollBarL()

    {

    // Update scrollbar in order to draw correct scroll bar.

    TInt pos( iListBox->View()->CurrentItemIndex() );

    if ( iListBox->ScrollBarFrame() )

        {

        iListBox->ScrollBarFrame()->MoveVertThumbTo( pos );

        }

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(

                                                CEikScrollBarFrame::EOff,

                                                CEikScrollBarFrame::EAuto );

    }

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

// CDRMRightsMgrDetailsContainer::OfferKeyEventL

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

//

TKeyResponse CDRMRightsMgrDetailsContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                TEventCode aType )

    {

    if ( aType != EEventKey ) // Is not key event?

        {

        return EKeyWasNotConsumed;

        }

    else if ( aKeyEvent.iCode == EKeyLeftArrow ||

              aKeyEvent.iCode == EKeyRightArrow )

        {

        return EKeyWasConsumed;

        }

    else

        {

        return iListBox ? iListBox->OfferKeyEventL( aKeyEvent, aType ) :

                          EKeyWasNotConsumed;

        }

    }

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

// CDRMRightsMgrDetailsContainer::Draw

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

//

void CDRMRightsMgrDetailsContainer::Draw( const TRect& /*aRect*/ ) const

    {

    }

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

// CDRMRightsMgrDetailsContainer::HandleControlEventL

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

//

void CDRMRightsMgrDetailsContainer::HandleControlEventL( CCoeControl* /*aControl*/,

                                             TCoeEvent /*aEventType*/ )

    {

    }

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

// CDRMRightsMgrDetailsContainer::SetIconsL

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

//

void CDRMRightsMgrDetailsContainer::SetIconsL()

    {

    }

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

// CDRMRightsMgrDetailsContainer::FocusChanged

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

//

void CDRMRightsMgrDetailsContainer::FocusChanged(TDrawNow /*aDrawNow*/)

   {

    if ( iListBox )

        {

        iListBox->SetFocus( IsFocused() );

        }

    }

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

// CDRMRightsMgrDetailsContainer::ConstructListBoxL

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

//

void CDRMRightsMgrDetailsContainer::ConstructListBoxL()

    {

    iListBox->ConstructL( this, EAknListBoxViewerFlags /* | 

        EAknListBoxItemSpecificMenuDisabled */ );

    if ( iStartEmbedded )

        {

        iListBox->View()->SetListEmptyTextL( KNullDesC );

        }

    else

        {

        UpdateListBoxContentL( iDetails );        // Updates content

        }

    }

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

// CDRMRightsMgrDetailsContainer::UpdateListBoxContentL

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

//

void CDRMRightsMgrDetailsContainer::UpdateListBoxContentL( TDetails& aDetails )

    {

    CDesCArray* items = ( CDesCArray* )( iListBox->Model()->ItemTextArray() );

    items->Reset();

    TInt rightsCount = aDetails.iRights->Count();

    if ( rightsCount )

        {

        // Add only the details of the currently active RO, although the file

        // could be related to multiple ROs.

        AddRightsDetailsL( aDetails.iActiveROindex, aDetails, items );

        }

    else

        {

        // WMDRM agent returned an empty array of rights. Add the status line

        // of rights.

        if ( aDetails.iDrmScheme == EDrmSchemeWmDrm )

            {

            AddStatusLineL( aDetails.iRights->At( 0 ).iStatus, items );

            }

        }

    // Content sending

    if ( aDetails.iDrmScheme != EDrmSchemeUnknownDrm )

        {

        AddContentSendingLineL( aDetails.iContentCanBeSent, items );

        }

    // Individual constraint

    if ( aDetails.iIndividualConstraint )

        {

        AddContentUseLineL( aDetails.iUsageAllowed, items );

        }

    iListBox->HandleItemAdditionL();

    }

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

// CDRMRightsMgrDetailsContainer::HandleListBoxEventL

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

//

void CDRMRightsMgrDetailsContainer::HandleListBoxEventL(

                    CEikListBox* /*aListBox*/, TListBoxEvent /*aEventType*/ )

    {

    }

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

// CDRMRightsMgrDetailsContainer::AddRightsDetailsL

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

//

void CDRMRightsMgrDetailsContainer::AddRightsDetailsL( TInt aNumberOfKey,

                                                       TDetails& aDetails,

                                                       CDesCArray* aItems )

    {

    if ( aNumberOfKey < aDetails.iRights->Count() && aNumberOfKey >= 0 )

        {

        // Status of Rights

        AddStatusLineL( aDetails.iRights->At( aNumberOfKey ).iStatus,

            aItems );

        // Play Rights

        AddRightsLineL( aDetails.iRights->At( aNumberOfKey ).iPlayConstraint,

            aItems,

            aDetails.iDrmScheme,

            ContentAccess::EPlay );

        // Display Rights

        AddRightsLineL( aDetails.iRights->At( aNumberOfKey ).iDisplayConstraint,

            aItems,

            aDetails.iDrmScheme,

            ContentAccess::EView );

        // Print Rights

        AddRightsLineL( aDetails.iRights->At( aNumberOfKey ).iPrintConstraint,

            aItems,

            aDetails.iDrmScheme,

            ContentAccess::EPrint );

        // Execute Rights

        AddRightsLineL( aDetails.iRights->At( aNumberOfKey ).iExecuteConstraint,

            aItems,

            aDetails.iDrmScheme,

            ContentAccess::EExecute );

        }

    }

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

// CDRMRightsMgrDetailsContainer::AddStatusLineL

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

//

void CDRMRightsMgrDetailsContainer::AddStatusLineL( TDRMUIRightsStatus aStatus,

                                                    CDesCArray* aItems )

    {

    TBuf<KMsgLineLength> msgLine;

    HBufC* stringHolder;

    stringHolder = StringLoader::LoadL( R_QTN_DRM_DETAILS_STATUS,

                                            iEikonEnv );

    msgLine.Zero();

    msgLine.Append( '\t' );

    msgLine.Append( *stringHolder );

    delete stringHolder;

    stringHolder = NULL;

    msgLine.Append( '\t' );

    TInt resourceId;

    switch( aStatus )

        {

        case EDRMUIStatusInvalid:

            resourceId = R_QTN_DRM_DETAILS_NO_LICENCE_AVAILABLE;

            break;

        case EDRMUIStatusValid:

            resourceId = R_QTN_DRM_DETAILS_VALID;

            break;

        case EDRMUIStatusFuture:

            resourceId = R_QTN_DRM_DETAILS_NOT_VALID_YET;

            break;

        case EDRMUIStatusExpired:

            resourceId = R_QTN_DRM_DETAILS_NO_LICENCE_AVAILABLE;

            break;

        default:

            resourceId = 0;

            break;

        }

    if ( resourceId )

        {

        stringHolder = StringLoader::LoadL( resourceId, iEikonEnv );

        msgLine.Append( *stringHolder );

        delete stringHolder;

        stringHolder = NULL;

        }

    if ( aItems )

        {

        aItems->AppendL( msgLine );

        }

    }

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

// CDRMRightsMgrDetailsContainer::AddContentSendingLineL

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

//

void CDRMRightsMgrDetailsContainer::AddContentSendingLineL(

                                                    TBool aContentCanBeSent,

                                                    CDesCArray* aItems )

    {

    TBuf<KMsgLineLength> msgLine;

    msgLine.Zero();

    msgLine.Append( '\t' );

    HBufC* stringHolder = StringLoader::LoadL( R_QTN_DRM_DETAILS_SENDING,

                                               iEikonEnv );

    msgLine.Append( *stringHolder );

    delete stringHolder;

    stringHolder = NULL;

    msgLine.Append( '\t' );

    stringHolder = StringLoader::LoadL( aContentCanBeSent ?

                                        R_QTN_DRM_MGR_DET_ALLOWED :

                                        R_QTN_DRM_MGR_DET_FORBID, iEikonEnv );

    msgLine.Append( *stringHolder );

    delete stringHolder;

    stringHolder = NULL;

    if ( aItems )

        {

        aItems->AppendL( msgLine );

        }

    }

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

// CDRMRightsMgrDetailsContainer::AddContentUseLineL

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

//

void CDRMRightsMgrDetailsContainer::AddContentUseLineL( TBool aUsageAllowed,

                                                        CDesCArray* aItems )

    {

    TBuf<KMsgLineLength> msgLine;

    msgLine.Zero();

    msgLine.Append( '\t' );

    HBufC* stringHolder = StringLoader::LoadL( R_QTN_DRM_DET_CONTENT_USE,

                                               iEikonEnv );

    msgLine.Append( *stringHolder );

    delete stringHolder;

    stringHolder = NULL;

    msgLine.Append( '\t' );

    stringHolder = StringLoader::LoadL( aUsageAllowed ?

                                        R_QTN_DRM_DET_SIM_ALLOWED :

                                        R_QTN_DRM_DET_SIM_NOT_ALLOWED, iEikonEnv );

    msgLine.Append( *stringHolder );

    delete stringHolder;

    stringHolder = NULL;

    if ( aItems )

        {

        aItems->AppendL( msgLine );

        }

    }

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

// CDRMRightsMgrDetailsContainer::AddRightsLineL

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

//

void CDRMRightsMgrDetailsContainer::AddRightsLineL(

                                            CDRMRightsConstraints* aConstraint,

                                            CDesCArray* aItems,

                                            const TInt aDrmScheme,

                                            const TUint32& aIntent )

    {

    if ( !aConstraint )

        {

        return;

        }

    else if ( aConstraint->FullRights() )

        {

        // Full Rights

        AddUsageRightsL( aItems, aIntent );

        }

    else

        {

        TUint32 counter( 0 );

        TUint32 originalCounter( 0 );

        TTime startDateTime( 0 );

        TTime endDateTime( 0 );

        TTimeIntervalSeconds interval( 0 );

        if ( aConstraint->GetCounters( counter, originalCounter ) == KErrNone )

            {

            // RO has a count constraint

            AddUsageTimesLeftL( counter, aItems, aIntent );

            }

        if ( aDrmScheme == EDrmSchemeOmaDrm )

            {

            // For OMA DRM only

            CDRMConstraint& drmConstraint = aConstraint->GetConstraint();

            if ( drmConstraint.iActiveConstraints & EConstraintTimedCounter )

                {

                // RO has Timed Counter constraint

                AddUsageTimesLeftL( drmConstraint.iTimedCounter, aItems,

                                    aIntent );

                }

            }

        if ( aConstraint->GetInterval( interval ) == KErrNone )

            {

            // RO has an interval constraint

            // WM DRM duration rights are mapped to the interval constraint

            // (which is not activated).

            TTime intervalStart( 0 );

            // If the file has an interval constraint which is activated,

            // do not add information about the interval to the details view.

            if ( aConstraint->GetIntervalStart( intervalStart ) != KErrNone )

                {

                // File has an interval constraint which is not activated.

                AddUsageTimeLeftL( interval, aItems, EFalse, aIntent );

                }

            }

        if ( aConstraint->GetStartTime( startDateTime ) == KErrNone )

            {

            // RO has a start time constraint

            AddRightsValidFromL( startDateTime, aItems, aIntent );

            }