/*

* 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: Volume bar control

*

*/

// Version : %version: 15 %

// INCLUDE FILES

#include <eikenv.h>

#include <gulicon.h>

#include <gulfont.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <data_caging_path_literals.hrh>

#include <aknlayoutscalable_avkon.cdl.h>

#include <mpxvideoplaybackcontrols.mbg>

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackvolumebar.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideo_debug.h"

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

// CONSTANTS

const TInt KMPXSliderHeight = 30;

const TInt KMPXSliderWidth = 18;

const TInt KMPXVolumeBarWidth = 24;

const TInt KMPXVolumeDragEventTimeOut = 100000;

const TInt KMPXPtrEventRepeatRequestTime = 200000;

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

CMPXVideoPlaybackVolumeBar::CMPXVideoPlaybackVolumeBar(

    CMPXVideoPlaybackControlsController* aController, TRect aRect )

    : iOneVolumeIncrementHeight(0)

    , iMuted(EFalse)

    , iRect(aRect)

    , iDragging(EVolumeNotDragging)

    , iController(aController)

{

}

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

// CMPXVideoPlaybackVolumeBar::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackVolumeBar::ConstructL()

{

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

    SetLayout();

    SkinChangeL();

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

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#endif //RD_TACTILE_FEEDBACK

}

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

// CMPXVideoPlaybackVolumeBar::NewL()

// Two-phased constructor.

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

//

CMPXVideoPlaybackVolumeBar* CMPXVideoPlaybackVolumeBar::NewL(

    CMPXVideoPlaybackControlsController* aController, TRect aRect )

{

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

    CMPXVideoPlaybackVolumeBar* self =

        new ( ELeave ) CMPXVideoPlaybackVolumeBar( aController, aRect );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CMPXVideoPlaybackVolumeBar::~CMPXVideoPlaybackVolumeBar()

// Destructor.

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

//

CMPXVideoPlaybackVolumeBar::~CMPXVideoPlaybackVolumeBar()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackVolumeBar::~CMPXVideoPlaybackVolumeBar()"));

    if ( iDraggingHandlerTimer )

    {

        iDraggingHandlerTimer->Cancel();

        delete iDraggingHandlerTimer;

        iDraggingHandlerTimer = NULL;

    }

    if (iSpeakerIcon)

    {

       delete iSpeakerIcon;

       iSpeakerIcon = NULL;

    }

    if (iSpeakerMuteIcon)

    {

       delete iSpeakerMuteIcon;

       iSpeakerMuteIcon = NULL;

    }

    if (iSliderIcon)

    {

       delete iSliderIcon;

       iSliderIcon = NULL;

    }

    if (iSliderSelectedIcon)

    {

       delete iSliderSelectedIcon;

       iSliderSelectedIcon = NULL;

    }

    if (iVolumeUpIcon)

    {

       delete iVolumeUpIcon;

       iVolumeUpIcon = NULL;

    }

    if (iVolumeDownIcon)

    {

       delete iVolumeDownIcon;

       iVolumeDownIcon = NULL;

    }

    if (iVolumeFrameIconTop)

    {

        delete iVolumeFrameIconTop;

        iVolumeFrameIconTop = NULL;

    }

    if (iVolumeFrameIconMiddle)

    {

        delete iVolumeFrameIconMiddle;

        iVolumeFrameIconMiddle = NULL;

    }

    if (iVolumeFrameIconBottom)

    {

        delete iVolumeFrameIconBottom;

        iVolumeFrameIconBottom = NULL;

    }

    if (iNoAudioIcon)

    {

       delete iNoAudioIcon;

       iNoAudioIcon = NULL;

    }

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif //RD_TACTILE_FEEDBACK

}

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

// CMPXVideoPlaybackVolumeBar::HandleResourceChange()

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

//

void CMPXVideoPlaybackVolumeBar::HandleResourceChange( TInt aType )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackVolumeBar::HandleResourceChange(0x%X)"), aType);

    if ( aType == KAknsMessageSkinChange )

    {

        TRAP_IGNORE( SkinChangeL() );

    }

    CCoeControl::HandleResourceChange( aType );

}

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

