/*

* Copyright (c) 2004-2007 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:  Popup Volume indicator

*

*/

// INCLUDE FILES

#include "AknVolumePopup.h"

#include <apgwgnam.h>

#include <eiklabel.h>

#include <StringLoader.h>

#include <barsread.h>

#include <Aknvolumecontrol.h>

#include <AknUtils.h>

#include <AknsDrawUtils.h>

#include <aknconsts.h>

#include <aknappui.h>

#include <aknslider.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <skinlayout.cdl.h>

#include <avkon.mbg>

#include <aknbutton.h>

#include <e32math.h>

#include <AknPanic.h>

#include <gulicon.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknWsEventObserver.h>

#include <AknStatuspaneUtils.h>

#include <touchfeedback.h>

#include <AknTasHook.h>

const TInt KSliderUsed = 0xffff;

const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds

const TReal KWidthSpace = 1.3;

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

// ============================================================================

NONSHARABLE_CLASS( CAknVolumePopupExtension ): public CBase,

                                               public MAknWsEventObserver

    {

public:

private:

    CAknVolumePopupExtension();

    void ConstructL();

public:

    ~CAknVolumePopupExtension();

    static CAknVolumePopupExtension* NewL();

    CAknControl* VolumeControl();

    void SetGraphics( TInt aElement, 

                      CFbsBitmap* aBitmap, 

                      CFbsBitmap* aMask );

    void TryLoadDefaultSliderVolumeBitmap();               

    void TryLoadDefaultHorizontalVolumeBitmap(); 

    // from MAknWsEventObserver

    void HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination);

public:

    CAknVolumeControl*  iOldVolumeControl;

    CAknSlider*         iSliderControl;

    TSize iMarkerSize;

    CAknsFrameBackgroundControlContext* iBgContext;

    TBool iUseMutedIcon;

    TBool iSpeakerHidden;

    TInt iSliderUsed;

    CAknVolumePopup* iParent;

    TBool iClosePopupWhenTapped;

    TBool iHaveDefaultValue;

    TInt iDefaultValue;

    TBool iResetDefaultValue;

    TBool iInitialized;

    TBool iHandlingPointerEvent;

    TBool iWindowGroupCreated;

private:

    TBitFlags32 iFlags;

    };

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

// CAknVolumePopupExtension::CAknVolumePopupExtension

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

//

CAknVolumePopupExtension::CAknVolumePopupExtension()

    : iUseMutedIcon(ETrue),

      iClosePopupWhenTapped(ETrue),

      iHaveDefaultValue(EFalse), 

      iDefaultValue(-1),

      iResetDefaultValue(ETrue)

    {

    }

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

// Destructor

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

//

CAknVolumePopupExtension::~CAknVolumePopupExtension()

    {

    delete iSliderControl;

    delete iOldVolumeControl;

    delete iBgContext;

    }

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

// CAknVolumePopupExtension::NewL

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

//

