/*
* 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 "VerticalSlider.h"
#include "CustomControlPanics.h"
#include <ImageEditorUi.mbg>
#include "ResolutionUtil.h"
#include "ImageEditorUiDefs.h"
#include <fbs.h>
#include <aknutils.h>
#include <AknIconUtils.h>


// CONSTANTS
const TInt KStandardSliderWidth     = 7;
const TInt KStandardSliderHeight    = 132;
const TInt KStandardSliderTabWidth  = 7;
const TInt KStandardSliderTabHeight = 12;

const TInt KDoubleSliderWidth       = 13;
const TInt KDoubleSliderHeight      = 244;
const TInt KDoubleSliderTabWidth    = 13;
const TInt KDoubleSliderTabHeight   = 24;

const TInt KQVGASliderWidth         = 10;
const TInt KQVGASliderHeight        = 188;
const TInt KQVGASliderTabWidth      = 10;
const TInt KQVGASliderTabHeight     = 18;

const TInt KHVGASliderWidth         = 13;
const TInt KHVGASliderHeight        = 244;
const TInt KHVGASliderTabWidth      = 13;
const TInt KHVGASliderTabHeight     = 24;

const TInt KVGASliderWidth          = 20;
const TInt KVGASliderHeight         = 376;
const TInt KVGASliderTabWidth       = 20;
const TInt KVGASliderTabHeight      = 36;

const TInt KQHDSliderWidth          = 13;
const TInt KQHDSliderHeight         = 244;
const TInt KQHDSliderTabWidth       = 13;
const TInt KQHDSliderTabHeight      = 24;

//=============================================================================
EXPORT_C CVerticalSlider* CVerticalSlider::NewL(const TRect& aRect, const CCoeControl& aControl)
    {
    CVerticalSlider* self = CVerticalSlider::NewLC(aRect, aControl);
    CleanupStack::Pop(self);
    return self;
    }

//=============================================================================
EXPORT_C CVerticalSlider* CVerticalSlider::NewLC(const TRect& aRect, const CCoeControl& aControl)
    {
    CVerticalSlider* self = new (ELeave) CVerticalSlider;
    CleanupStack::PushL(self);
    self->ConstructL(aRect, aControl);
    return self;
    }

//=============================================================================
EXPORT_C CVerticalSlider::~CVerticalSlider()
    {
    delete iSliderBg;
	delete iSliderBgMask;
	delete iSliderTab;
	delete iSliderTabMask;
    }

//=============================================================================
void CVerticalSlider::ConstructL(const TRect& /*aRect*/, const CCoeControl& aControl)
    {
	SetContainerWindowL(aControl);
	
    // Load the bitmaps
    LoadBitmapL( iSliderBg, iSliderBgMask, EMbmImageeditoruiQgn_graf_ied_vslider, EMbmImageeditoruiQgn_graf_ied_vslider_mask );
    LoadBitmapL( iSliderTab, iSliderTabMask, EMbmImageeditoruiQgn_graf_ied_vtab, EMbmImageeditoruiQgn_graf_ied_vtab_mask );
    SetBitmapSize();

	ActivateL();
    }

//=============================================================================
CVerticalSlider::CVerticalSlider()
    {
    // no implementation required
    }

//=============================================================================
EXPORT_C TInt CVerticalSlider::CountComponentControls() const
    {
    return 0;
    }

//=============================================================================
void CVerticalSlider::Draw(const TRect& /*aRect*/) const
{
    if ( iMinimumValue <= iMaximumValue )
    {
        TUint height = iMaximumValue - iMinimumValue; // height of the slider
        TUint pixelsFromMin = iPosition - iMinimumValue; // tab position from the beginning
    
        TReal factor = 0.0;
        if (iMinimumValue < iMaximumValue )
        {
            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 = Rect().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);
    }
}

//=============================================================================
EXPORT_C CCoeControl* CVerticalSlider::ComponentControl(TInt /*aIndex*/) const
    {
    return NULL;
    }

//=============================================================================
EXPORT_C TSize CVerticalSlider::MinimumSize()
	{
	TSize size = iSliderBg->SizeInPixels();
	return size;
	}

// setters

//=============================================================================
EXPORT_C void CVerticalSlider::SetMinimum(TInt aValue)
	{
	iMinimumValue = aValue;
	}

//=============================================================================
EXPORT_C void CVerticalSlider::SetMaximum(TInt aValue)
	{
	iMaximumValue = aValue;
	}

//=============================================================================
EXPORT_C void CVerticalSlider::SetStep(TUint aValue)
	{
	iStep = aValue;
	}

//=============================================================================
EXPORT_C void CVerticalSlider::SetStepAmount(TUint8 aValue)
	{
	iNumberOfSteps = aValue;
	
	if(aValue == 0)
		{
		iStep = 0;
		}
	else
		{
		iStep = (iMaximumValue-iMinimumValue) / aValue;
		}
	}

//=============================================================================
EXPORT_C void CVerticalSlider::SetPosition(TInt aValue)
	{
	__ASSERT_ALWAYS( aValue >= iMinimumValue, Panic(EVerticalSliderPanicIndexUnderflow) );
	__ASSERT_ALWAYS( aValue <= iMaximumValue, Panic(EVerticalSliderPanicIndexOverflow) );

	iPosition = aValue;
	}