// CMPXVideoPlaybackVolumeBar::SetLayout()

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

//

void CMPXVideoPlaybackVolumeBar::SetLayout()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackVolumeBar::SetLayout()"));

    //

    // Calculate icon rects

    //

    iRect = TRect(0, 0, iRect.Width(), iRect.Height() );

    TInt volumeUpDownIndicatorSize = iRect.Width() / 3;

    iVolumeControlRect = TRect( volumeUpDownIndicatorSize,

                                iRect.iTl.iY,

                                iRect.iBr.iX,

                                iRect.iTl.iY + iRect.Height() * 4 / 5 );

    iVolumeBarRect =  TRect( iVolumeControlRect.iTl.iX + iVolumeControlRect.Width() / 3,

                             iVolumeControlRect.iTl.iY + iVolumeControlRect.Height() / 20,

                             iVolumeControlRect.iTl.iX + iVolumeControlRect.Width() / 3 * 2,

                             iVolumeControlRect.iTl.iY + iVolumeControlRect.Height() );

    iVolumeBarRectTop = TRect( iRect.Width() / 2 - KMPXVolumeBarWidth / 2 ,

                               iVolumeBarRect.iTl.iY,

                               iRect.Width() / 2 + KMPXVolumeBarWidth / 2,

                               iVolumeBarRect.iTl.iY + iVolumeBarRect.Height() / 10 );

    iVolumeBarRectMiddle = TRect( iVolumeBarRectTop.iTl.iX,

                                  iVolumeBarRectTop.iBr.iY,

                                  iVolumeBarRectTop.iBr.iX,

                                  iVolumeBarRectTop.iBr.iY + iVolumeBarRectTop.Height() * 8 );

    iVolumeBarRectBottom = TRect( iVolumeBarRectTop.iTl.iX,

                                  iVolumeBarRectMiddle.iBr.iY,

                                  iVolumeBarRectTop.iBr.iX,

                                  iVolumeBarRect.iBr.iY );

    iSliderRect = TRect( iRect.Width() / 2 - KMPXSliderWidth / 2 + 3,

                         iVolumeBarRect.iBr.iY - KMPXSliderHeight,

                         iRect.Width() / 2 + KMPXSliderWidth / 2 + 3,

                         iVolumeBarRect.iBr.iY );

    iVolumeUpControlRect = TRect( iRect.iTl,

                           TSize( volumeUpDownIndicatorSize,

                                  iVolumeControlRect.Height() / 2 ) );

    iVolumeDownControlRect = TRect( TPoint ( iRect.iTl.iX, iVolumeControlRect.Height() / 2 ),

                                    iVolumeUpControlRect.Size() );

    iVolumeUpRect = TRect( iVolumeUpControlRect.iTl.iX + 2,

                           iVolumeUpControlRect.iTl.iY + 8,

                           iVolumeUpControlRect.iBr.iX + 2,

                           iVolumeUpControlRect.iTl.iY + volumeUpDownIndicatorSize );

    iVolumeDownRect = TRect( iVolumeUpRect.iTl.iX,

                             iVolumeDownControlRect.iBr.iY - volumeUpDownIndicatorSize,

                             iVolumeUpRect.iBr.iX,

                             iVolumeDownControlRect.iBr.iY  );

    iSpeakerControlRect = TRect( TPoint( iRect.iTl.iX, iVolumeControlRect.iBr.iY ),

                                 iRect.iBr );

    iSpeakerRect = TRect( iSpeakerControlRect.iTl.iX + iSpeakerControlRect.Width() / 5,

                          iSpeakerControlRect.iTl.iY + iSpeakerControlRect.Height() / 5,

                          iSpeakerControlRect.iBr.iX - iSpeakerControlRect.Width() / 5,

                          iSpeakerControlRect.iBr.iY - iSpeakerControlRect.Height() / 5 );

    iOneVolumeIncrementHeight = (TReal)( iVolumeBarRect.Height() - KMPXSliderHeight )

                                / (TReal)KPbPlaybackVolumeLevelMax;

}

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

