/*

* Copyright (c) 2005 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: SmilPlayerIndicatorController implementation

*

*/

// INCLUDE FILES

#include <gulicon.h>                // CGulIcon

#include <AknUtils.h>               // AknLayoutUtils

#include <AknsUtils.h>              // AknsUtils

#include <AknStatuspaneUtils.h>     // AknStatuspaneUtils

#include <applayout.cdl.h>

#include <smilplayer.mbg>

#include <AknsConstants.h>

#include <data_caging_path_literals.hrh> 

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <eiklabel.h>

#include <eikimage.h>

#include "SmilPlayerIndicatorController.h"

#include "SmilPlayerPresentationController.h"

#include "SmilPlayerVolumeIndicatorController.h"

#include "SmilPlayerTimeIndicatorTimer.h"

// CONSTANTS

_LIT(KSmilPlayerBitmapFile, "smilplayer.mbm");

const TInt KMilliSecondsToSecondsCoefficient = 1000;

const TInt KColorWhite = 0;

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

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

// CSmilPlayerIndicatorController::CSmilIndicatorControllerler

// C++ constructor 

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

//

CSmilPlayerIndicatorController::CSmilPlayerIndicatorController( 

                                                    CSmilPlayerPresentationController* aPresController ) :

    iPresController( aPresController ),

    iShowTimeIndicator( ETrue )

    {

    }

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

// CSmilPlayerIndicatorController::ConstructL

// Symbian second phase constructor. Sets indicator controller as foreground

// observer so that event about foreground/background changes are received.

// This is needed in order to stop pause timer when SMIL Player is set to 

// background and start it again when SMIL Player is set foreground. Creates

// volume controller if volume is enabled and all other indicator controls and

// their timers.

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

//

void CSmilPlayerIndicatorController::ConstructL( const CCoeControl* aParent, 

                                                 TBool aVolumeEnabled  )

    {

    iCoeEnv->AddForegroundObserverL( *this );

    SetContainerWindowL( *aParent );

    if ( aVolumeEnabled )

        {

        iVolumeController = CSmilPlayerVolumeIndicatorController::NewL( this );

        iVolumeController->SetObserver( this );

        }

    iTimeIndicator = new(ELeave) CEikLabel;

    iTimeIndicator->SetTextL( KNullDesC );

    iTimeIndicator->SetContainerWindowL( *this );

    iTimeIndicator->MakeVisible( EFalse );

    iTimeModel = CSmilPlayerTimeIndicatorTimer::NewL( this, iCoeEnv );

    InitializeIconIndicatorL( iPauseIndicator, 

                              KAknsIIDQgnIndiMmsPause,

                              EMbmSmilplayerQgn_indi_mms_pause,

                              EMbmSmilplayerQgn_indi_mms_pause_mask );

    InitializeIconIndicatorL( iPlayIndicator, 

                              KAknsIIDQgnIndiMmsPlay,

                              EMbmSmilplayerQgn_indi_mms_play,

                              EMbmSmilplayerQgn_indi_mms_play_mask );

    MakeVisible( EFalse );

    }

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

// CSmilPlayerIndicatorController::NewL

// Symbian two phased constructor

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

//

CSmilPlayerIndicatorController*

