/*
* Copyright (c) 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:    Volume control implementation
*
*/




// INCLUDE FILES
#include "shwslideshowvolumecontrol.h"

#include <alf/alfdisplay.h>
#include <alf/alftexture.h>
#include <alf/alfimage.h>
#include <alf/alfimagevisual.h>
#include <alf/alftextvisual.h>

#include <alf/alfgridlayout.h>
#include <alf/alfdecklayout.h>
#include <alf/alfanchorlayout.h>
#include <alf/alfanchorlayout.h>
#include <alf/alfimagebrush.h>
#include <alf/alfroster.h>
#include <alf/alfbrusharray.h>

#include <data_caging_path_literals.hrh>
#include <AknsUtils.h>          // skins
#include <glxicons.mbg>
#include <avkon.mbg>
#include <glxresourceutilities.h>   // for CGlxResourceUtilities

#include <AknUtils.h>
#include <StringLoader.h>

#include <glxlog.h>
#include <glxtracer.h>
#include <shwslideshowview.rsg>

#include "glxuiutility.h"
#include "glxtexturemanager.h"
#include "shwcallback.h"

// CONSTANTS
namespace
    {
    const TInt KShwVolumeControlXOffset = 0;
    _LIT( KIconsFilename, "glxicons.mif" );
    const TInt KShwVolumeControlWidthScaleFactor = 2;
    const TInt KShwVolumeMaxPercent = 100;
    const TInt KShwVolumeTextMaxLineCount = 1;   
    const TReal KControlWidthMultiplier = 0.2;
    const TReal KControlHeightMultiplier = 0.12;
    const TReal KOpacityOpaque = 1.0;
    const TReal KHalfOpacityOpaque = 0.4;
    const TReal KOpacityTransperent = 0.0;
    const TInt KValueGridCols = 2;
    const TInt KValueGridRows = 1;
    }
    
//! NOTE : This implementation does not go with the current Slide Show UI Spec 1.1
// UI specs need to be updated and a fine print needs to pe prepared about the 
// LAF of this control
// In that case the visual positioning can be adjusted by paddin and giving weights

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CShwSlideshowVolumeControl()
// ---------------------------------------------------------------------------
inline CShwSlideshowVolumeControl::CShwSlideshowVolumeControl( CAlfEnv& aEnv,
		CGlxUiUtility& aUtility, TTimeIntervalMicroSeconds32 aInterval)
		: iUtility(aUtility), iInterval(aInterval),iAlfEnv(aEnv)
	{
	}

// ---------------------------------------------------------------------------
// ~CShwSlideshowVolumeControl
// ---------------------------------------------------------------------------
CShwSlideshowVolumeControl::~CShwSlideshowVolumeControl()
	{
	TRACER("CShwSlideshowVolumeControl::~CShwSlideshowVolumeControl");
	GLX_LOG_INFO("CShwSlideshowVolumeControl::~CShwSlideshowVolumeControl" );
	// visuals
	if (iMainVisual)
        {
        iMainVisual->RemoveAndDestroyAllD();
        iMainVisual = NULL;
        }
	// timer
	if ( iTimer )
	    {
	    iTimer->Cancel();
	    }
	delete iTimer;
	}
	
// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------	
CShwSlideshowVolumeControl* CShwSlideshowVolumeControl::NewL(
	CAlfEnv& aEnv,
	CGlxUiUtility& aUtility,
    TTimeIntervalMicroSeconds32 aInterval)
	{
	TRACER("CShwSlideshowVolumeControl::NewL");
	GLX_LOG_INFO("CShwSlideshowVolumeControl::NewL" );
	CShwSlideshowVolumeControl* self = new( ELeave ) 
	    CShwSlideshowVolumeControl( aEnv, aUtility, aInterval );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}
	
// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::ConstructL()
    {
    TRACER("CShwSlideshowVolumeControl::ConstructL");
    GLX_LOG_INFO("CShwSlideshowVolumeControl::ConstructL" );
	// Construct the base class.
	CAlfControl::ConstructL(iAlfEnv);
	
	//----------------------- LAYOUT HIERARCHY -------------------------------
	//
	//						 	 ->iBackgroundImageVisual
	//							|
	//							|					  ->iSpeakerImageVisual
	//							|					 |
	// iMainVisual-->iVisualDeck ->iValueGridVisual->
	//							|					 |
	//							|					  ->iPercentTextVisual
	//							|
	//							 ->iMuteImageVisual
	//
	//-------------------------------------------------------------------------
	
    iMainVisual = CAlfAnchorLayout::AddNewL(*this);
    
    iVisualDeck = CAlfDeckLayout::AddNewL(*this,iMainVisual);
    
    iValueGridVisual = CAlfGridLayout::AddNewL(*this,KValueGridCols,
    										KValueGridRows,iVisualDeck);
    
    // The visual elements of the control
    iBackgroundImageVisual = CAlfImageVisual::AddNewL(*this,iVisualDeck);
    iMuteImageVisual = CAlfImageVisual::AddNewL(*this,iVisualDeck);
    iSpeakerImageVisual = CAlfImageVisual::AddNewL(*this,iValueGridVisual);
    iPercentTextVisual = CAlfTextVisual::AddNewL(*this,iValueGridVisual);
    
    // BackGround Visual
    iBackgroundImageVisual->EnableBrushesL();
    iBackgroundImageVisual->SetOpacity( KHalfOpacityOpaque );
	
	//hide the volume level visualation by default
	iMainVisual->SetOpacity(KOpacityTransperent);

	// Only create the timer if an interval's been specified - 
	// default is to not use one.
	if ( iInterval.Int() != 0 )
		{
        iTimer = CPeriodic::NewL( CActive::EPriorityStandard );
		}
    }

// ---------------------------------------------------------------------------
// SetVolume
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::SetVolume(TInt aVolume, TInt aMaxVolume)
	{
	TRACER("CShwSlideshowVolumeControl::SetVolume");
	// Only allow positive values and
	// ensure that aVolume never exceeds aMaxVolume
	if ( aMaxVolume >= 0 && aVolume >= 0 && aVolume <= aMaxVolume )
		{
		iVolume = aVolume;
		iMaxVolume = aMaxVolume;
		}
	}

// ---------------------------------------------------------------------------
// Refresh
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::RefreshL()
	{
	TRACER("CShwSlideshowVolumeControl::RefreshL");
	if( ShowControlL() )
	    {
	    if ( iTimer )
	        {
	        // Restart the timer
	        iTimer->Cancel();
	        iTimer->Start(iInterval, iInterval, TShwCallBack< 
	                CShwSlideshowVolumeControl, 
	                &CShwSlideshowVolumeControl::TimerCallback> (this));
	        }
	    }
	}
	
// ---------------------------------------------------------------------------
// Hide
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::Hide()
	{
	TRACER("CShwSlideshowVolumeControl::Hide");
	// Hide our self
	CAlfDisplay* display = iUtility.Display();
	CAlfControlGroup* group = ControlGroup();

	if ( display && group )
		{
		CAlfRoster& roster = display->Roster();
		roster.Hide( *group );
		}	
	}

// ---------------------------------------------------------------------------
// InitControlTextureL
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::InitControlTextureL()
    {
    TRACER("CShwSlideshowVolumeControl::InitControlTextureL");
    // Get the icon file
    TFileName mifFile( KDC_APP_BITMAP_DIR );
    mifFile.Append( KIconsFilename );
    User::LeaveIfError( CompleteWithAppPath( mifFile ) );
    // Get the texture manager
    CGlxTextureManager& textureMgr = iUtility.GlxTextureManager();
    // Load the background texture
    
    // Below given icon ID is to be changed once the Capped_element Icon
    // is available in the build
    CAlfTexture& backgroundTexture = textureMgr.CreateIconTextureL
        ( EMbmGlxiconsQgn_graf_adapt_search_bg, mifFile );
    
    // apply an image brush to the visual
    iBrush = CAlfImageBrush::NewL(iAlfEnv, TAlfImage( backgroundTexture ) );
    iBackgroundImageVisual->Brushes()->AppendL( iBrush, EAlfHasOwnership );
    iBackgroundImageVisual->SetScaleMode( CAlfImageVisual::EScaleFitInside );
    // Muted visual
    CAlfTexture& textureMuted = iUtility.GlxTextureManager().CreateIconTextureL
        ( EMbmGlxiconsQgn_indi_mup_speaker_muted, mifFile );                                        
    iMuteImageVisual->SetImage( textureMuted );
    iMuteImageVisual->SetScaleMode( CAlfImageVisual::EScaleFitInside );
    
    // Speaker visual
    CAlfTexture& textureSpkr = iUtility.GlxTextureManager().CreateIconTextureL
        ( EMbmGlxiconsQgn_indi_mup_speaker, mifFile );
    iSpeakerImageVisual->SetImage( textureSpkr );
    iSpeakerImageVisual->SetScaleMode( CAlfImageVisual::EScaleFitInside );      
    }