// CMPXVideoPlaybackVolumeBar::SkinChangeL()

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

//

void CMPXVideoPlaybackVolumeBar::SkinChangeL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackVolumeBar::SkinChangeL()"));

    //

    // Create icons

    //

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath;

    iController->LocateBitmapFileL( iconsPath );

    delete iSpeakerIcon;

    iSpeakerIcon = NULL;

    iSpeakerIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiNsliderUnmuted,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_unmuted,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_unmuted_mask );

    if ( iSpeakerIcon )

    {

        AknIconUtils::SetSize( iSpeakerIcon->Bitmap(),

                               iSpeakerRect.Size(),

                               EAspectRatioPreserved );

    }

    delete iSpeakerMuteIcon;

    iSpeakerMuteIcon = NULL;

    iSpeakerMuteIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiNsliderMuted,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_muted,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_muted_mask );

    if ( iSpeakerMuteIcon )

    {

        AknIconUtils::SetSize( iSpeakerMuteIcon->Bitmap(),

                               iSpeakerRect.Size(),

                               EAspectRatioPreserved );

    }

    delete iNoAudioIcon;

    iNoAudioIcon = NULL;

    iNoAudioIcon = AknsUtils::CreateGulIconL(

            skin,

            KAknsIIDQgnGrafMupLstCorrupttrack,

            iconsPath,

            EMbmMpxvideoplaybackcontrolsQgn_graf_mup_lst_corrupttrack,

            EMbmMpxvideoplaybackcontrolsQgn_graf_mup_lst_corrupttrack_mask );

    if ( iNoAudioIcon )

    {

        AknIconUtils::SetSize( iNoAudioIcon->Bitmap(),

                               iSpeakerRect.Size(),

                               EAspectRatioPreserved );

    }

    delete iSliderIcon;

    iSliderIcon = NULL;

    iSliderIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnGrafNsliderVerticalMarker,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_marker,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_marker_mask );

    if ( iSliderIcon )

    {

        AknIconUtils::SetSize( iSliderIcon->Bitmap(),

                               TSize(KMPXSliderWidth, KMPXSliderHeight),

                               EAspectRatioNotPreserved );

    }

    delete iSliderSelectedIcon;

    iSliderSelectedIcon = NULL;

    iSliderSelectedIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnGrafNsliderVerticalMarkerSelected,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_marker_selected,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_marker_selected_mask );

    if ( iSliderSelectedIcon )

    {

        AknIconUtils::SetSize( iSliderSelectedIcon->Bitmap(),

                               TSize(KMPXSliderWidth, KMPXSliderHeight),

                               EAspectRatioNotPreserved );

    }

    delete iVolumeUpIcon;

    iVolumeUpIcon = NULL;

    iVolumeUpIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiCam4ZoomMax,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_level_increase,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_level_increase_mask );

    if ( iVolumeUpIcon )

    {

        AknIconUtils::SetSize( iVolumeUpIcon->Bitmap(),

                               iVolumeUpRect.Size(),

                               EAspectRatioPreserved );

    }

    delete iVolumeDownIcon;

    iVolumeDownIcon = NULL;

    iVolumeDownIcon = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiCam4ZoomMin,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_level_decrease,

		    EMbmMpxvideoplaybackcontrolsQgn_indi_nslider_level_decrease_mask );

    if ( iVolumeDownIcon )

    {

        AknIconUtils::SetSize( iVolumeDownIcon->Bitmap(),

                               iVolumeDownRect.Size(),

                               EAspectRatioPreserved );

    }

    delete iVolumeFrameIconTop;

    iVolumeFrameIconTop = NULL;

    iVolumeFrameIconTop = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiCam4ZoomTop,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_top,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_top_mask );

    if ( iVolumeFrameIconTop )

    {

        AknIconUtils::SetSize( iVolumeFrameIconTop->Bitmap(),

                               TSize( KMPXVolumeBarWidth, iVolumeBarRectTop.Height() ),

                               EAspectRatioNotPreserved );

    }

    delete iVolumeFrameIconMiddle;

    iVolumeFrameIconMiddle = NULL;

    iVolumeFrameIconMiddle = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiCam4ZoomMiddle,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_middle,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_middle_mask );

    if ( iVolumeFrameIconMiddle )

    {

        AknIconUtils::SetSize( iVolumeFrameIconMiddle->Bitmap(),

                               TSize( KMPXVolumeBarWidth, iVolumeBarRectMiddle.Height() ),

                               EAspectRatioNotPreserved );

    }

    delete iVolumeFrameIconBottom;

    iVolumeFrameIconBottom = NULL;

    iVolumeFrameIconBottom = AknsUtils::CreateGulIconL(

            skin,

		    KAknsIIDQgnIndiCam4ZoomBottom,

		    iconsPath,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_bottom,

		    EMbmMpxvideoplaybackcontrolsQgn_graf_nslider_vertical_bottom_mask );

    if ( iVolumeFrameIconBottom )

    {

        AknIconUtils::SetSize( iVolumeFrameIconBottom->Bitmap(),

                               TSize( KMPXVolumeBarWidth, iVolumeBarRectBottom.Height() ),

                               EAspectRatioNotPreserved );

    }

}

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