CAknVolumePopupExtension* CAknVolumePopupExtension::NewL()

    {

    CAknVolumePopupExtension* self = new( ELeave ) CAknVolumePopupExtension();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknVolumePopupExtension::ConstructL

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

//

void CAknVolumePopupExtension::ConstructL()

    {

    }

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

// CAknVolumePopupExtension::VolumeControl

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

// 

CAknControl* CAknVolumePopupExtension::VolumeControl()

        {

        if( iSliderUsed == KSliderUsed )

            {

            return iSliderControl;

            }

        return iOldVolumeControl;

        } 

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

// CAknVolumePopupExtension::SetGraphics

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

//

void CAknVolumePopupExtension::SetGraphics( TInt aElement, 

                                       CFbsBitmap* aBitmap, 

                                       CFbsBitmap* aMask )

    {

    // element index is assumed to be valid (no checking)

    if( aElement >= CAknSlider::EElemEmptyLeftCap && 

        aElement <= CAknSlider::EElemMarkerSelected )

        {

        iSliderControl->SetGraphics( aElement , aBitmap, aMask );

        }

    }

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

// CAknVolumePopupExtension::TryLoadDefaultSliderVolumeBitmap

//

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

//     

void CAknVolumePopupExtension::TryLoadDefaultSliderVolumeBitmap()

    {

    iSliderControl->SetGraphics( CAknSlider::EElemTickMark, NULL, NULL );

    }                         

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

// CAknVolumePopupExtension::TryLoadDefaultHorizontalVolumeBitmap

//

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

//     

void CAknVolumePopupExtension::TryLoadDefaultHorizontalVolumeBitmap()

    {

    const TInt iconIDArray[] = 

        {

        EMbmAvkonQgn_graf_volume_small_off,        

        EMbmAvkonQgn_graf_volume_small_on,

        EMbmAvkonQgn_graf_nslider_marker,

        EMbmAvkonQgn_graf_nslider_marker_selected

        };

    const TInt iconMaskIDArray[] = 

        {

        EMbmAvkonQgn_graf_volume_small_off_mask,        

        EMbmAvkonQgn_graf_volume_small_on_mask,

        EMbmAvkonQgn_graf_nslider_marker_mask,

        EMbmAvkonQgn_graf_nslider_marker_selected_mask

        }; 

    const TAknsItemID iconSkinIDArray[] = 

        {

        KAknsIIDQgnGrafVolumeSmallOff,        

        KAknsIIDQgnGrafVolumeSmallOn,

        KAknsIIDQgnGrafNsliderMarker,

        KAknsIIDQgnGrafNsliderMarkerSelected

        };

    const TInt element[] = 

        {

        CAknSlider::EElemEmptyLine,

        CAknSlider::EElemFilledLine,

        CAknSlider::EElemMarker,

        CAknSlider::EElemMarkerSelected

        };

    TInt count = sizeof( iconIDArray )/sizeof(TInt);

    TInt err = KErrNone;

    CFbsBitmap* bitmapPtr = NULL;

    CFbsBitmap* maskPtr = NULL;    

    for ( TInt i = 0; i < count; i++ )

        {

        //find new graphic from Skinned bitmap

        TRAP(err, AknsUtils::CreateIconL( AknsUtils::SkinInstance(),

            iconSkinIDArray[i],

            bitmapPtr,

            maskPtr,

            KNullDesC,

            iconIDArray[i],

            iconMaskIDArray[i] ));

        // find new graphic from mif file

       if ( err )

            {

             TRAP(err,AknIconUtils::CreateIconL(

                bitmapPtr,

                maskPtr,

                KAvkonBitmapFile,

                iconIDArray[i],

                iconMaskIDArray[i] ));      

            } 

        if( !err )

            {

            iSliderControl->SetGraphics( element[i], bitmapPtr, maskPtr );

            }          

        }

    }   

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

// CAknVolumePopupExtension::HandleWsEventL

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

//    

void CAknVolumePopupExtension::HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination)

    {

    if( aEvent.Type() == EEventPointer )

        {

        // Touch outside of volume popup, close volume popup

        if( iClosePopupWhenTapped && 

            aEvent.Pointer()->iType == TPointerEvent::EButton1Down &&

            aDestination != iParent )

            {

            MTouchFeedback* feedback = MTouchFeedback::Instance();

            if ( feedback )

                {

                feedback->InstantFeedback( ETouchFeedbackPopUp );

                }

            iParent->CloseVolumePopup();

            }

        }

    }

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

// CAknVolumePopup::CAknVolumePopup

//

//

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

//

CAknVolumePopup::CAknVolumePopup(TInt aFlags):

    iFlags(aFlags),

    iAdjustmentIndicatorOn(ETrue),

    iVertical(EFalse),

    iTimeout(0)

    {

    }

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

// CAknVolumePopup::ConstructFromResourceL

// 

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

//

