/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "VeiSlider.h"

#include "VeiSlider.pan"

#include "VideoEditorDebugUtils.h"

#include <VideoEditorUiComponents.mbg>

#include <fbs.h>

#include <aknutils.h>

#include <AknIconUtils.h>

#include <eikenv.h>

// CONSTANTS

_LIT(KSliderMifFile, "\\resource\\apps\\VideoEditorUiComponents.mif");

const TInt KTabAspectRatioX = 10;

const TInt KTabAspectRatioY = 24;

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

//

//	class CVeiSlider member functions

//

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

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

EXPORT_C CVeiSlider::~CVeiSlider()

    {

    delete iSliderBg;

	delete iSliderBgMask;

	delete iSliderTab;

	delete iSliderTabMask;

    }

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

CVeiSlider::CVeiSlider()

    {

    // no implementation required

    }

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

TInt CVeiSlider::CountComponentControls() const

    {

    return 0;

    }

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

CCoeControl* CVeiSlider::ComponentControl(TInt /*aIndex*/) const

    {

    return NULL;

    }

// setters

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

EXPORT_C void CVeiSlider::SetMinimum(TInt aValue)

	{

	iMinimumValue = aValue;

	}

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

EXPORT_C void CVeiSlider::SetMaximum(TInt aValue)

	{

	iMaximumValue = aValue;

	}

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

EXPORT_C void CVeiSlider::SetStep(TUint aValue)

	{

	iStep = aValue;

	}

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

EXPORT_C void CVeiSlider::SetStepAmount(TUint8 aValue)

	{

	iNumberOfSteps = aValue;

	if(aValue == 0)

		{

		iStep = 0;

		}

	else

		{

		iStep = (iMaximumValue-iMinimumValue) / aValue;

		}

	}

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

EXPORT_C void CVeiSlider::SetPosition(TInt aValue)

	{

	__ASSERT_ALWAYS( aValue >= iMinimumValue, Panic(EVeiSliderPanicIndexUnderflow) );

	__ASSERT_ALWAYS( aValue <= iMaximumValue, Panic(EVeiSliderPanicIndexOverflow) );

	iPosition = aValue;

	}

// getters

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

EXPORT_C TInt CVeiSlider::Minimum() const

	{

	return iMinimumValue;

	}

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

EXPORT_C TInt CVeiSlider::Maximum() const

	{

	return iMaximumValue;

	}

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

EXPORT_C TInt CVeiSlider::Step() const

	{

	return iStep;

	}

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

EXPORT_C TInt CVeiSlider::SliderPosition() const

	{

	return iPosition;

	}

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

EXPORT_C void CVeiSlider::Increment()

	{

	iPosition += iStep;

	if(iPosition > iMaximumValue)

		{

		iPosition = iMaximumValue;

		}

	}

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

EXPORT_C void CVeiSlider::Decrement()

	{

	iPosition -= iStep;

	if(iPosition < iMinimumValue)

		{

		iPosition = iMinimumValue;

		}

	}

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

void CVeiSlider::LoadBitmapL( CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, TInt aBitmapId, TInt aMaskId ) const

	{

    TFileName iconFile( KSliderMifFile );

    User::LeaveIfError( CompleteWithAppPath(iconFile) );

    // Get ids for bitmap and mask

    AknIconUtils::CreateIconL(

        aBitmap,

        aMask,

        iconFile,

        aBitmapId,

        aMaskId

        );                

	}

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

//

//	class CVeiVerticalSlider member functions

//

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

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

EXPORT_C CVeiVerticalSlider* CVeiVerticalSlider::NewL(const TRect& aRect, const CCoeControl& aControl)

	{

	CVeiVerticalSlider* self = CVeiVerticalSlider::NewLC(aRect, aControl);

	CleanupStack::Pop(self);

	return self;

	}

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

EXPORT_C CVeiVerticalSlider* CVeiVerticalSlider::NewLC(const TRect& aRect, const CCoeControl& aControl)

    {

    CVeiVerticalSlider* self = new (ELeave) CVeiVerticalSlider;

    CleanupStack::PushL(self);

    self->ConstructL(aRect, aControl);

    return self;

    }

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

EXPORT_C CVeiVerticalSlider::~CVeiVerticalSlider()

    {

    }

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