// getters

//=============================================================================
EXPORT_C TInt CVerticalSlider::Minimum() const
	{
	return iMinimumValue;
	}

//=============================================================================
EXPORT_C TInt CVerticalSlider::Maximum() const
	{
	return iMaximumValue;
	}

//=============================================================================
EXPORT_C TInt CVerticalSlider::Step() const
	{
	return iStep;
	}

//=============================================================================
EXPORT_C TInt CVerticalSlider::Position() const
	{
	return iPosition;
	}

//=============================================================================
EXPORT_C void CVerticalSlider::Increment()
	{
	iPosition += iStep;
	if(iPosition > iMaximumValue)
		{
		iPosition = iMaximumValue;
		}
	}

//=============================================================================
EXPORT_C void CVerticalSlider::Decrement()
	{
	iPosition -= iStep;
	if(iPosition < iMinimumValue)
		{
		iPosition = iMinimumValue;
		}
	}


//=============================================================================
void CVerticalSlider::LoadBitmapL( CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, TInt aBitmapId, TInt aMaskId ) const
{

    TFileName iconFile( KImageEditorUiMifFile );
    User::LeaveIfError( CompleteWithAppPath(iconFile) );

    // Get ids for bitmap and mask
    AknIconUtils::CreateIconL(
        aBitmap,
        aMask,
        iconFile,
        aBitmapId,
        aMaskId
        );


}

//=============================================================================
void CVerticalSlider::SetBitmapSize() const
{

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

    //  Get the screen mode from the Resolution Util
    TInt screenMode = CResolutionUtil::Self()->GetScreenMode();

    TSize sliderSize;
    TSize tabSize;

    switch( screenMode )
    {
        // small screen sizes
        case CResolutionUtil::EStandard:
        case CResolutionUtil::EStandardFullScreen:
        case CResolutionUtil::EStandardLandscape:
        case CResolutionUtil::EStandardLandscapeFullScreen:
        case CResolutionUtil::ESquare:
        case CResolutionUtil::ESquareFullScreen:
        case CResolutionUtil::ESquareRotated:
        case CResolutionUtil::ESquareRotatedFullScreen:
        {
            sliderSize = TSize (KStandardSliderWidth, KStandardSliderHeight);
            tabSize = TSize (KStandardSliderTabWidth, KStandardSliderTabHeight);
            break;
        }

        // QVGA
        case CResolutionUtil::EQVGA:
        case CResolutionUtil::EQVGAFullScreen:
        case CResolutionUtil::EQVGALandscape:
        case CResolutionUtil::EQVGALandscapeFullScreen:
        {
            sliderSize = TSize (KQVGASliderWidth, KQVGASliderHeight);
            tabSize = TSize (KQVGASliderTabWidth, KQVGASliderTabHeight);
            break;
        }
       
        case CResolutionUtil::EDouble:
        case CResolutionUtil::EDoubleFullScreen:
        case CResolutionUtil::EDoubleLandscape:
        case CResolutionUtil::EDoubleLandscapeFullScreen:
        {
            sliderSize = TSize (KDoubleSliderWidth, KDoubleSliderHeight);
            tabSize = TSize (KDoubleSliderTabWidth, KDoubleSliderTabHeight);
            break;
        }
        
        // HVGA
        case CResolutionUtil::EHVGA:
        case CResolutionUtil::EHVGAFullScreen:
        case CResolutionUtil::EHVGALandscape:
        case CResolutionUtil::EHVGALandscapeFullScreen:
        {
            sliderSize = TSize (KHVGASliderWidth, KHVGASliderHeight);
            tabSize = TSize (KHVGASliderTabWidth, KHVGASliderTabHeight);
            break;
        }
        
        // VGA
        case CResolutionUtil::EVGA:
        case CResolutionUtil::EVGAFullScreen:
        case CResolutionUtil::EVGALandscape:
        case CResolutionUtil::EVGALandscapeFullScreen:
        {
            sliderSize = TSize (KVGASliderWidth, KVGASliderHeight);
            tabSize = TSize (KVGASliderTabWidth, KVGASliderTabHeight);
            break;
        }
        
        // QHD
        case CResolutionUtil::EQHD:
        case CResolutionUtil::EQHDFullScreen:
        case CResolutionUtil::EQHDLandscape:
        case CResolutionUtil::EQHDLandscapeFullScreen:
        {
            sliderSize = TSize (KQHDSliderWidth, KQHDSliderHeight);
            tabSize = TSize (KQHDSliderTabWidth, KQHDSliderTabHeight);
            break;
        }
        
        default:
        {
            sliderSize = TSize (KStandardSliderWidth, KStandardSliderHeight);
            tabSize = TSize (KStandardSliderTabWidth, KStandardSliderTabHeight);
            break;
        }
    }
    
    // Set size for scalable icons - MUST BE CALLED BEFORE ICON IS USABLE
    AknIconUtils::SetSize( iSliderBg, sliderSize );
    AknIconUtils::SetSize( iSliderTab, tabSize );

}

// End of File