EXPORT_C CAknVolumePopup* CAknVolumePopup::ConstructFromResourceL(

                                                           TInt aResourceId )

    {

    // create volume control

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );

    TInt flags = -1;

    TInt sliderType = reader.ReadInt16();

    if ( sliderType == EAknSliderWithFeedbackStyle )

        {

        TInt feedbackStyle = (TAknFeedbackStyle)reader.ReadInt16();

        flags = reader.ReadInt16();

        }

    else

        {

        flags = sliderType;

        }

    if( flags == -1) // 0xffff

        {

        flags = reader.ReadInt16();

        }        

    if( flags == ENaviPaneVolumeControl ||

        flags == EDynRangeNaviPaneVolumeControl ) 

        {

        CAknVolumePopup* self = new( ELeave ) CAknVolumePopup( KSliderUsed );

        CleanupStack::PopAndDestroy(); // reader

        CleanupStack::PushL( self );

        self->ConstructL( NULL, EFalse, aResourceId );

        CleanupStack::Pop();

        return self;   

        }

    else

        {

    	CAknVolumePopup* self = new( ELeave ) CAknVolumePopup(0);

    	CleanupStack::PopAndDestroy(); // reader

        CleanupStack::PushL( self );

        self->ConstructL( NULL, EFalse, aResourceId );

        CleanupStack::Pop();

        return self;    

        }

    }

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

// CAknVolumePopup::NewL

//

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

//

EXPORT_C CAknVolumePopup* CAknVolumePopup::NewL( CCoeControl* aParent,

                                                     TBool aIsVertical )

    {

    CAknVolumePopup* self = new( ELeave ) CAknVolumePopup(KSliderUsed);

    CleanupStack::PushL( self );

    if( aIsVertical )

        {

        self->ConstructL( aParent, ETrue, R_AVKON_VERTICAL_POPUP_SLIDER );

        }

    else

        {

        self->ConstructL( aParent, aIsVertical, R_AVKON_HORIZONTAL_POPUP_SLIDER );

        }

    CleanupStack::Pop();

    AKNTASHOOK_ADDL( self, "CAknVolumePopup" );

    return self;    

    }

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