void CVeiVerticalSlider::ConstructL(const TRect& aRect, const CCoeControl& aControl)

	{

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::ConstructL: in");

	SetContainerWindowL(aControl);

    // Load the bitmaps 

    LoadBitmapL( iSliderBg, iSliderBgMask, EMbmVideoeditoruicomponentsQgn_graf_ied_vslider, EMbmVideoeditoruicomponentsQgn_graf_ied_vslider_mask );

    LoadBitmapL( iSliderTab, iSliderTabMask, EMbmVideoeditoruicomponentsQgn_graf_ied_vtab, EMbmVideoeditoruicomponentsQgn_graf_ied_vtab_mask );

	SetRect(aRect);

	ActivateL();

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::ConstructL: out");

	}

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

CVeiVerticalSlider::CVeiVerticalSlider()

    {

    // no implementation required

    }

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

void CVeiVerticalSlider::Draw(const TRect& aRect) const

	{

    if ( Minimum() <= Maximum() )

    	{

        TUint height = Maximum() - Minimum(); // height of the slider

        TUint pixelsFromMin = SliderPosition() - Minimum(); // tab position from the beginning

        TReal factor = 0.0;

        if (Minimum() < Maximum() )

        	{

            factor = (TReal) pixelsFromMin / height; // tab position from the beginning in percentage

        	}

        TUint sliderTabHeight = iSliderTab->SizeInPixels().iHeight; // slider tab height

        // slider bitmap is actually a bit longer but this resolves the problem

        // where the tab is drawn outside of the slider when in maximum position

        TUint sliderBitmapHeight = iSliderBg->SizeInPixels().iHeight - sliderTabHeight;

        TUint tabPositionFromMinInPixels = (TUint) (factor * sliderBitmapHeight + 0.5); // calculate tab position

        // top left coordinate

        const TPoint tl = aRect.iTl;

        CWindowGc& gc = SystemGc();

        // draw actual slider using mask bitmap

        TRect bgRect(TPoint(0,0), iSliderBg->SizeInPixels());

        gc.BitBltMasked(tl, iSliderBg, bgRect, iSliderBgMask, ETrue);

        // draw the tab using mask bitmap

        TRect tabRect(TPoint(0,0), iSliderTab->SizeInPixels());

        gc.BitBltMasked(TPoint(tl.iX, tl.iY+tabPositionFromMinInPixels), iSliderTab, tabRect, iSliderTabMask, ETrue);

    	}

	}

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

void CVeiVerticalSlider::SizeChanged()

	{

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::SizeChanged: in");

	__ASSERT_ALWAYS( iSliderBg && iSliderTab, Panic(EVeiSliderPanicBitmapsNotLoaded) );

	// Set size for scalable icons - MUST BE CALLED BEFORE ICON IS USABLE

	TSize sliderSize;

	TSize tabSize;

	TInt w = Rect().Width();

	TInt h = Rect().Height();

	// NOTE: this assumes that the slider and the slider tab have the same width.

	// If that is not the case, it should be handled with transparency in the SVG graphic.

	// Set the slider bg to fill the whole rect

	sliderSize.iWidth = w;

	sliderSize.iHeight = h;

	AknIconUtils::SetSize( iSliderBg, sliderSize, EAspectRatioNotPreserved);

	// The slider tab is set to have the same width.

	// The height is calculated from the aspect ratio (set based on the original SVG)

	tabSize.iWidth = w;

	tabSize.iHeight = (TInt)( w * KTabAspectRatioY / KTabAspectRatioX );

	AknIconUtils::SetSize( iSliderTab, tabSize, EAspectRatioNotPreserved);

	LOGFMT4(KVideoEditorLogFile, "CVeiVerticalSlider::SizeChanged: out: sliderSize(%d,%d), tabSize(%d,%d)", sliderSize.iWidth,sliderSize.iHeight,tabSize.iWidth,tabSize.iHeight);

	}

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

TSize CVeiVerticalSlider::MinimumSize()

	{

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::MinimumSize()");

	return iSliderBg->SizeInPixels();

	}

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

//

//	class CVeiHorizontalSlider member functions

//

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

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

EXPORT_C CVeiHorizontalSlider* CVeiHorizontalSlider::NewL(const TRect& aRect, const CCoeControl& aControl)

	{

	CVeiHorizontalSlider* self = CVeiHorizontalSlider::NewLC(aRect, aControl);

	CleanupStack::Pop(self);

	return self;

	}

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

EXPORT_C CVeiHorizontalSlider* CVeiHorizontalSlider::NewLC(const TRect& aRect, const CCoeControl& aControl)

    {

    CVeiHorizontalSlider* self = new (ELeave) CVeiHorizontalSlider;

    CleanupStack::PushL(self);

    self->ConstructL(aRect, aControl);

    return self;

    }

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