// ---------------------------------------------------------------------------
// ShowControlL
// ---------------------------------------------------------------------------
TBool CShwSlideshowVolumeControl::ShowControlL()
    {
    TRACER("CShwSlideshowVolumeControl::Refresh");
    TBool retVal = EFalse;
    // Hide and show our self
    CAlfDisplay* display = iUtility.Display();
    CAlfControlGroup* group = ControlGroup();

    if ( display && group )
        {
        CAlfRoster& roster = display->Roster();
        roster.Hide( *group );
        roster.ShowL( *group, KAlfRosterShowAtTop );
        retVal = ETrue;
        }  
    return retVal;  
    }
	
// ---------------------------------------------------------------------------
// TimerCallback
// ---------------------------------------------------------------------------
TInt CShwSlideshowVolumeControl::TimerCallback()
    {
    TRACER("CShwSlideshowVolumeControl::TimerCallback");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::TimerCallback" );
    // Timed out so hide ourself
    Hide();
    if ( iTimer )
        {
        // Cancel the timer
        iTimer->Cancel();
        }
    return 0;
    }

// ---------------------------------------------------------------------------
// NotifyControlVisibility
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::NotifyControlVisibility( TBool aIsVisible,
    CAlfDisplay& /*aDisplay*/ )
	{	
	TRACER("CShwSlideshowVolumeControl::NotifyControlVisibility");
    GLX_LOG_ENTRY_EXIT
        ( "CShwSlideshowVolumeControl::NotifyControlVisibility" );
    GLX_LOG_INFO1
        ( "CShwSlideshowVolumeControl, is visible = %d", aIsVisible );
	if ( !aIsVisible )
		{
		RemoveLayoutVisuals();
		RemoveControlVisuals();
		}
	else
		{
		TRAP_IGNORE( SetAndLayoutVisualsL() );
		}
	}

// ---------------------------------------------------------------------------
// RemoveLayoutVisuals
// ---------------------------------------------------------------------------	
void CShwSlideshowVolumeControl::RemoveLayoutVisuals()
    {
    TRACER("CShwSlideshowVolumeControl::RemoveLayoutVisuals");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::RemoveLayoutVisuals" );
	//not required for now
    }

// ---------------------------------------------------------------------------
// RemoveControlVisuals
// ---------------------------------------------------------------------------	
void CShwSlideshowVolumeControl::RemoveControlVisuals()
    {
    TRACER("CShwSlideshowVolumeControl::RemoveControlVisuals");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::RemoveControlVisuals" );
    // Remove the visuals visibility
    iMainVisual->SetOpacity(KOpacityTransperent);
    }
	