//   CMPXVideoPlaybackVolumeBar::HandleVolumeIncreaseL

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

//

void CMPXVideoPlaybackVolumeBar::HandleVolumeIncreaseL( const TPointerEvent& aPointerEvent )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackVolumeBar::HandleVolumeIncreaseL()"));

    switch ( aPointerEvent.iType )

    {

        case TPointerEvent::EButtonRepeat: 

        {    

#ifdef RD_TACTILE_FEEDBACK 

            if ( iFeedback ) 

            { 

#ifdef SYMBIAN_BUILD_GCE

                iFeedback->InstantFeedback( ETouchFeedbackSlider );

#else

                iFeedback->InstantFeedback( ETouchFeedbackSensitive );

#endif //SYMBIAN_BUILD_GCE 

            } 

#endif //RD_TACTILE_FEEDBACK                 

            iController->HandleCommandL( EMPXPbvCmdIncreaseVolume );

            iDragging = EVolumeIncreaseDragging;

        }    

        case TPointerEvent::EButton1Down: 

        { 

            Window().RequestPointerRepeatEvent( 

                         TTimeIntervalMicroSeconds32(KMPXPtrEventRepeatRequestTime) 

                         ,iVolumeUpControlRect); 

            break;

        } 

        case TPointerEvent::EDrag:

        {

            iDragging = EVolumeIncreaseDragging;

            break;

        }

        case TPointerEvent::EButton1Up:

        {

#ifdef RD_TACTILE_FEEDBACK

            if ( iFeedback )

            {

#ifdef SYMBIAN_BUILD_GCE

                iFeedback->InstantFeedback( ETouchFeedbackSlider );

#else

                iFeedback->InstantFeedback( ETouchFeedbackBasic );

#endif //SYMBIAN_BUILD_GCE       

            }

#endif //RD_TACTILE_FEEDBACK

            iController->HandleCommandL( EMPXPbvCmdIncreaseVolume );

            iDragging = EVolumeNotDragging;

            break;

        }

    }

}

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

//   CMPXVideoPlaybackVolumeBar::HandleVolumeDecreaseL

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

//

void CMPXVideoPlaybackVolumeBar::HandleVolumeDecreaseL( const TPointerEvent& aPointerEvent )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackVolumeBar::HandleVolumeDecreaseL()"));

    switch ( aPointerEvent.iType )

    {

        case TPointerEvent::EButtonRepeat: 

        {    

#ifdef RD_TACTILE_FEEDBACK 

            if ( iFeedback )