EXPORT_C CVeiHorizontalSlider::~CVeiHorizontalSlider()

    {

    }

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

void CVeiHorizontalSlider::ConstructL(const TRect& aRect, const CCoeControl& aControl)

	{

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::ConstructL: in");

	SetContainerWindowL(aControl);

    // Load the bitmaps 

    LoadBitmapL( iSliderBg, iSliderBgMask, EMbmVideoeditoruicomponentsQgn_graf_ied_hslider, EMbmVideoeditoruicomponentsQgn_graf_ied_hslider_mask );

    LoadBitmapL( iSliderTab, iSliderTabMask, EMbmVideoeditoruicomponentsQgn_graf_ied_htab, EMbmVideoeditoruicomponentsQgn_graf_ied_htab_mask );

	SetRect(aRect);

	ActivateL();

	LOG(KVideoEditorLogFile, "CVeiVerticalSlider::ConstructL: out");

	}

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

CVeiHorizontalSlider::CVeiHorizontalSlider()

    {

    // no implementation required

    }

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

void CVeiHorizontalSlider::Draw(const TRect& aRect) const

	{

    if ( Minimum() <= Maximum() )

    	{

        TUint height = Maximum() - Minimum(); // height of the slider

        TUint pixelsFromMin = SliderPosition() - Minimum(); // tab position from the beginning

        TReal factor = 0.0;

        if (Minimum() < Maximum() )

        	{

            factor = (TReal) pixelsFromMin / height; // tab position from the beginning in percentage

        	}

        TUint sliderTabWidth = iSliderTab->SizeInPixels().iWidth; // slider tab width

        // slider bitmap is actually a bit longer but this resolves the problem

        // where the tab is drawn outside of the slider when in maximum position

        TUint sliderBitmapWidth = iSliderBg->SizeInPixels().iWidth - sliderTabWidth;

        TUint tabPositionFromMinInPixels = (TUint) (factor * sliderBitmapWidth + 0.5); // calculate tab position

        // top left coordinate

        const TPoint tl = aRect.iTl;

        CWindowGc& gc = SystemGc();

        // draw actual slider using mask bitmap

        TRect bgRect(TPoint(0,0), iSliderBg->SizeInPixels());

        gc.BitBltMasked(tl, iSliderBg, bgRect, iSliderBgMask, ETrue);

        // draw the tab using mask bitmap

        TRect tabRect(TPoint(0,0),iSliderTab->SizeInPixels());

        gc.BitBltMasked(TPoint(tl.iX + tabPositionFromMinInPixels, tl.iY), iSliderTab, tabRect, iSliderTabMask, ETrue);

    	}

	}

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

void CVeiHorizontalSlider::SizeChanged()

	{

	LOG(KVideoEditorLogFile, "CVeiHorizontalSlider::SizeChanged: in");

	__ASSERT_ALWAYS( iSliderBg && iSliderTab, Panic(EVeiSliderPanicBitmapsNotLoaded) );

	// Set size for scalable icons - MUST BE CALLED BEFORE ICON IS USABLE

	TSize sliderSize;

	TSize tabSize;

	TInt w = Rect().Width();

	TInt h = Rect().Height();

	// NOTE: this assumes that the slider and the slider tab have the same height.

	// If that is not the case, it should be handled with transparency in the SVG graphic.

	// Set the slider bg to fill the whole rect.

	sliderSize.iWidth = w;

	sliderSize.iHeight = h;

	AknIconUtils::SetSize( iSliderBg, sliderSize, EAspectRatioNotPreserved);

	// The slider tab is set to have the same height with the bg.

	// The width is calculated from the aspect ratio (set based on the original SVG).

	tabSize.iWidth = (TInt)( h * KTabAspectRatioY / KTabAspectRatioX );

	tabSize.iHeight = h;

	AknIconUtils::SetSize( iSliderTab, tabSize, EAspectRatioNotPreserved);

	LOGFMT4(KVideoEditorLogFile, "CVeiHorizontalSlider::SizeChanged: out: sliderSize(%d,%d), tabSize(%d,%d)", sliderSize.iWidth,sliderSize.iHeight,tabSize.iWidth,tabSize.iHeight);

	}

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

TSize CVeiHorizontalSlider::MinimumSize()

	{

	LOG(KVideoEditorLogFile, "CVeiHorizontalSlider::MinimumSize()");

	return iSliderBg->SizeInPixels();

	}

// End of File