// ---------------------------------------------------------------------------
// SetAndLayoutVisualsL
// ---------------------------------------------------------------------------	
void CShwSlideshowVolumeControl::SetAndLayoutVisualsL()
    {
    TRACER("CShwSlideshowVolumeControl::SetAndLayoutVisualsL");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::SetAndLayoutVisualsL" );

	iMainVisual->SetFlag(EAlfVisualFlagManualSize);
    iMainVisual->SetFlag(EAlfVisualFlagManualPosition);
	//calculate control size
	iControlSize  = iUtility.DisplaySize();
	iControlSize.iHeight *= KControlHeightMultiplier;
	iControlSize.iWidth *= KControlWidthMultiplier;
	//set the control size
	iMainVisual->SetSize(iControlSize);
	
	//calculate the control position
	TInt xPos = ( iUtility.DisplaySize().iWidth - iControlSize.iWidth )
		    / KShwVolumeControlWidthScaleFactor;
	TAlfRealPoint pos( xPos, KShwVolumeControlXOffset );
	iMainVisual->SetPos(pos);
	
	//set the anchors
	User::LeaveIfError( iMainVisual->SetRelativeAnchorRect(
  	0, EAlfAnchorOriginLeft, EAlfAnchorOriginTop, TAlfRealPoint(),
	 EAlfAnchorOriginRight, EAlfAnchorOriginBottom, TAlfRealPoint() ) );
	//update the child visuals
	 iMainVisual->UpdateChildrenLayout();
	 iVisualDeck->UpdateChildrenLayout();
	 iValueGridVisual->UpdateChildrenLayout();
	 
    // Other visuals' layout depends on the volume
    TInt volume = CurrentVolumeAsPercentage();
    
    if (volume == 0)
        {
        // volume = 0% 
        // show muted icon (no %age value)
        SetMuteVisualVisibility();
        }
    else
        {
        // 0 < volume <= 100% 
        // show speaker and %age
        SetValueVisualVisibilityL( volume );
        }
    }

// ---------------------------------------------------------------------------
// SetMuteVisualVisibility
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::SetMuteVisualVisibility()
    {
    TRACER("CShwSlideshowVolumeControl::SetMuteVisualVisibilitys");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::SetMuteVisualVisibility" );

	// set the mute visual's visibility to 1 and the value visual to 0
    iValueGridVisual->SetOpacity(KOpacityTransperent);
    iMuteImageVisual->SetOpacity(KOpacityOpaque);
    iMainVisual->SetOpacity(KOpacityOpaque);
    }

// ---------------------------------------------------------------------------
// SetValueVisualVisibilityL
// ---------------------------------------------------------------------------
void CShwSlideshowVolumeControl::SetValueVisualVisibilityL(TInt aVolume)
    {
    TRACER("CShwSlideshowVolumeControl::SetValueVisualVisibilityL");
    GLX_LOG_ENTRY_EXIT( "CShwSlideshowVolumeControl::SetValueVisualVisibilityL" );
   	
   	// update the percentage visual
   	iPercentTextVisual->SetStyle( EAlfTextStyleSmall, EAlfBackgroundTypeDark );
    iPercentTextVisual->SetMaxLineCount( KShwVolumeTextMaxLineCount );
    iPercentTextVisual->SetWrapping( CAlfTextVisual::ELineWrapTruncate );
   
    // Load the localised string
    HBufC* text = StringLoader::LoadLC( R_SHW_VOLUME_PERCENTAGE, aVolume );
    TPtr ptr = text->Des();
    AknTextUtils::LanguageSpecificNumberConversion( ptr );

    iPercentTextVisual->SetTextL( *text );
    iPercentTextVisual->SetColor(KRgbBlack);
    
    CleanupStack::PopAndDestroy( text );

    iPercentTextVisual->EnableShadow(EFalse);    
    iPercentTextVisual->MoveToFront();
    
    // set the value grid visual's visibility to 1 and the mute visual to 0
    iMuteImageVisual->SetOpacity(KOpacityTransperent);
    iValueGridVisual->SetOpacity(KOpacityOpaque);
    // Text and speaker icon should come top on background
    // so making first in layout's visual list.
    iValueGridVisual->MoveToFront();
    iMainVisual->SetOpacity(KOpacityOpaque);
    }

// ---------------------------------------------------------------------------
// CurrentVolumeAsPercentage()
// ---------------------------------------------------------------------------
TInt CShwSlideshowVolumeControl::CurrentVolumeAsPercentage()
	{
	TRACER("CShwSlideshowVolumeControl::CurrentVolumeAsPercentage");
	GLX_LOG_ENTRY_EXIT("CShwSlideshowVolumeControl::CurrentVolumeAsPercentage");
	TInt retVal = iVolume;

	// guard against any undefined numbers
	if ( iVolume > 0 && iMaxVolume > 0 )
		{
		TReal numerator( iVolume );
		TReal denominator( iMaxVolume );
		TReal working = ( numerator / denominator ) * KShwVolumeMaxPercent;
		retVal = TInt( working );
		}
	else if ( iVolume == iMaxVolume )
		{
		retVal = KShwVolumeMaxPercent;
		}
	return retVal;
	}
// End of File