CSmilPlayerIndicatorController::NewL( const CCoeControl* aParent, 

                                      CSmilPlayerPresentationController* aPresController,

                                      TBool aVolumeEnabled )

    {

    CSmilPlayerIndicatorController* self = new(ELeave) CSmilPlayerIndicatorController( aPresController );

    CleanupStack::PushL( self );

    self->ConstructL( aParent, aVolumeEnabled );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSmilPlayerIndicatorController::~CSmilPlayerIndicatorController

// Destructor

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

//

CSmilPlayerIndicatorController::~CSmilPlayerIndicatorController()

    {

    iCoeEnv->RemoveForegroundObserver( *this );

    delete iVolumeController;

    delete iTimeIndicator;

    delete iTimeModel;

    delete iPauseIndicator;

    delete iPlayIndicator;

    iPresController = NULL; // For LINT

    }

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

// CSmilPlayerIndicatorController::OfferKeyEventL

// Forwards key event to volume controller if present.

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

//

TKeyResponse CSmilPlayerIndicatorController::OfferKeyEventL( const TKeyEvent& aKeyEvent, 

                                                             TEventCode aType )

    {

    TKeyResponse result( EKeyWasNotConsumed );

    if ( iVolumeController )

        {

        result = iVolumeController->OfferKeyEventL( aKeyEvent, aType );

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::CountComponentControls

// Returns number of child controls.

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

//

TInt CSmilPlayerIndicatorController::CountComponentControls() const

    {

    // return nbr of controls inside this container

    TInt result( 3 );

    if ( iVolumeController )

        {

        result++;

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::ComponentControl

// Returns specified child controls.

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

//

CCoeControl* CSmilPlayerIndicatorController::ComponentControl( TInt aIndex ) const

    {

    CCoeControl* result = NULL;

    switch( aIndex )

        {

        case 0:

            {

            result = iPauseIndicator;

            break;

            }

        case 1:

            {

            result = iPlayIndicator;

            break;

            }

        case 2:

            {

            result = iTimeIndicator;

            break;

            }

        case 3:

            {

            result = iVolumeController;

            break;

            }

        default:

            {

            break;

            }

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::Stop

// Indicates that presentation has been stopped. Stops time indicator refreshing.

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

//

void CSmilPlayerIndicatorController::Stop()

    {

    iPauseIndicator->MakeVisible( EFalse );

    iPlayIndicator->MakeVisible( EFalse );

    iTimeModel->Stop();

    }

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

// CSmilPlayerIndicatorController::Start

// Indicates that presentation has been started. Starts time indicator refreshing.

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

//

void CSmilPlayerIndicatorController::Start()

    {

    iPauseIndicator->MakeVisible( ETrue );

    iPlayIndicator->MakeVisible( EFalse );

    iTimeModel->Start();

    }

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

// CSmilPlayerIndicatorController::Pause

// Indicates that presentation has been paused. Pauses time indicator refreshing

// and play indicator is set hidden.

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

//

void CSmilPlayerIndicatorController::Pause()

    {

    iPlayIndicator->MakeVisible( ETrue );

    iPauseIndicator->MakeVisible( EFalse );

    DrawDeferred();

    iTimeModel->Pause();

    }

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

// CSmilPlayerIndicatorController::Resume

// Indicates that presentation has been resumed. Starts time indicator refreshing.

// And prevents time indicator from showing if duration is not finite. Also sets

// play indicator visible.

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

//

void CSmilPlayerIndicatorController::Resume()

    {

    iTimeModel->Resume();

    iPauseIndicator->MakeVisible( ETrue );

    iPlayIndicator->MakeVisible( EFalse );

    DrawDeferred();

    }

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

// CSmilPlayerIndicatorController::EndReached

// Indicates the presentation end has been reached. This notification from presentation

// controller is forwarded to time indicator timer. Also hides play indicator.

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

//

void CSmilPlayerIndicatorController::EndReached()

    {

    iPlayIndicator->MakeVisible( EFalse );

    iTimeModel->EndReached();

    }

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

// CSmilPlayerIndicatorController::VolumeValue

// Asks current volume level from volume controller if present and returns it

// caller. Otherwise return zero.

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

//

TInt CSmilPlayerIndicatorController::VolumeValue() const

    {

    TInt result( 0 );

    if ( iVolumeController )

        {

        result = iVolumeController->VolumeValue();

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::TimeChangedL

// Called by timer indicator timer. Updates time indicator with new time string.

// On landscape mode time indicator is not shown if volume indicator is visible

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

//

void CSmilPlayerIndicatorController::TimeChangedL( const TDesC& aTimeString )

    {

    if ( !iTimeIndicator->IsVisible() )

        {

        if ( iShowTimeIndicator ||

             !iVolumeController || 

             !iVolumeController->IsVisible() )

            {

            iTimeIndicator->MakeVisible( ETrue );

            }

        }       

    iTimeIndicator->SetTextL( aTimeString );

    iTimeIndicator->DrawDeferred();

    }

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

// CSmilPlayerIndicatorController::CurrentTime

// Returns current presentation time.

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

//

TInt CSmilPlayerIndicatorController::CurrentTime() const

    {

    TInt result( 0 );

    if ( iPresController->Presentation() )

        {

        result = iPresController->Presentation()->CurrentTime().Value() / 

                 KMilliSecondsToSecondsCoefficient;

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::PresentationDuration

// Returns presentation duration.

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

//

TInt CSmilPlayerIndicatorController::PresentationDuration() const

    {

    TInt result( 0 );

    if ( iPresController->Presentation() )

        {

        result = iPresController->Presentation()->Duration().Value() /

                 KMilliSecondsToSecondsCoefficient;

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::IsDurationFinite

// Returns whether presentation duration is finite (i.e. not infinite).

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

//

TBool CSmilPlayerIndicatorController::IsDurationFinite() const

    {

    TBool result( EFalse );

    if ( iPresController->Presentation() )

        {

        result = iPresController->Presentation()->Duration().IsFinite();

        }

    return result;

    }

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

// CSmilPlayerIndicatorController::HandleGainingForeground

// Starts pause indicator blinking if presentation is on the paused state. 

// Pause indicator blinking was stopped when player was sent to background so

// that timer would not waste processing time unnecessarely.

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

//

void CSmilPlayerIndicatorController::HandleGainingForeground()

    {

    }

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

// CSmilPlayerIndicatorController::HandleLosingForeground

// Stops the pause indicator blinking if presentation is on paused state.

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

//

void CSmilPlayerIndicatorController::HandleLosingForeground()

    {

    }

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

// CSmilPlayerIndicatorController::LayoutIndicators

// Sets correct layout for indicator controls according current LAF.

// On landscape mode only time indicator or volume indicator is shown at once.

// Both are shown on the same place and time indicator is hidden if volume indicator

// shown.

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

//

void CSmilPlayerIndicatorController::LayoutIndicators()

    {

    TAknLayoutRect smilstatusVolumePane;

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

		smilstatusVolumePane.LayoutRect( Rect(), AknLayout::Navi_pane_tab_elements_Line_1() );

        }

    else

        {

		smilstatusVolumePane.LayoutRect( Rect(), 

                                     AknLayoutScalable_Apps::smil_status_volume_pane() );

        }

    TAknLayoutRect stateIndicatorIcon;

    TAknLayoutText timeLayout;

    if( iPresController->UseWidescreenStatusPane() )

        {            

        TAknLayoutRect naviSmilPane;

         naviSmilPane.LayoutRect(Rect(), AknLayoutScalable_Avkon::navi_smil_pane( 0 ));

        stateIndicatorIcon.LayoutRect( naviSmilPane.Rect(),

                                   AknLayoutScalable_Avkon::navi_smil_pane_g1( 0 ) );

        timeLayout.LayoutText(  naviSmilPane.Rect(),

                            AknLayoutScalable_Avkon::navi_smil_pane_t1() );

        }

    else

        {

    stateIndicatorIcon.LayoutRect( Rect(),

                                   AknLayoutScalable_Apps::smil_status_pane_g1() );

        timeLayout.LayoutText(  Rect(),

                             AknLayoutScalable_Apps::smil_status_pane_t1() );

        }

    if ( iVolumeController )

        {

        iVolumeController->SetRect( smilstatusVolumePane.Rect() );

        }

    TRect timeRect;

    // TODO: Remove hack when changes have been made to LAF.

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        timeRect = smilstatusVolumePane.Rect();

        iShowTimeIndicator = EFalse;

        iTimeIndicator->MakeVisible( EFalse );

        }

    else

        {

        timeRect = timeLayout.TextRect();

        iShowTimeIndicator = ETrue;

        }

    iTimeIndicator->SetRect( timeRect );

    iTimeIndicator->SetFont( timeLayout.Font() );

    TRAP_IGNORE( UpdateTextColorL() );

    TInt align( ELayoutAlignNone );

    switch( timeLayout.Align() )

        {

        case CGraphicsContext::ELeft:

            {

            align = ELayoutAlignLeft;

            break;

            }

        case CGraphicsContext::ECenter:

            {

            align = ELayoutAlignCenter;

            break;

            }

        case CGraphicsContext::ERight:

            {

            align = ELayoutAlignRight;

            break;

            }

        default:

            {

            break;

            }

        }

    iTimeIndicator->SetLabelAlignment( align );

    SetIconIndicatorExtent( iPauseIndicator, stateIndicatorIcon.Rect() );

    SetIconIndicatorExtent( iPlayIndicator, stateIndicatorIcon.Rect() );

    DrawDeferred();

    }

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

// CSmilPlayerIndicatorController::InitializeIconIndicatorL

// Creates and initializes given icon control with specified bitmap and mask.

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

//

void CSmilPlayerIndicatorController::InitializeIconIndicatorL( CEikImage*& aIndicator, 

                                                               const TAknsItemID& aItem, 

                                                               const TInt aBitmapIndex,

                                                               const TInt aMaskIndex ) const

    {

    aIndicator = new(ELeave) CEikImage;

    aIndicator->SetContainerWindowL( *this );

    aIndicator->MakeVisible( EFalse );

    SetIconIndicatorBitmapL( aIndicator, aItem, aBitmapIndex, aMaskIndex );

    }

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

// CSmilPlayerIndicatorController::HandleControlEventL

// Handles control events from volume indicator controller. 

// Sets new volume to presentation if it has been changed.

// On landscape mode toggles time and volume indicators.

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

//

void CSmilPlayerIndicatorController::HandleControlEventL( CCoeControl* aControl, 

                                                          TCoeEvent aEventType )

    {

    if ( aControl == iVolumeController &&

         aEventType == MCoeControlObserver::EEventStateChanged )

        {

        TInt currentVolume( VolumeValue() * 10 );