// CAknVolumePopup::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknVolumePopup::ConstructL( CCoeControl* aParent, 

                                  TBool aIsVertical, 

                                  TInt aResourceId )

    {

    iExt = CAknVolumePopupExtension::NewL();

    iVertical = aIsVertical;

    iExt->iSliderUsed = iFlags;

    iExt->iParent = this;

   // create inactivity timer

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

    // create volume control

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC( reader, aResourceId );

    TInt sliderType = reader.ReadInt16();

    if ( sliderType == EAknSliderWithFeedbackStyle )

        {

        TInt feedbackStyle = (TAknFeedbackStyle)reader.ReadInt16();

        iFlags = reader.ReadInt16();

        }

    else

        {

        iFlags = sliderType;

        }

    if( iFlags == -1) // 0xffff

        {

        iFlags = reader.ReadInt16();

        reader.Rewind( 2 );

        }

    reader.Rewind( 2 );

    if ( iFlags == EPopupVolumeControl )

        {

         //use the new style popup volume control

        iFlags = ESmallPopupVolumeControl;

        }

    if( !aParent && (iFlags == ENaviPaneVolumeControl ||

         iFlags == EDynRangeNaviPaneVolumeControl ))

        {

        CreateWindowL();

        DrawableWindow()->SetOrdinalPosition(0, ECoeWinPriorityNeverAtFront);

        }

    else if( !aParent )

        {

        // create a window group for volume popup

        // needed to prevent apps noticing this window

        RWsSession& wsSession = iCoeEnv->WsSession();

        iWindowGroup = RWindowGroup( wsSession );

        User::LeaveIfError( iWindowGroup.Construct( (TUint32) &iWindowGroup, EFalse ) );

        iWindowGroup.AutoForeground(EFalse);

        CApaWindowGroupName* name = CApaWindowGroupName::NewLC( wsSession,

                                                                (TUint32) &iWindowGroup );

        name->SetHidden( ETrue );

        name->SetCaptionL( KVolumePopupWgName ); // FIXME - KSomeUniqueName, available to OOM watcher so this won't be closed

        User::LeaveIfError( name->SetWindowGroupName( iWindowGroup ));

        CleanupStack::PopAndDestroy();  //name

        iWindowGroup.SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );

         // create control's window to own window group

        CreateWindowL( &iWindowGroup );

        //catch other windows poninter 

        Window().SetNonFading(ETrue); 

        iExt->iWindowGroupCreated = ETrue;

        }

    else

        {

        CreateWindowL( aParent );

        }

    if ( CAknEnv::Static()->TransparencyEnabled() )

        {

        Window().SetRequiredDisplayMode( EColor16MA );

        Window().SetTransparencyAlphaChannel();

        Window().SetBackgroundColor(TRgb(~0));

        }

    Window().SetShadowDisabled(ETrue);

    // Values received from the navi pane volume control resource.

    TInt value    = KErrNotFound;

    TInt minvalue = KErrNotFound;

    TInt maxvalue = KErrNotFound;

    if( iExt->iSliderUsed != KSliderUsed )

        {

        iExt->iOldVolumeControl = new( ELeave )CAknVolumeControl;

        if ( AknLayoutUtils::PenEnabled() )

            iExt->VolumeControl()->SetContainerWindowL(*this);

        iExt->iOldVolumeControl->ConstructFromResourceL(reader);	

        }

    else if( iVertical ||

         iFlags == ENaviPaneVolumeControl ||

         iFlags == EDynRangeNaviPaneVolumeControl )

        {

         //use the vertical slider

        iExt->iSliderControl = new( ELeave )CAknSlider;

        iExt->iSliderControl->SetBackground( this );

        if ( iFlags == ENaviPaneVolumeControl ||

             iFlags == EDynRangeNaviPaneVolumeControl )

            {

            // Navi pane shows vertical volume popup instead of the old navi

            // pane volume control, but the old style volume control must

            // be also created in order to preserve BC.

            // Read and set the initial value and range from the resource

            // before passing it to the CAknVolumeControl.

            TInt int16Length( sizeof( TInt16 ) );

            reader.Advance( int16Length ); // identifier or flags

            if ( iFlags == EDynRangeNaviPaneVolumeControl )

                {

                reader.Advance( int16Length ); // flags

                }

            value = reader.ReadInt16();

            if ( iFlags == EDynRangeNaviPaneVolumeControl )

                {

                TPtrC filename = reader.ReadTPtrC();

                reader.Advance( 2 * int16Length ); // bitmap and mask ID

                minvalue = reader.ReadInt16();

                maxvalue = reader.ReadInt16();

                reader.Rewind( 4 * int16Length );

                reader.Rewind( filename.Size() + int16Length ); // filename + length heading

                reader.Rewind( 3 * int16Length );

                }

            else

                {

                reader.Rewind( 2 * int16Length );

                }

            iVertical = ETrue;

            iExt->iOldVolumeControl = new ( ELeave ) CAknVolumeControl;

            iExt->iOldVolumeControl->SetContainerWindowL(*this);

            iExt->iOldVolumeControl->ConstructFromResourceL( reader );

            iExt->iOldVolumeControl->SuppressDrawing( ETrue );

            // Old volume control was created with the navi pane volume control

            // resource, slider resource is used to create the slider control.

            CleanupStack::PopAndDestroy(); // reader

            iCoeEnv->CreateResourceReaderLC( reader, R_AVKON_VERTICAL_POPUP_SLIDER );

            }

        if(AknLayoutUtils::PenEnabled())

            iExt->VolumeControl()->SetContainerWindowL(*this);

        iExt->iSliderControl->ConstructFromResourceL(this, 0, reader);

        iExt->TryLoadDefaultSliderVolumeBitmap();

        iExt->iSliderControl->ReportMarkerDragEvent( ETrue );

        iExt->iSliderControl->SuppressDrawing( ETrue );

    else

        {

        iExt->iSliderControl = new( ELeave )CAknSlider;