/*
* Copyright (c) 2002-2006 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:
*
*/
// INCLUDE FILES
#include <AknUtils.h>
#include <barsread.h>
#include <eikenv.h>
#include <AknDef.h>
#include <AknPanic.h>
#include <avkon.hrh>
#include <avkon.mbg>
#include <e32math.h>
#include <bitstd.h>
#include <bitdev.h>
#include <aknconsts.h>
#include <StringLoader.h>
#include <AknsDrawUtils.h>
#include <centralrepository.h>
#include <AvkonInternalCRKeys.h>
#include <AknsFrameBackgroundControlContext.h>
#include <gulicon.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <layoutmetadata.cdl.h>
#include <AknIconUtils.h>
#include <AknBidiTextUtils.h>
#include <AknTasHook.h>
#include "aknslider.h"
#include <touchfeedback.h>
// Large enough for a 20 digit number or fraction with two 9 digit numbers.
// This number is not in the header as it does not need to be known by the
// client.
const TInt KAknSliderValueLabelValueMaxLength = 20;
// This value is used to account for the safety demands of StringLoader. It
// requires extra length in the target descriptor of its formatting than you
// would expect.
const TInt KAknSliderFormatKeyLength = 2;
// This value is the optimum number of repeat key events to get through the
// range of the slider.
const TInt KAknSliderFeedbackActionTime = 160 * 1000; // Interval, microseconds
// Default draw color
const TInt KAknSliderDefaultDrawColor = 120;
const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds
const TInt KStableFeedbackIntesity = 50;
const TInt KFeedbackTimeout = 100000;
const TInt KNoFeedbackTimeout = 0;
const TInt KStepThreshold = 15;
// ============================================================================
// Internal class to hold slider control data, primarily coming from resource.
NONSHARABLE_CLASS( CAknSliderData ): public CBase
{
public:
static CAknSliderData* NewLC( TInt aResourceId );
static CAknSliderData* NewL( TResourceReader& aReader );
~CAknSliderData();
void SetRange( TInt aMinimumValue, TInt aMaximumValue );
inline TInt Range() const
{
return iMaximumValue - iMinimumValue;
}
void SetDecimalPlaces( TInt aDecimalPlaces );
inline TInt DecimalPlaces() const
{
return iDecimalPlaces;
}
private:
CAknSliderData();
void ConstructFromResourceL( TInt aResourceId );
void ConstructFromResourceL( TResourceReader& aReader );
// Copy constructor, declared not defined -> disabled
CAknSliderData( const CAknSliderData& aData );
// Assignment operator, declared not defined -> disabled
const CAknSliderData& operator=( const CAknSliderData& aData );
public:
TInt iMinimumValue;
TInt iMaximumValue;
TInt iStepSize;
TInt iValueType;
TInt iLayout;
HBufC* iText; // Owned
// Text to be used for the singular label if needed. Owned
HBufC* iSingularText;
HBufC* iMinimumLabelText; // Owned
HBufC* iMaximumLabelText; // Owned
TInt iDecoratorImageId;
TAknFeedbackStyle iFeedbackStyle;
private:
TInt iDecimalPlaces;
// NOTE! This class is only for storing the data read from slider resource.
// Do not add any unnecessary members to this class, such data and
// functionality should go to the extension instead.
};
// ----------------------------------------------------------------------------
// CAknSliderData::NewLC
// ----------------------------------------------------------------------------
//
CAknSliderData* CAknSliderData::NewLC( TInt aResourceId )
{
CAknSliderData* self = new ( ELeave ) CAknSliderData();
CleanupStack::PushL( self );
self->ConstructFromResourceL( aResourceId );
return self;
}
// ----------------------------------------------------------------------------
// CAknSliderData::NewL
// ----------------------------------------------------------------------------
//
CAknSliderData* CAknSliderData::NewL( TResourceReader& aReader )
{
CAknSliderData* self = new ( ELeave ) CAknSliderData();
CleanupStack::PushL( self );
self->ConstructFromResourceL( aReader );
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
CAknSliderData::CAknSliderData()
{
// Derived from CBase -> members zeroed
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
CAknSliderData::~CAknSliderData()
{
delete iText;
delete iSingularText;
delete iMinimumLabelText;
delete iMaximumLabelText;
}
// ----------------------------------------------------------------------------
// CAknSliderData::ConstructFromResourceL
// ----------------------------------------------------------------------------
//
void CAknSliderData::ConstructFromResourceL( TInt aResourceId )
{
TResourceReader reader;
CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );
ConstructFromResourceL( reader );
CleanupStack::PopAndDestroy(); // reader
}
// ----------------------------------------------------------------------------
// CAknSliderData::ConstructFromResource
// ----------------------------------------------------------------------------
//
void CAknSliderData::ConstructFromResourceL( TResourceReader& aReader )
{
TInt sliderType = aReader.ReadInt16();
if ( sliderType == EAknSliderWithFeedbackStyle )
{
iFeedbackStyle = (TAknFeedbackStyle)aReader.ReadInt16();
iLayout = aReader.ReadInt16();
}
else
{
// old resource struct used -> actually sliderType contains
// layout information
iLayout = sliderType;
if ( iLayout > EAknSliderLayoutHorizontal )
{
iLayout = EAknSliderLayoutHorizontal;
}
}
TInt min = aReader.ReadInt16();
TInt max = aReader.ReadInt16();
SetRange( min, max );
iStepSize = aReader.ReadInt16();
iValueType = aReader.ReadInt16();
SetDecimalPlaces( aReader.ReadInt16() );
iSingularText = aReader.ReadHBufCL();
iMinimumLabelText = aReader.ReadHBufCL();
iMaximumLabelText = aReader.ReadHBufCL();
iText = aReader.ReadHBufCL();
// Extension link for graphics
iDecoratorImageId = aReader.ReadInt32();
if ( !iDecoratorImageId )
{
iDecoratorImageId = R_AVKON_SLIDER_CONTRAST_GRAPHICS;
}
}
// ----------------------------------------------------------------------------
// CAknSliderData::SetRange
// ----------------------------------------------------------------------------
//
void CAknSliderData::SetRange( TInt aMinimumValue, TInt aMaximumValue )
{
__ASSERT_ALWAYS( aMaximumValue > aMinimumValue,
Panic( EAknPanicOutOfRange ) );
iMaximumValue = aMaximumValue;
iMinimumValue = aMinimumValue;
}
// ----------------------------------------------------------------------------
// CAknSliderData::SetDecimalPlaces
// ----------------------------------------------------------------------------
//
void CAknSliderData::SetDecimalPlaces( TInt aDecimalPlaces )
{
__ASSERT_DEBUG( aDecimalPlaces >= 0, Panic( EAknPanicInvalidValue ) );
__ASSERT_DEBUG( aDecimalPlaces < 10, Panic( EAknPanicInvalidValue ) );
iDecimalPlaces = Abs( aDecimalPlaces );
}
// ============================================================================
NONSHARABLE_STRUCT( TAknSliderGfx )
{
TAknSliderGfx(): iRgb( NULL ), iMask( NULL )
{}
CFbsBitmap* iRgb; // Referenced.
CFbsBitmap* iMask; // Referenced.
// customized graphics flag
TInt iCustomizedFlag; // if use default, then value = 0, else value = 1
};
// ============================================================================
NONSHARABLE_CLASS( CAknSliderExtension ): public CBase
{
public:
// Symbols for bitflags.
enum TFlags
{
EFlagHorizontal,
EFlagFillEnabled,
EFlagMarkerEnabled,
EFlagTickMarksEnabled,
EFlagTickBelowOrRight,
EFlagPointerDown,
EFlagDraggingThumb,
EFlagValueStepChange,
EFlagPlayingContinuousFb,
EFlagCount // must be the last flag
};
private:
CAknSliderExtension();
// Copy constructor, declared not defined -> disabled
CAknSliderExtension( const CAknSliderExtension& );
// Assignment operator, declared not defined -> disabled
const CAknSliderExtension& operator=( const CAknSliderExtension& );
void ConstructL();
public:
~CAknSliderExtension();
static CAknSliderExtension* NewL();
void SetGraphics( TInt aElement,
CFbsBitmap* aBitmap,
CFbsBitmap* aMask,
TBool aCustomize = ETrue);
void UseDefaultGraphics( TInt aElement );
TBool UsesDefaultGraphics( TInt aElement ) const;
TBool UsesDefaultGraphics() const;
void GetGfx( TAknSliderGfx& aGfx, TInt aElement ) const;
void DeleteBitmaps();
void TryLoadNSliderBitmap(TBool aFromSkin, MAknsSkinInstance* aSkin );
void TryLoadNSliderVerticalBitmap( MAknsSkinInstance* aSkin );
inline void SetFlag( TInt aFlagIndex )
{
ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );
iFlags.Set( aFlagIndex );
}
inline void ClearFlag( TInt aFlagIndex )
{
ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );
iFlags.Clear( aFlagIndex );
}
inline TBool IsFlagSet( TInt aFlagIndex ) const
{
ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );
return iFlags.IsSet( aFlagIndex );
}
public:
CFbsBitmap* iLineIcon; // Owned.
CFbsBitmap* iLineIconMask; // Owned.
TRect iLeftCapRect; // The default value is zero -> no left line cap
TRect iRightCapRect; // The default value is zero -> no right line cap
TRect iTickRect;
CPeriodic* iTimer; // Owned.
TInt iEffectTimerCount;
TRect iThumbRect; // Equals GetMarkerRect
TUint iTickInterval;
TPoint iPenInputPos;//remember pointer input position
TBool iReportMarkerDragEvent;
TRect iTouchDownArea;
TRect iTouchActiveArea;
TBool iNoDraw;
private:
// If EFlagHorizontal is not set, the orientation is vertical.
TBitFlags32 iFlags;
// Stores the element graphics (rgb icon and mask icon) as bitmaps. Bitmaps
// are owned.
TAknSliderGfx iGfx[CAknSlider::EElemMarkerSelected + 1];
};
// ----------------------------------------------------------------------------
// CAknSliderExtension::CAknSliderExtension
// ----------------------------------------------------------------------------
//
CAknSliderExtension::CAknSliderExtension()
{
// slider is derived from CBase -> members zeroed
SetFlag( EFlagMarkerEnabled );//default is marker enable
SetFlag( EFlagHorizontal ); //default is horizontal enable
SetFlag( EFlagValueStepChange); //default is step change enable
// Don't report drag event as default setting
iReportMarkerDragEvent = EFalse;
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
CAknSliderExtension::~CAknSliderExtension()
{
if( iTimer )
{
iTimer->Cancel();
}
delete iTimer;
delete iLineIcon;
delete iLineIconMask;
DeleteBitmaps();
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::ConstructL
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::ConstructL()
{
// Create icon for line
AknsUtils::CreateIconL( AknsUtils::SkinInstance(),
KAknsIIDQgnGrafLinePrimaryHorizontal, iLineIcon, iLineIconMask,
KAvkonBitmapFile, EMbmAvkonQgn_graf_line_primary_horizontal,
EMbmAvkonQgn_graf_line_primary_horizontal_mask );
// Set default value
for ( int i = 0; i <= CAknSlider::EElemMarkerSelected; ++i )
{
iGfx[i].iRgb = NULL;
iGfx[i].iMask = NULL;
iGfx[i].iCustomizedFlag = 0;
}
iTimer = CPeriodic::NewL( CActive::EPriorityStandard );
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::NewL
// ----------------------------------------------------------------------------
//
CAknSliderExtension* CAknSliderExtension::NewL()
{
CAknSliderExtension* self = new( ELeave ) CAknSliderExtension();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::TryLoadNewSliderBitmap
//
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::TryLoadNSliderBitmap( TBool aFromSkin, MAknsSkinInstance* aSkin )
{
const TInt iconIDArray[] =
{
EMbmAvkonQgn_graf_nslider_end_left,
EMbmAvkonQgn_graf_nslider_end_right,
EMbmAvkonQgn_graf_nslider_middle,
EMbmAvkonQgn_graf_nslider_marker,
EMbmAvkonQgn_graf_nslider_marker_selected
};
const TInt iconMaskIDArray[] =
{
EMbmAvkonQgn_graf_nslider_end_left_mask,
EMbmAvkonQgn_graf_nslider_end_right_mask,
EMbmAvkonQgn_graf_nslider_middle_mask,
EMbmAvkonQgn_graf_nslider_marker_mask,
EMbmAvkonQgn_graf_nslider_marker_selected_mask
};
const TAknsItemID iconSkinIDArray[] =
{
KAknsIIDQgnGrafNsliderEndLeft,
KAknsIIDQgnGrafNsliderEndRight,
KAknsIIDQgnGrafNsliderMiddle,
KAknsIIDQgnGrafNsliderMarker,
KAknsIIDQgnGrafNsliderMarkerSelected
};
const TInt element[] =
{
CAknSlider::EElemEmptyLeftCap,
CAknSlider::EElemEmptyRightCap,
CAknSlider::EElemEmptyLine,
CAknSlider::EElemMarker,
CAknSlider::EElemMarkerSelected
};
TInt arrayTotal = sizeof( iconIDArray )/sizeof(TInt);
TInt err = KErrNone;
for ( TInt i = 0; i < arrayTotal; i++ )
{
CFbsBitmap* bitmapPtr = NULL;
CFbsBitmap* maskPtr = NULL;
if( aFromSkin )
{
//find new graphic from Skinned bitmap
TRAP(err, AknsUtils::CreateIconL( aSkin,
iconSkinIDArray[i],
bitmapPtr,
maskPtr,
KNullDesC,
iconIDArray[i],
iconMaskIDArray[i] ));
}
//find new graphic from mif file
else
{
TRAP(err, AknIconUtils::CreateIconL(
bitmapPtr,
maskPtr,
KAvkonBitmapFile,
iconIDArray[i],
iconMaskIDArray[i] ));
}
if( !err )
{
SetGraphics( element[i], bitmapPtr, maskPtr );
}
}
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::TryLoadNewSliderBitmap
//
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::TryLoadNSliderVerticalBitmap( MAknsSkinInstance* aSkin )
{
const TInt iconIDArray[] =
{
EMbmAvkonQgn_graf_nslider_vertical_top,
EMbmAvkonQgn_graf_nslider_vertical_bottom,
EMbmAvkonQgn_graf_nslider_vertical_middle,
EMbmAvkonQgn_graf_nslider_vertical_marker,
EMbmAvkonQgn_graf_nslider_vertical_tick_major,
EMbmAvkonQgn_graf_nslider_vertical_marker
};
const TInt iconMaskIDArray[] =
{
EMbmAvkonQgn_graf_nslider_vertical_top_mask,
EMbmAvkonQgn_graf_nslider_vertical_bottom_mask,
EMbmAvkonQgn_graf_nslider_vertical_middle_mask,
EMbmAvkonQgn_graf_nslider_vertical_marker_mask,
EMbmAvkonQgn_graf_nslider_vertical_tick_major_mask,
EMbmAvkonQgn_graf_nslider_marker_mask
};
const TAknsItemID iconSkinIDArray[] =
{
KAknsIIDQgnGrafNsliderVerticalTop, //KAknsIIDNone,
KAknsIIDQgnGrafNsliderVerticalBottom,//KAknsIIDNone,
KAknsIIDQgnGrafNsliderVerticalMiddle,//KAknsIIDNone,
KAknsIIDQgnGrafNsliderVerticalMarker,//KAknsIIDNone,
KAknsIIDQgnGrafNsliderVerticalTickMajor,//KAknsIIDNone,
KAknsIIDQgnGrafNsliderVerticalMarker//KAknsIIDNone
};
const TInt element[] =
{
CAknSlider::EElemEmptyLeftCap,
CAknSlider::EElemEmptyRightCap,
CAknSlider::EElemEmptyLine,
CAknSlider::EElemMarker,
CAknSlider::EElemTickMark,
CAknSlider::EElemMarkerSelected
};
TInt arrayTotal = sizeof( iconIDArray )/sizeof(TInt);
TInt err = KErrNone;
CFbsBitmap* bitmapPtr = NULL;
CFbsBitmap* maskPtr = NULL;
for ( TInt i = 0; i < arrayTotal; i++ )
{
//find new graphic from Skinned bitmap
TRAP(err, AknsUtils::CreateIconL( aSkin,
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 )
{
SetGraphics( element[i], bitmapPtr, maskPtr, EFalse );
}
}
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::DeleteBitmaps
//
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::DeleteBitmaps()
{
TInt i;
for( i = 0; i <= CAknSlider::EElemMarkerSelected; i++)
{
delete iGfx[i].iRgb;
iGfx[i].iRgb = NULL;
delete iGfx[i].iMask;
iGfx[i].iMask = NULL;
}
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::SetGraphics
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::SetGraphics( TInt aElement,
CFbsBitmap* aBitmap,
CFbsBitmap* aMask,
TBool aCustomize )
{
// element index is assumed to be valid (no checking)
// no need to set rgb or mask to NULL as we are assigning and won't leave
delete iGfx[aElement].iRgb;
iGfx[aElement].iRgb = aBitmap;
delete iGfx[aElement].iMask;
iGfx[aElement].iMask = aMask;
// Set the flag to 1
iGfx[aElement].iCustomizedFlag = aCustomize;
switch( aElement )
{
case CAknSlider::EElemFilledLine:
{
SetFlag( EFlagFillEnabled );
}
break;
case CAknSlider::EElemMarker:
{
SetFlag( EFlagMarkerEnabled );
}
break;
case CAknSlider::EElemTickMark:
{
if( aBitmap==NULL && aMask==NULL )
{
ClearFlag( EFlagTickMarksEnabled );
}
else
{
SetFlag( EFlagTickMarksEnabled );
}
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::UseDefaultGraphics
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::UseDefaultGraphics( TInt aElement )
{
// element index is assumed to be valid (no checking)
delete iGfx[aElement].iRgb;
iGfx[aElement].iRgb = NULL;
delete iGfx[aElement].iMask;
iGfx[aElement].iMask = NULL;
iGfx[aElement].iCustomizedFlag = 0;
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::UsesDefaultGraphics
// ----------------------------------------------------------------------------
//
TBool CAknSliderExtension::UsesDefaultGraphics( TInt aElement ) const
{
// element index is assumed to be valid (no checking)
if ( iGfx[aElement].iCustomizedFlag == 0 )
{
return ETrue;
}
return EFalse;
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::UsesDefaultGraphics
// ----------------------------------------------------------------------------
//
TBool CAknSliderExtension::UsesDefaultGraphics() const
{
// element index is assumed to be valid (no checking)
TBool ret(ETrue);
ret = ret && UsesDefaultGraphics( CAknSlider::EElemEmptyLeftCap ) &&
UsesDefaultGraphics( CAknSlider::EElemEmptyRightCap ) &&
UsesDefaultGraphics( CAknSlider::EElemEmptyLine );
return ret;
}
// ----------------------------------------------------------------------------
// CAknSliderExtension::GetGfx
// ----------------------------------------------------------------------------
//
void CAknSliderExtension::GetGfx( TAknSliderGfx& aGfx, TInt aElement ) const
{
// element index is assumed to be valid (no checking)
aGfx = iGfx[aElement];
}
// ============================================================================
// An internal helper class for creating slider graphics for option setting
// item.
NONSHARABLE_CLASS( CAknSliderIconizer ): public CBase
{
public:
static void CreateSettingsIconL( const TRect& aRect, TInt aValue,
CGulIcon* aIcon, const TInt aMinValue,
const TInt aMaxValue );
static void ReSizeDefaultSettingsIcons( const TRect& aParent,
CAknSliderIconizer* aIcon );
static void ReSizeNewSettingsIcons( const TRect& aParent,
CAknSliderExtension* aExtension,
CAknSliderIconizer* aIcon,
TInt aValue,
const TInt aMinValue,
const TInt aMaxValue );
private:
CAknSliderIconizer();
~CAknSliderIconizer();
void DrawSettingsIconL( const TRect& aRect, TInt aValue, CGulIcon* aIcon,
const TInt aMinValue, const TInt aMaxValue ,
TBool aFlagFilled ) const;
void DrawDefaultSettingsIconL( const TRect& aParent,
TInt aValue,
CFbsBitGc* aFbsBitGc,
const TInt aMinValue,
const TInt aMaxValue ) const;
void DrawNewSettingsIconL( const TRect& aParent,
TInt aValue,
CFbsBitGc* aFbsBitGc,
const TInt aMinValue,
const TInt aMaxValue,
TBool aFilledFlag ) const;
private:
// Stores the element graphics (rgb icon and mask icon) as bitmaps. Bitmaps
// are owned.
TAknSliderGfx iSettingGfx[CAknSlider::EElemMarkerSelected + 1];
};
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
CAknSliderIconizer::CAknSliderIconizer()
{
// Derived from CBase -> members zeroed
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
CAknSliderIconizer::~CAknSliderIconizer()
{
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::CreateSettingsIconL
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::CreateSettingsIconL(
const TRect& aRect, TInt aValue, CGulIcon* aIcon,
const TInt aMinValue, const TInt aMaxValue )
{
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
CAknSliderIconizer* iconizer = new ( ELeave ) CAknSliderIconizer;
CleanupStack::PushL( iconizer );
// Set default value
for ( int i = 0; i <= CAknSlider::EElemMarkerSelected; ++i )
{
iconizer->iSettingGfx[i].iRgb = NULL;
iconizer->iSettingGfx[i].iMask = NULL;
iconizer->iSettingGfx[i].iCustomizedFlag = 0;
}
// aRect = set_value_pane
TAknLayoutRect layoutRect;
layoutRect.LayoutRect( aRect,
AknLayoutScalable_Avkon::slider_set_pane_cp3() );
TRect sliderPane = layoutRect.Rect();
CAknSliderExtension* extension = CAknSliderExtension::NewL();
CleanupStack::PushL( extension );
// Load bitmaps
//1.load new graphics from skin
extension->TryLoadNSliderBitmap( ETrue, skin );
if( extension->UsesDefaultGraphics() )
{
//2. load old graphic from skin
TRAPD( err, {
AknsUtils::CreateIconL( skin,
KAknsIIDQgnIndiSliderSet,
iconizer->iSettingGfx[CAknSlider::EElemMarker].iRgb,
iconizer->iSettingGfx[CAknSlider::EElemMarker].iMask,
KNullDesC,
EMbmAvkonQgn_indi_slider_edit,
EMbmAvkonQgn_indi_slider_edit_mask );
AknsUtils::CreateIconL( skin,
KAknsIIDQgnGrafLinePrimaryHorizontal,
iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iRgb,
iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iMask,
KNullDesC,
EMbmAvkonQgn_graf_line_primary_horizontal,
EMbmAvkonQgn_graf_line_primary_horizontal_mask );
} );
if( !err )
{
ReSizeDefaultSettingsIcons( sliderPane, iconizer );
}
//3.load new from mif, must success
else
{
extension->TryLoadNSliderBitmap( EFalse, skin );
}
}
//new slider layout
ReSizeNewSettingsIcons( sliderPane, extension, iconizer,
aValue, aMinValue,aMaxValue );
iconizer->DrawSettingsIconL( aRect,
aValue,
aIcon,
aMinValue,
aMaxValue,
extension->IsFlagSet(CAknSliderExtension::EFlagFillEnabled));
CleanupStack::PopAndDestroy(); // extension, the bitmaps loaded deleted here
if( iconizer->iSettingGfx[CAknSlider::EElemMarker].iCustomizedFlag == 0 )
{
delete iconizer->iSettingGfx[CAknSlider::EElemMarker].iRgb;
iconizer->iSettingGfx[CAknSlider::EElemMarker].iRgb = NULL;
delete iconizer->iSettingGfx[CAknSlider::EElemMarker].iMask;
iconizer->iSettingGfx[CAknSlider::EElemMarker].iMask = NULL;
}
if( iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iCustomizedFlag == 0 )
{
delete iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iRgb;
iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iRgb = NULL;
delete iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iMask;
iconizer->iSettingGfx[CAknSlider::EElemEmptyLine].iMask = NULL;
}
CleanupStack::PopAndDestroy( iconizer );
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::ReSizeDefaultSettingsIcons
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::ReSizeDefaultSettingsIcons( const TRect& aParent,
CAknSliderIconizer* aIcon )
{
TAknLayoutRect temp;
TRect lineRect,markerRect;
//old slider layout
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g1() );
lineRect = temp.Rect();
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g2() );
markerRect = temp.Rect();
if( aIcon->iSettingGfx[CAknSlider::EElemEmptyLine].iRgb != NULL &&
aIcon->iSettingGfx[CAknSlider::EElemMarker].iRgb != NULL )
{
AknIconUtils::SetSize( aIcon->iSettingGfx[CAknSlider::EElemEmptyLine].iRgb,
lineRect.Size(),
EAspectRatioNotPreserved );
AknIconUtils::SetSize( aIcon->iSettingGfx[CAknSlider::EElemMarker].iRgb,
markerRect.Size() );
}
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::ReSizeNewSettingsIcons
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::ReSizeNewSettingsIcons( const TRect& aParent,
CAknSliderExtension* aExtentsion,
CAknSliderIconizer* aIcon,TInt aValue,
const TInt aMinValue,
const TInt aMaxValue )
{
TAknLayoutRect temp;
TRect lineRect,markerRect,leftCapRect,rightCapRect,tickRect;
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g4() );
lineRect = temp.Rect();
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g3() );
leftCapRect = temp.Rect();
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g5() );
rightCapRect = temp.Rect();
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g6() );
markerRect = temp.Rect();
temp.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g7() );
tickRect = temp.Rect();
TSize size;
for ( int i = 0; i <= CAknSlider::EElemMarkerSelected; ++i )
{
if( !aExtentsion->UsesDefaultGraphics(i) )
{
aExtentsion->GetGfx( aIcon->iSettingGfx[i], i );
switch( i )
{
case CAknSlider::EElemEmptyLine:
{
size = lineRect.Size();
break;
}
case CAknSlider::EElemMarker:
case CAknSlider::EElemMarkerSelected:
{
size = markerRect.Size();
break;
}
case CAknSlider::EElemTickMark:
{
size = tickRect.Size();
break;
}
case CAknSlider::EElemEmptyLeftCap:
{
size = leftCapRect.Size();
break;
}
case CAknSlider::EElemEmptyRightCap:
{
size = rightCapRect.Size();
break;
}
case CAknSlider::EElemFilledLeftCap:
{
size = leftCapRect.Size();
break;
}
case CAknSlider::EElemFilledRightCap:
{
size = rightCapRect.Size();
break;
}
case CAknSlider::EElemFilledLine:
{
TInt bmpRun = lineRect.Width() +
leftCapRect.Width() +
rightCapRect.Width() -
markerRect.Width();
TInt pos = ( ( bmpRun * ( aValue - aMinValue ) ) /
(aMaxValue - aMinValue ) );
TPoint markerPos = TPoint( pos + markerRect.iTl.iX, markerRect.iTl.iY );
size.iWidth = markerPos.iX + (markerRect.Width()/2) -
lineRect.iTl.iX;
size.iHeight = lineRect.Height();
break;
}
default:
Panic( EAknPanicInvalidValue );
}
if( aIcon->iSettingGfx[i].iRgb != NULL &&
aIcon->iSettingGfx[i].iMask != NULL )
{
AknIconUtils::SetSize( aIcon->iSettingGfx[i].iRgb,
size,
EAspectRatioNotPreserved );
AknIconUtils::SetSize( aIcon->iSettingGfx[i].iMask,
size,
EAspectRatioNotPreserved );
aIcon->iSettingGfx[i].iCustomizedFlag = 1;
}
}
}
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::DrawSettingsIconL
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::DrawSettingsIconL(
const TRect& aRect, TInt aValue, CGulIcon* aIcon,
const TInt aMinValue, const TInt aMaxValue, TBool aFilledFlag ) const
{
// The actual bitmap
CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap;
CleanupStack::PushL( bitmap );
User::LeaveIfError( bitmap->Create(
aRect.Size(), CCoeEnv::Static()->ScreenDevice()->DisplayMode() ) );
CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();
CleanupStack::PushL( fbsBitGc );
CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL( bitmap );
CleanupStack::PushL( bmpDevice );
fbsBitGc->Activate( bmpDevice );
TRect outerRect;
TRect innerRect;
TRect origin;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, origin );
TAknLayoutRect layoutRect;
layoutRect.LayoutRect( origin,
AknLayoutScalable_Avkon::listscroll_gen_pane( 0 ) );
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::list_gen_pane( 0 ) );
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::list_setting_number_pane( 0 ) );
TRect listSettingPaneRect( layoutRect.Rect() );
// 1. Background skinning
TAknLayoutRect innerLayRect;
// New style LAF data used
#ifdef RD_LIST_STRETCH
// check list stretching from cenrep
TBool stretchingEnabled;
CRepository* cenRep = CRepository::NewL( KCRUidAvkon );
cenRep->Get( KAknAutomaticListStretching, stretchingEnabled );
delete cenRep;
if ( Layout_Meta_Data::IsLandscapeOrientation() &&
Layout_Meta_Data::IsListStretchingEnabled() &&
stretchingEnabled )
{
layoutRect.LayoutRect( listSettingPaneRect,
AknLayoutScalable_Avkon::set_value_pane_vc( 0 ) );
}
else
{
layoutRect.LayoutRect( listSettingPaneRect,
AknLayoutScalable_Avkon::set_value_pane( 0 ) );
}
#else
layoutRect.LayoutRect( listSettingPaneRect,
AknLayoutScalable_Avkon::set_value_pane( 0 ) );
#endif
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::bg_set_opt_pane( 0 ) );
innerLayRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::bg_set_opt_pane_g1() );
// Move to 0,0
outerRect = layoutRect.Rect();
TPoint skinOffset( -outerRect.iTl.iX, -outerRect.iTl.iY );
innerRect = innerLayRect.Rect();
outerRect.Move( skinOffset );
innerRect.Move( skinOffset );
// Frame IID for qsn_fr_set_opt_foc_xxxxx
const TAknsItemID *frameId = &KAknsIIDQsnFrSetOptFoc;
// Make a control context:
CAknsFrameBackgroundControlContext* cc =
CAknsFrameBackgroundControlContext::NewL(
*frameId, outerRect, innerRect, EFalse );
CleanupStack::PushL( cc );
TPoint dstPos( 0, 0 );
AknsDrawUtils::DrawBackground( AknsUtils::SkinInstance(), cc, NULL,
*fbsBitGc, dstPos, outerRect, KAknsDrawParamDefault );
CleanupStack::PopAndDestroy(); // cc
// 2. Draw the line and marker on top of the background
// aRect = set_value_pane
layoutRect.LayoutRect( aRect,
AknLayoutScalable_Avkon::slider_set_pane_cp3() );
TRect parent = layoutRect.Rect();
//new graphic or old
if( iSettingGfx[CAknSlider::EElemEmptyLeftCap].iCustomizedFlag != 1 &&
iSettingGfx[CAknSlider::EElemEmptyRightCap].iCustomizedFlag != 1 )
{
DrawDefaultSettingsIconL( parent, aValue, fbsBitGc,
aMinValue, aMaxValue );
}
else
{
DrawNewSettingsIconL( parent, aValue, fbsBitGc, aMinValue,
aMaxValue, aFilledFlag );
}
CleanupStack::PopAndDestroy( 2 ); // bmpDevice, fbsBitGc
// Transfers ownership, so all we need to do is to..
aIcon->SetBitmap( bitmap );
CleanupStack::Pop(); // bitmap
// 3. The mask
CFbsBitmap* mask = new ( ELeave ) CFbsBitmap;
CleanupStack::PushL( mask );
TDisplayMode mode = iSettingGfx[CAknSlider::EElemEmptyLine].iMask->DisplayMode();
if ( mode == ENone )
{
mode = EGray256;
}
User::LeaveIfError( mask->Create( aRect.Size(), mode ) );
fbsBitGc = CFbsBitGc::NewL();
CleanupStack::PushL( fbsBitGc );
bmpDevice = CFbsBitmapDevice::NewL( mask );
CleanupStack::PushL( bmpDevice );
fbsBitGc->Activate( bmpDevice );
fbsBitGc->SetPenStyle( CGraphicsContext::ENullPen );
fbsBitGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
fbsBitGc->SetBrushColor( KRgbWhite );
fbsBitGc->DrawRect( TRect( aRect.Size() ) );
fbsBitGc->SetBrushStyle( CGraphicsContext::ENullBrush );
AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), *fbsBitGc,
outerRect, innerRect,
KAknsIIDQsnFrSetOptFoc,
KAknsIIDQsnFrSetOptFocCenter,
KAknsSDMAlphaOnly );
CleanupStack::PopAndDestroy( 2 ); // bmpDevice, fbsBitGc
// Transfers ownership, so all we need to do is to..
aIcon->SetMask( mask );
CleanupStack::Pop(); // mask
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::DrawDefaultSettingsIconL
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::DrawDefaultSettingsIconL(
const TRect& aParent, TInt aValue, CFbsBitGc* aFbsBitGc,
const TInt aMinValue, const TInt aMaxValue ) const
{
TRect lineRect, markerRect;
TInt bitmapRun;
TAknLayoutRect layoutRect;
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g1() );
lineRect = layoutRect.Rect();
TAknLayoutRect markerLayout;
markerLayout.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g2() );
markerRect = markerLayout.Rect();
bitmapRun = lineRect.Width() - markerRect.Width();
//new graphic and old graphic is in the same place
aFbsBitGc->BitBltMasked( TPoint( lineRect.iTl.iX, lineRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemEmptyLine].iRgb,
TRect( 0, 0, lineRect.Width(), lineRect.Height()),
iSettingGfx[CAknSlider::EElemEmptyLine].iMask,
EFalse);
// Calculate the correct position where to draw the marker
TInt range = aMaxValue - aMinValue;
// It is this expression which determines the functional direction of
// the slider in its drawing (but not its event handling).
TInt pos = ( ( bitmapRun * ( aValue - aMinValue ) ) / range );
TPoint markerPos = TPoint( pos + markerRect.iTl.iX, markerRect.iTl.iY );
TRect srcRect( 0, 0, markerRect.Width(), markerRect.Height() );
aFbsBitGc->BitBltMasked( markerPos,
iSettingGfx[CAknSlider::EElemMarker].iRgb,
srcRect,
iSettingGfx[CAknSlider::EElemMarker].iMask,
EFalse);
}
// ----------------------------------------------------------------------------
// CAknSliderIconizer::DrawNewSettingsIconL
// ----------------------------------------------------------------------------
//
void CAknSliderIconizer::DrawNewSettingsIconL(
const TRect& aParent, TInt aValue, CFbsBitGc* aFbsBitGc,
const TInt aMinValue, const TInt aMaxValue, TBool aFilledFlag ) const
{
TRect lineRect, markerRect, leftCapRect, rightCapRect, tickRect;
TInt bitmapRun;
TAknLayoutRect layoutRect;
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g4() );
lineRect = layoutRect.Rect();
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g3() );
leftCapRect = layoutRect.Rect();
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g5() );
rightCapRect = layoutRect.Rect();
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g6() );
markerRect = layoutRect.Rect();
layoutRect.LayoutRect( aParent,
AknLayoutScalable_Avkon::slider_set_pane_g7() );
tickRect = layoutRect.Rect();
bitmapRun = lineRect.Width() +
leftCapRect.Width() +
rightCapRect.Width() -
markerRect.Width();
//new graphic and old graphic is in the same place
aFbsBitGc->BitBltMasked( TPoint( lineRect.iTl.iX, lineRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemEmptyLine].iRgb,
TRect( 0, 0, lineRect.Width(), lineRect.Height()),
iSettingGfx[CAknSlider::EElemEmptyLine].iMask,
EFalse);
//leftcap, rightcap,filled line,tick
aFbsBitGc->BitBltMasked( TPoint( leftCapRect.iTl.iX, leftCapRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemEmptyLeftCap].iRgb,
TRect(0, 0, leftCapRect.Width(), leftCapRect.Height()),
iSettingGfx[CAknSlider::EElemEmptyLeftCap].iMask,
EFalse);
aFbsBitGc->BitBltMasked( TPoint( rightCapRect.iTl.iX, rightCapRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemEmptyRightCap].iRgb,
TRect( 0, 0, rightCapRect.Width(), rightCapRect.Height()),
iSettingGfx[CAknSlider::EElemEmptyRightCap].iMask,
EFalse );
// Calculate the correct position where to draw the marker
TInt range = aMaxValue - aMinValue;
// It is this expression which determines the functional direction of
// the slider in its drawing (but not its event handling).
TInt pos = ( ( bitmapRun * ( aValue - aMinValue ) ) / range );
TPoint markerPos = TPoint( pos + markerRect.iTl.iX, markerRect.iTl.iY );
//filled enable, draw filled line
if( aFilledFlag )
{
// filled line and cap
TInt fillWidth = markerPos.iX + markerRect.Width()/2 - lineRect.iTl.iX;
aFbsBitGc->BitBltMasked( TPoint( lineRect.iTl.iX, lineRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemFilledLine].iRgb,
TRect(0, 0, fillWidth, lineRect.Height()),
iSettingGfx[CAknSlider::EElemFilledLine].iMask,
EFalse);
//left cap always filled
if( aValue != aMinValue )
{
aFbsBitGc->BitBltMasked( TPoint( lineRect.iTl.iX, lineRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemFilledLeftCap].iRgb,
TRect(0, 0, leftCapRect.Width(), leftCapRect.Height()),
iSettingGfx[CAknSlider::EElemFilledLine].iMask,
EFalse);
}
//only when the line filled, the right cap filled
if( aValue >= aMaxValue )
{
aFbsBitGc->BitBltMasked( TPoint( lineRect.iTl.iX, lineRect.iTl.iY ),
iSettingGfx[CAknSlider::EElemFilledRightCap].iRgb,
TRect( 0, 0, rightCapRect.Width(), rightCapRect.Height()),
iSettingGfx[CAknSlider::EElemFilledLine].iMask,
EFalse);
}
}
else
{
TRect srcRect( 0, 0, markerRect.Width(), markerRect.Height() );
aFbsBitGc->BitBltMasked( markerPos,
iSettingGfx[CAknSlider::EElemMarker].iRgb,
srcRect,
iSettingGfx[CAknSlider::EElemMarker].iMask,
EFalse);
}
}
// ============================================================================
// ----------------------------------------------------------------------------
// Default constructor
// ----------------------------------------------------------------------------
//
EXPORT_C CAknSlider::CAknSlider()
{
// Derived from CBase -> members zeroed
AKNTASHOOK_ADD( this, "CAknSlider" );
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
EXPORT_C CAknSlider::~CAknSlider()
{
AKNTASHOOK_REMOVE();
AknsUtils::DeregisterControlPosition( this );
delete iValueLabel;
delete iMinLabel;
delete iMaxLabel;
delete iMarkerBmp;
delete iMarkerMaskBmp;
delete iImage;
delete iData;
delete iExt;
}
// ----------------------------------------------------------------------------
// CAknSlider::ConstructL
// Creates the labels.
// ----------------------------------------------------------------------------
//
void CAknSlider::ConstructL()
{
iExt = CAknSliderExtension::NewL();
InitializeBitmapsL();
iValueLabel = new( ELeave ) CEikLabel;
iValueLabel->UseLogicalToVisualConversion( EFalse );
iValueLabel->SetContainerWindowL( *this );
iMinLabel = new( ELeave ) CEikLabel;
iMinLabel->SetContainerWindowL( *this );
iMaxLabel = new( ELeave ) CEikLabel;
iMaxLabel->SetContainerWindowL( *this );
if ( AknLayoutUtils::PenEnabled() && ( &Window() != NULL ) )
{
// Enable drag events, it will then be possible to drag from thumb
EnableDragEvents();
//Enable dragging to start from thumb and then move outside the slider
DrawableWindow()->SetPointerGrab( ETrue );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::InitializeBitmapsL
// ----------------------------------------------------------------------------
//
void CAknSlider::InitializeBitmapsL()
{
if ( iExt->iLineIcon )
{
delete iExt->iLineIcon;
iExt->iLineIcon = NULL;
delete iExt->iLineIconMask;
iExt->iLineIconMask = NULL;
}
iExt->DeleteBitmaps();
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
if( Layout() == EAknSliderLayoutVertical ) //vertical
{
//1.load default graphic for new vertical slider
iExt->ClearFlag( CAknSliderExtension::EFlagHorizontal );
iExt->TryLoadNSliderVerticalBitmap( skin );
}
else if ( Layout() == EAknSliderLayoutHorizontal )
{
iExt->TryLoadNSliderBitmap( ETrue, skin );
}
else // horizonal
{
//1.load new from skin
iExt->TryLoadNSliderBitmap( ETrue, skin );
if( iExt->UsesDefaultGraphics() )
{
//2.load old from skin
TRAPD( err,
{
AknsUtils::CreateIconL( skin,
KAknsIIDQgnGrafLinePrimaryHorizontal,
iExt->iLineIcon,
iExt->iLineIconMask,
KNullDesC,
EMbmAvkonQgn_graf_line_primary_horizontal,
EMbmAvkonQgn_graf_line_primary_horizontal_mask);
AknsUtils::CreateIconL( skin,
KAknsIIDQgnIndiSliderEdit,
iMarkerBmp,
iMarkerMaskBmp,
KNullDesC,
EMbmAvkonQgn_indi_slider_edit,
EMbmAvkonQgn_indi_slider_edit_mask);
} );
//3.load new from mif, must success.
if( err )
{
iExt->TryLoadNSliderBitmap( EFalse, skin );
}
}
}
}
// ----------------------------------------------------------------------------
// CAknSlider::SetValueL
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetValueL( TInt aValue )
{
// Note that this assert will panic any value that is not aligned on the
// step size relative to the minimum value;
__ASSERT_DEBUG( aValue >= MinimumValue() &&
aValue<= MaximumValue() &&
( aValue-MinimumValue() ) % StepSize() == 0,
Panic( EAknPanicOutOfRange ) );
iValue = aValue;
if ( iValueLabel != NULL )
{
SetValueTextL();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::Value
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CAknSlider::Value() const
{
return iValue;
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateBitmapL
// Returns slider bitmap to "list pane for setting item" (setting option item
// slider graphic). Ownership of the bitmap is transferred to the caller.
// ----------------------------------------------------------------------------
//
EXPORT_C CFbsBitmap* CAknSlider::CreateBitmapL( TInt aValue, TInt aResourceId )
{
TResourceReader reader;
CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );
reader.ReadInt16(); // ignore layout
TInt minValue = reader.ReadInt16();
TInt maxValue = reader.ReadInt16();
CleanupStack::PopAndDestroy(); // reader
return CreateBitmapL( aValue, minValue, maxValue );
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateBitmapL
// Returns slider bitmap to "list pane for setting item" (setting option item
// slider graphic). Ownership of the bitmap is transferred to the caller.
// ----------------------------------------------------------------------------
//
EXPORT_C CFbsBitmap* CAknSlider::CreateBitmapL(
TInt aValue, TInt aMinimumValue, TInt aMaximumValue )
{
CGulIcon* icon = CreateSetStyleListBoxIconL(
aValue, aMinimumValue, aMaximumValue ); // now have ownership
icon->SetBitmapsOwnedExternally( ETrue );
CFbsBitmap* bitmap = icon->Bitmap();
CFbsBitmap* mask = icon->Mask();
delete icon;
delete mask;
return bitmap; // ownership transferred
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateSetStyleListBoxIconL
// Returns slider icon to "list pane for setting item" (setting option item
// slider graphic). Ownership of the icon is transferred to the caller.
// ----------------------------------------------------------------------------
//
EXPORT_C CGulIcon* CAknSlider::CreateSetStyleListBoxIconL(
TInt aValue, TInt aResourceId )
{
TResourceReader reader;
CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );
reader.ReadInt16(); // ignore layout
TInt minValue = reader.ReadInt16();
TInt maxValue = reader.ReadInt16();
CleanupStack::PopAndDestroy(); // reader
return CreateSetStyleListBoxIconL( aValue, minValue, maxValue );
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateSetStyleListBoxIconL
// Returns slider icon to "list pane for setting item" (setting option item
// slider graphic). Ownership of the icon is transferred to the caller.
// ----------------------------------------------------------------------------
//
EXPORT_C CGulIcon* CAknSlider::CreateSetStyleListBoxIconL(
TInt aValue, TInt aMinimumValue, TInt aMaximumValue )
{
__ASSERT_ALWAYS( aMaximumValue > aMinimumValue,
Panic( EAknPanicOutOfRange ) );
__ASSERT_ALWAYS( ( aValue <= aMaximumValue ) &&
( aValue >= aMinimumValue ),
Panic( EAknPanicOutOfRange ) );
// Make the icon and put it in the array
CGulIcon* icon = CGulIcon::NewLC();
TRect origin;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, origin );
TAknLayoutRect layoutRect;
layoutRect.LayoutRect( origin,
AknLayoutScalable_Avkon::listscroll_gen_pane( 0 ) );
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::list_gen_pane( 0 ) );
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::list_setting_number_pane( 0 ) );
TRect listSettingPaneRect( layoutRect.Rect());
#ifdef RD_LIST_STRETCH
// check list stretching from cenrep
TBool stretchingEnabled;
CRepository* cenRep = CRepository::NewL( KCRUidAvkon );
cenRep->Get( KAknAutomaticListStretching, stretchingEnabled );
delete cenRep;
if ( Layout_Meta_Data::IsLandscapeOrientation() &&
Layout_Meta_Data::IsListStretchingEnabled() &&
stretchingEnabled )
{
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::set_value_pane_vc( 0 ) );
}
else
{
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::set_value_pane( 0 ) );
}
#else
layoutRect.LayoutRect( layoutRect.Rect(),
AknLayoutScalable_Avkon::set_value_pane( 0 ) );
#endif
TRect setValuePaneRect( layoutRect.Rect() );
TRect rect( setValuePaneRect );
// Move to 0,0
rect.Move( -rect.iTl.iX, -rect.iTl.iY );
CAknSliderIconizer::CreateSettingsIconL( rect, aValue, icon,
aMinimumValue, aMaximumValue );
CleanupStack::Pop( icon ); // icon - not owned anymore, do not destroy
return icon; // ownership transferred
}
// ----------------------------------------------------------------------------
// CAknSlider::SetRange
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetRange( TInt aMinimumValue, TInt aMaximumValue )
{
SliderData()->SetRange( aMinimumValue, aMaximumValue );
}
// ----------------------------------------------------------------------------
// CAknSlider::GetRange
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::GetRange( TInt& aMinimumValue, TInt& aMaximumValue )
{
aMaximumValue = MaximumValue();
aMinimumValue = MinimumValue();
}
// ----------------------------------------------------------------------------
// CAknSlider::SetStepSize
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetStepSize( TInt aStepSize )
{
// This assert is only done for CAknSlider, as the step size is not
// particularly relevant for the data; That is, if you are just interested
// in CAknSliderData in order to format a value label, then you might want
// to ignore the restrictions on stepsize
__ASSERT_ALWAYS( aStepSize != 0 && SliderData()->Range() % aStepSize == 0,
Panic( EAknPanicOutOfRange ) );
SliderData()->iStepSize = aStepSize;
}
// ----------------------------------------------------------------------------
// CAknSlider::SetValueTextL
// Sets the text for the value label.
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetValueTextL()
{
TBuf<KValueLabelTextMaxLength + KAknBidiExtraSpacePerLine> textBuf;
DoSetValueTextL( textBuf, iValue, *SliderData() );
AknBidiTextUtils::ConvertToVisualAndClipL( textBuf,
*( iValueLabel->Font() ),
iValueLabel->Size().iWidth,
iValueLabel->Size().iWidth );
iValueLabel->SetTextL( textBuf );
}
// ----------------------------------------------------------------------------
// CAknSlider::DoSetValueTextL
// ----------------------------------------------------------------------------
//
void CAknSlider::DoSetValueTextL( TDes& aTextBuf, TInt aValue,
const CAknSliderData& aSliderData )
{
TBuf<KAknSliderValueLabelValueMaxLength> valueBuf;
_LIT( KBareFigure, "%d" );
_LIT( KFraction, "%d/%d" );
switch ( aSliderData.iValueType )
{
case EAknSliderValueBareFigure:
valueBuf.Format( KBareFigure, aValue ); // bare figure
break;
case EAknSliderValuePercentage:
{
TInt num = ( 100 * ( aValue - aSliderData.iMinimumValue ) ) /
aSliderData.Range();
HBufC* percentage = StringLoader::LoadLC( R_QTN_SELECT_SLIDER_VALUE,num );
valueBuf.Copy( *percentage );
CleanupStack::PopAndDestroy( percentage );
}
break;
case EAknSliderValueFraction:
valueBuf.Format( KFraction, aValue, aSliderData.iMaximumValue ); // x/y
break;
case EAknSliderValueDecimal:
{
TReal r;
Math::Pow10( r, aSliderData.DecimalPlaces() );
// First have to format the format.
TBuf<8> format;
// This allows for 2 digit field size and/or decimal places
_LIT( KFormatTemplate, "%%-%d.%df" );
format.Format( KFormatTemplate,
KAknSliderValueLabelValueMaxLength,
aSliderData.DecimalPlaces() );
valueBuf.Format( format, aValue / r );
valueBuf.TrimAll();
}
break;
default:
break; // valueBuf left empty
} // end switch
// Convert this formatted number if necessary to display language-sensitive
// numerals
AknTextUtils::DisplayTextLanguageSpecificNumberConversion( valueBuf );
// A text pointer for the format string
TPtr formatPtr( 0, 0 );
if ( aSliderData.iText != NULL )
{
formatPtr.Set( aSliderData.iText->Des() );
}
if ( aSliderData.iSingularText != NULL )
{
// format with %U in the supplied text. But only if value = 1 and we
// are using bare figure layout
if ( ( aValue == 1 ) &&
( aSliderData.iValueType == EAknSliderValueBareFigure ) )
{
formatPtr.Set( aSliderData.iSingularText->Des() );
}
}
if ( formatPtr.Length() > 0 )
{
FormatWithOrWithoutTokenL( aTextBuf, formatPtr, valueBuf );
}
else
{
aTextBuf.Copy( valueBuf.Left( KAknSliderValueLabelValueMaxLength ) );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::FormatWithOrWithoutTokenL
//
// This method is used to protect the call to StringLoader::Format against
// passing it texts with no token. If you do, it panics.
//
// The protection here is still far from perfect, as only % is looked for. So
// there is still a problem.
//
// StringLoader itself should take on this responsibility and not panic. In
// this case, the call to this routine would just be the code in the 2nd half.
// ----------------------------------------------------------------------------
//
void CAknSlider::FormatWithOrWithoutTokenL(
TDes& aOutput, const TDesC& aFormat, const TDesC& aValue )
{
if ( aFormat.Locate('%') == -1 )
{
aOutput.Copy( aFormat.Left( KValueLabelTextMaxLength ) );
}
else
{
// We can know that the length of the resulting formatted string will
// be less than or equal to the sum of the two lengths Wierd effects in
// string loader mean we have to add 2 more (It adds key length instead
// of subtracting it sometimes)....
TInt safeLength = aValue.Length() + aFormat.Length() +
KAknSliderFormatKeyLength;
// No leaving methods are going to be called
HBufC* wholeTextBuf = HBufC::NewL( safeLength );
TPtr wholeTextPtr = wholeTextBuf->Des();
// Value for when no %U or when there is no number (%NU)
TInt keyIndex = -1;
StringLoader::Format( wholeTextPtr, aFormat, keyIndex, aValue );
aOutput.Copy( wholeTextPtr.Left( KValueLabelTextMaxLength ) );
delete wholeTextBuf;
}
}
// ----------------------------------------------------------------------------
// DoSetLabelTextL
// Local function to gather together arabization of minimum/maximum strings.
// Static to make the function local to this compilation unit only (i.e. not
// polluting the global namespace).
// ----------------------------------------------------------------------------
static void DoSetLabelTextL( const TDesC& aText, CEikLabel* aLabel )
{
if ( aLabel )
{
HBufC* localBuf = aText.AllocLC();
TPtr ptr = localBuf->Des();
AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
aLabel->SetTextL( ptr ); // Makes copy of buffer
CleanupStack::PopAndDestroy( localBuf );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::SetMinimumTextL
// Sets the text for the minimum label.
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetMinimumTextL( const TDesC& aText )
{
DoSetLabelTextL( aText, iMinLabel );
}
// ----------------------------------------------------------------------------
// CAknSlider::SetMaximumTextL
// Sets the text for the maximum label.
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetMaximumTextL( const TDesC& aText )
{
DoSetLabelTextL( aText, iMaxLabel );
}
// ----------------------------------------------------------------------------
// CAknSlider::MinimumSize
// ----------------------------------------------------------------------------
//
TSize CAknSlider::MinimumSize()
{
TInt index = 0;
if ( iEditable )
{
if ( Layout() == EAknFormSliderLayout3 )
{
index = 0;
}
else if ( Layout() == EAknFormSliderLayout2 )
{
index = 1;
}
else if ( Layout() == EAknFormSliderLayout1 )
{
index = 2;
}
}
TAknLayoutRect temp, layout;
temp.LayoutRect( TRect( 0, 0, 0, 0 ),
AknLayoutScalable_Avkon::Screen() );
layout.LayoutRect( temp.Rect(),
AknLayoutScalable_Avkon::listscroll_form_pane() );
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::list_form_gen_pane() );
layout.LayoutRect( temp.Rect(),
AknLayoutScalable_Avkon::form_field_slider_pane( index ) );
return layout.Rect().Size();
}
// ----------------------------------------------------------------------------
// CAknSlider::OfferKeyEventL
// Handles the key events.
// ----------------------------------------------------------------------------
//
TKeyResponse CAknSlider::OfferKeyEventL(
const TKeyEvent& aKeyEvent, TEventCode aType )
{
// If not a key event or in view mode
if ( aType != EEventKey || !iEditable )
{
return EKeyWasNotConsumed;
}
TInt step = StepSize();
TBool hor = iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal );
iExt->iPenInputPos = TPoint( -1, -1 );
if ( EKeyLeftArrow == aKeyEvent.iCode && hor )
{
TranslateValueL( -step );
}
else if ( EKeyRightArrow == aKeyEvent.iCode && hor )
{
TranslateValueL( step );
}
else if ( EKeyDownArrow == aKeyEvent.iCode && !hor )
{
TranslateValueL( -step );
}
else if ( EKeyUpArrow == aKeyEvent.iCode && !hor )
{
TranslateValueL( step );
}
else
{
return EKeyWasNotConsumed;
}
return EKeyWasConsumed;
}
// ----------------------------------------------------------------------------
// CAknSlider::ConstructFromResourceL
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::ConstructFromResourceL( TResourceReader& aReader )
{
iData = CAknSliderData::NewL( aReader );
ConstructL();
// Apply constraints on the read stepsize here
SetStepSize( StepSize() );
// Set the labels up
if ( SliderData()->iMinimumLabelText )
{
SetMinimumTextL( *( SliderData()->iMinimumLabelText ) );
}
if ( SliderData()->iMaximumLabelText )
{
SetMaximumTextL( *( SliderData()->iMaximumLabelText ) );
}
// Create graphics if needed
if ( Layout() == EAknSettingsItemSliderLayoutWithGraphics )
{
CreateDecoratorImageFromResourceL( SliderData()->iDecoratorImageId );
}
TAknLayoutRect layoutRect;
TRect containerRect;
if( Layout() == EAknSliderLayoutVertical )
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,
containerRect );
layoutRect.LayoutRect(containerRect,AknLayoutScalable_Avkon::main_pane(13) );
containerRect = layoutRect.Rect();
layoutRect.LayoutRect( containerRect,
AknLayoutScalable_Avkon::popup_slider_window(0) );
containerRect = layoutRect.Rect();
SetRect( containerRect );
}
else if( Layout() == EAknSliderLayoutHorizontal )
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,
containerRect );
layoutRect.LayoutRect(containerRect,AknLayoutScalable_Apps::main_pane(0) );
containerRect = layoutRect.Rect();
layoutRect.LayoutRect( containerRect,
AknLayoutScalable_Apps::main_video_tele_pane(0) );
containerRect = layoutRect.Rect();
layoutRect.LayoutRect( containerRect,
AknLayoutScalable_Apps::popup_vtel_slider_window(0) );
containerRect = layoutRect.Rect();
SetRect( containerRect );
}
else
{
SetRect( MinimumSize() );
}
SetValueTextL();
}
// ----------------------------------------------------------------------------
// CAknSlider::ConstructFromResourceL
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::ConstructFromResourceL(
CCoeControl* aParent, TInt aValue, TResourceReader& aReader )
{
SetContainerWindowL( *aParent );
ConstructFromResourceL( aReader ); // Call basic ConstructFromResourceL()
SetValueL( aValue );
ActivateL();
//DrawNow();
}
// ----------------------------------------------------------------------------
// CAknSlider::HandleResourceChange
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::HandleResourceChange( TInt aType )
{
CCoeControl::HandleResourceChange( aType );
switch ( aType )
{
case KEikMessageCaptionedControlEditableStateChange:
{
iEditable = ETrue;
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->EnableFeedbackForControl( this, ETrue );
}
}
break;
case KEikMessageCaptionedControlNotEditableStateChange:
{
iEditable = EFalse;
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->EnableFeedbackForControl( this, EFalse );
}
}
break;
case KAknsMessageSkinChange:
{
SetLabelColor();
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CAknSlider::CountComponentControls
// Standard CCoeControl routine to return the number of component controls.
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CAknSlider::CountComponentControls() const
{
TInt count = 0;
CCoeControl* controls[] = { iValueLabel, iMaxLabel, iMinLabel, iImage };
for ( TUint ii = 0; ii < sizeof( controls ) / sizeof( CCoeControl* ); ++ii )
{
if ( controls[ii] )
{
count++;
}
}
return count;
}
// ----------------------------------------------------------------------------
// CAknSlider::ComponentControl
// Standard CCoeControl routine to return the control at a given index
// ----------------------------------------------------------------------------
//
EXPORT_C CCoeControl* CAknSlider::ComponentControl( TInt aIndex ) const
{
CCoeControl* controls[] = { iValueLabel, iMaxLabel, iMinLabel, iImage };
for ( TUint ii = 0; ii < sizeof( controls ) / sizeof( CCoeControl* ); ++ii )
{
if ( controls[ii] && aIndex-- == 0 )
{
return controls[ii];
}
}
return NULL;
}
// ----------------------------------------------------------------------------
// CAknSlider::SizeChanged
// Sets the layout.
// ----------------------------------------------------------------------------
//
void CAknSlider::SizeChanged()
{
switch ( Layout() )
{
case EAknFormSliderLayout1:
{
FormSliderLayout1();
break;
}
case EAknFormSliderLayout2:
{
FormSliderLayout2();
break;
}
case EAknFormSliderLayout3:
{
FormSliderLayout3();
break;
}
case EAknSettingsItemSliderLayout:
case EAknSettingsItemSliderLayoutWithGraphics:
{
SettingsItemSliderLayout();
break;
}
case EAknMIDPFormSliderLayout:
{
MIDPFormSliderLayout();
break;
}
case EAknSliderLayoutVertical:
{
VerticalSliderLayout();
break;
}
case EAknSliderLayoutHorizontal:
{
HorizontalSliderLayout();
break;
}
default:
break;
}
TAknLayoutRect horLine;
if ( Layout() == EAknSettingsItemSliderLayout ||
Layout() == EAknSettingsItemSliderLayoutWithGraphics ||
Layout() == EAknSliderLayoutVertical ||
Layout() == EAknSliderLayoutHorizontal )
{
horLine.LayoutRect( iMarkerArea,
AKN_LAYOUT_WINDOW_Slider_pane_elements_Line_1 );
}
else
{
horLine.LayoutRect( iMarkerArea,
AKN_LAYOUT_WINDOW_Slider_pane_elements__form__Line_1 );
}
TRect horRect = horLine.Rect();
iColor = horLine.Color();
SetLabelColor();
AknsUtils::RegisterControlPosition( this );
}
// ----------------------------------------------------------------------------
// CAknSlider::FormSliderLayout1
// Pure layout function. Value label is shown in the same place in View and
// Edit modes.
// ----------------------------------------------------------------------------
//
void CAknSlider::FormSliderLayout1()
{
TRect rect = Rect();
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_2 );
TAknLayoutRect layoutRect;
// slider_form_pane
TAknLayoutRect temp, layout;
temp.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_cont_pane( 2 ) );
layout.LayoutRect( temp.Rect(),
AknLayoutScalable_Avkon::slider_form_pane( 1 ) );
iMarkerArea = layout.Rect();
// Load new slider layout if exist
if( !(iExt->UsesDefaultGraphics()) )
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g4() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g3() );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g5() );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g7() );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g6() );
iExt->iThumbRect = temp.Rect();
}
else
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g1() );
AknIconUtils::SetSize( iExt->iLineIcon, temp.Rect().Size() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g2() );
iExt->iThumbRect = temp.Rect();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::FormSliderLayout2
// Pure layout function. Value label is not shown in the same place in Edit
// mode.
// ----------------------------------------------------------------------------
//
void CAknSlider::FormSliderLayout2()
{
TRect rect = Rect();
if ( iEditable )
{
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_3( 0, 0 ) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_3( 2, 2 ) );
TAknLayoutRect temp, layout;
temp.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_cont_pane( 1 ) );
layout.LayoutRect( temp.Rect(),
AknLayoutScalable_Avkon::slider_form_pane( 0 ) );
iMarkerArea = layout.Rect();
//Load new slider layout if exist
if( !(iExt->UsesDefaultGraphics() ) )
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g4() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g3() );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g5() );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g7() );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g6() );
iExt->iThumbRect = temp.Rect();
}
else
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g1() );
AknIconUtils::SetSize( iExt->iLineIcon, temp.Rect().Size() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g2() );
iExt->iThumbRect = temp.Rect();
}
if ( iValueLabel )
{
// Label must not overlap control but width is used to set view
// mode text
TSize tempSize = iValueLabel->Size();
iValueLabel->SetSize( TSize( tempSize.iWidth, 0 ) );
}
}
else
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_2 );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::FormSliderLayout3
// Pure layout function. Value label is not shown in the same place in Edit
// mode.
// ----------------------------------------------------------------------------
//
void CAknSlider::FormSliderLayout3()
{
TRect rect = Rect();
if ( iEditable )
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_2 );
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_3( 0, 1 ) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_3( 2, 3 ) );
TAknLayoutRect temp, layout;
temp.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_cont_pane( 0 ) );
// slider layout with value, min and max labels
layout.LayoutRect( temp.Rect(),
AknLayoutScalable_Avkon::slider_form_pane( 0 ) );
iMarkerArea = layout.Rect();
//Load new slider layout if exist
if( !(iExt->UsesDefaultGraphics()) )
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g4() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g3() );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g5() );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g7() );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g6() );
iExt->iThumbRect = temp.Rect();
}
else
{
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g1() );
AknIconUtils::SetSize( iExt->iLineIcon, temp.Rect().Size() );
iLineRect = temp.Rect();
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::slider_form_pane_g2() );
iExt->iThumbRect = temp.Rect();
}
}
else
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_2 );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::SettingsItemSliderLayout
// Pure layout function.
// ----------------------------------------------------------------------------
//
void CAknSlider::SettingsItemSliderLayout()
{
TRect rect = Rect();
iEditable = ETrue;
TAknLayoutRect temp, layoutRect;
if ( Layout() == EAknSettingsItemSliderLayout)
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t1_copy1( 0 ) );
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t2_copy1( 0 ) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t3_copy1( 0 ) );
layoutRect.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_set_pane_copy1( 0 ) );
// Indication rect for setting slider pane
iExt->iTouchDownArea = Rect();
iExt->iTouchActiveArea = TouchActiveArea();
}
if ( Layout() == EAknSettingsItemSliderLayoutWithGraphics )
{
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AknLayoutScalable_Avkon::setting_slider_graphic_pane_t1_copy1( 0 ) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AknLayoutScalable_Avkon::setting_slider_graphic_pane_t2_copy1( 0 ) );
AknLayoutUtils::LayoutImage( iImage, rect,
AknLayoutScalable_Avkon::setting_slider_graphic_pane_g1_copy1( 0 ) );
AknIconUtils::SetSize( const_cast<CFbsBitmap*>( iImage->Bitmap() ),
iImage->Size(), EAspectRatioNotPreserved );
layoutRect.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_set_pane_cp_copy1( 0 ) );
// Indication rect for setting slider pane
iExt->iTouchDownArea = Rect();
iExt->iTouchActiveArea = TouchActiveArea();
}
iMarkerArea = layoutRect.Rect();
//new horizonal slider
if( !(iExt->UsesDefaultGraphics()))
{
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g4_copy1(0) );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g3_copy1(0) );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g5_copy1(0) );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g7_copy1(0) );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g6_copy1(0) );
iExt->iThumbRect = temp.Rect();
}
else //default slider
{
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g1_copy1() );
AknIconUtils::SetSize( iExt->iLineIcon, temp.Rect().Size() );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g2_copy1() );
iExt->iThumbRect = temp.Rect();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::VerticalSliderLayout
// Pure layout function.
// ----------------------------------------------------------------------------
//
void CAknSlider::VerticalSliderLayout()
{
TRect rect = Rect();
iEditable = ETrue;
TAknLayoutRect temp, layoutRect;
if( !(iExt->UsesDefaultGraphics()))
{
iMarkerArea = rect;
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::small_volume_slider_vertical_pane_g2() );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::small_volume_slider_vertical_pane_g3() );
iExt->iThumbRect = temp.Rect();
}
else
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t1(1) );
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t2(1) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t3(1) );
iMarkerArea = rect;
//new vertical slider
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_pane_g3(0) );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_pane_g1(0) );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_pane_g2(0) );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_pane_g3(0) );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_pane_g4(0) );
iExt->iThumbRect = temp.Rect();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::HorizontalSliderLayout
// Pure layout function.
// ----------------------------------------------------------------------------
//
void CAknSlider::HorizontalSliderLayout()
{
TRect rect = Rect();
iEditable = ETrue;
TAknLayoutRect temp, layoutRect;
if( !( iExt->UsesDefaultGraphics() ) )
{
iMarkerArea = rect;
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Apps::vtel_slider_pane_g2(0) );
AknIconUtils::SetSize( iExt->iLineIcon, rect.Size() );
iLineRect = Rect();
/*temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Apps::vtel_slider_pane_g4(0) );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Apps::vtel_slider_pane_g3(0) );
iExt->iRightCapRect = temp.Rect();*/
temp.LayoutRect( rect,
AknLayoutScalable_Apps::vtel_slider_pane_g5(0) );
iExt->iThumbRect = temp.Rect();
}
else
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t1(0) );
AknLayoutUtils::LayoutLabel( iMinLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t2(0) );
AknLayoutUtils::LayoutLabel( iMaxLabel, rect,
AknLayoutScalable_Avkon::setting_slider_pane_t3(0) );
layoutRect.LayoutRect( rect,
AknLayoutScalable_Avkon::slider_set_pane(0) );
iMarkerArea = layoutRect.Rect();
//new vertical slider
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g4(0) );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g3(0) );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g5(0) );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g7(0) );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_set_pane_g6(0) );
iExt->iThumbRect = temp.Rect();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::MIDPFormSliderLayout
// Pure layout function. Value, min and max labels are shown.
// ----------------------------------------------------------------------------
//
void CAknSlider::MIDPFormSliderLayout()
{
TRect rect = Rect();
if ( iEditable )
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AknLayoutScalable_Avkon::form2_midp_gauge_slider_pane_t1() );
TAknLayoutRect layout, temp;
layout.LayoutRect( rect,
AknLayoutScalable_Avkon::form2_midp_gauge_slider_cont_pane(0) );
AknLayoutUtils::LayoutLabel( iMinLabel, layout.Rect(),
AknLayoutScalable_Avkon::form2_midp_gauge_slider_pane_t2_cp01(0) );
AknLayoutUtils::LayoutLabel( iMaxLabel, layout.Rect(),
AknLayoutScalable_Avkon::form2_midp_gauge_slider_pane_t3_cp01(1) );
temp.LayoutRect( layout.Rect(),
AknLayoutScalable_Avkon::form2_midp_slider_pane_cp01(0));
iMarkerArea = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::form2_midp_slider_pane_g2(0) );
AknIconUtils::SetSize( iExt->iLineIcon, temp.Rect().Size() );
iLineRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::form2_midp_slider_pane_g1(0) );
iExt->iLeftCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::form2_midp_slider_pane_g3(0) );
iExt->iRightCapRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_form_pane_g7(0) );
iExt->iTickRect = temp.Rect();
temp.LayoutRect( iMarkerArea,
AknLayoutScalable_Avkon::slider_form_pane_g2() );
iExt->iThumbRect = temp.Rect();
}
else
{
AknLayoutUtils::LayoutLabel( iValueLabel, rect,
AKN_LAYOUT_TEXT_Form_slider_field_texts_Line_2 );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::Draw
// Implementation of automatically called control drawing function from
// CCoeControl.
// ----------------------------------------------------------------------------
//
void CAknSlider::Draw( const TRect& /*aRect*/ ) const
{
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal ) )
{
DrawHorizontal( ETrue );
}
else // must be vertical
{
DrawVertical( ETrue );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawHorizontalTickMarks
//
// Draws horizontal tick marks. The slider grows rightwards and tick marks are
// placed above or below the line. If tick mark interval is zero the repeat
// step size is used as the interval.
//
// Slider range is not a pixel space, conversion must be done from
// slider range to actual pixel range. Using one pixel width for the
// tick interval in pixel space is not possible, as rounding errors
// would cumulate. Each tick pixel coordinate must be separately
// determined.
//
// Slider range [r1, r2] e Z, pixel range [p1, p2] e Z. Mapping from
// slider range position r to pixel range position p:
//
// | (r - r1)(p2 - p1) |
// p = p1 + | ----------------- |
// |_ r2 - r1 _|
//
// Flooring indicates truncation caused by integer division.
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawHorizontalTickMarks( CWindowGc& aGc ) const
{
TAknSliderGfx gfx;
FetchGfx( gfx, EElemTickMark, iExt->iTickRect.Size() );
if ( !gfx.iRgb )
{
aGc.SetBrushStyle( CWindowGc::ESolidBrush );
aGc.SetBrushColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
}
const TInt mw = MarkerSize().iWidth; // Marker width
const TInt r1 = SliderData()->iMinimumValue; // Slider range start
const TInt r2 = SliderData()->iMaximumValue; // Slider range end
// Note that r2 - r1 > 0 as slider quarantees that
// SliderData()->iMinimumValue < SliderData()->iMaximumValue.
const TInt p1 = iMarkerArea.iTl.iX + mw / 2; // Pixel range start
const TInt p2 = p1 + iMarkerArea.Width() - mw; // Pixel range end
// Interval between tick marks, if zero then use step spacing.
// StepSize is always >= 1, therefore s cannot be zero which would
// lead to infinite loop below.
const TInt s = ( 0 == iExt->iTickInterval ) ? StepSize():
iExt->iTickInterval;
const TInt tickWidth = iExt->iTickRect.Size().iWidth;
// If tick width is even, handle as if it was uneven. The extra column of
// pixels is aligned to right side of the tick mark middle position.
const TInt off = ( tickWidth / 2 ) -
( ( tickWidth % 2 == 0 ) ? 1: 0 );
TRect rect = iExt->iTickRect;
for ( int r = r1; r <= r2; r += s )
{
// Current pos in the range -> current pos on screen, r2 - r1 > 0
// always (see comment above).
rect.iTl.iX = p1 + ( ( r - r1 ) * ( p2 - p1 ) ) / ( r2 - r1 ) - off;
rect.iBr.iX = rect.iTl.iX + tickWidth;
if ( gfx.iRgb && gfx.iMask )
{
aGc.BitBltMasked( rect.iTl, gfx.iRgb, rect.Size(), gfx.iMask, EFalse );
}
else if ( gfx.iRgb )
{
aGc.BitBlt( rect.iTl, gfx.iRgb, rect.Size() );
}
else
{
aGc.DrawRect( rect );
}
}
aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawVerticalTickMarks
//
// Draws vertical tick marks. The slider grows upwards and tick marks are
// placed to the left or right of the line. If tick mark interval is zero the
// repeat step size is used as the interval. Implementation is similar to
// DrawHorizontalTickMarks, the major difference is that in vertical mode
// slider range and pixel range grow to different directions.
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawVerticalTickMarks( CWindowGc& aGc ) const
{
TAknSliderGfx gfx;
FetchGfx( gfx, EElemTickMark, iExt->iTickRect.Size() );
if ( !gfx.iRgb )
{
aGc.SetBrushStyle( CWindowGc::ESolidBrush );
aGc.SetBrushColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
}
const TInt mh = MarkerSize().iHeight; // Marker height
const TInt r1 = SliderData()->iMinimumValue; // Slider range start
const TInt r2 = SliderData()->iMaximumValue; // Slider range end
// Note that r2 - r1 > 0 as slider quarantees that
// SliderData()->iMinimumValue < SliderData()->iMaximumValue.
const TInt p2 = iMarkerArea.iBr.iY - mh / 2; // Pixel range end
const TInt p1 = p2 - iMarkerArea.Height() + mh; // Pixel range start
// Interval between tick marks, if zero then use step spacing.
// StepSize is always >= 1, therefore s cannot be zero which would
// lead to infinite loop below.
const TInt s = ( 0 == iExt->iTickInterval ) ? StepSize():
iExt->iTickInterval;
const TInt tickHeight = iExt->iTickRect.Size().iHeight;
// If tick width is even, handle as if it was uneven. The extra column of
// pixels is aligned above the tick mark middle position.
const TInt off = ( tickHeight / 2 ) -
( ( tickHeight % 2 == 0 ) ? 1: 0 );
TRect rect = iExt->iTickRect;
for ( int r = r1; r <= r2; r += s )
{
// Current pos in the range -> current pos on screen, r2 - r1 > 0,
// checked above
rect.iBr.iY = p2 - ( ( r - r1 ) * ( p2 - p1 ) ) / ( r2 - r1 ) + off;
rect.iTl.iY = rect.iBr.iY - tickHeight;
if ( gfx.iRgb && gfx.iMask )
{
aGc.BitBltMasked( rect.iTl, gfx.iRgb, rect.Size(), gfx.iMask, EFalse );
}
else if ( gfx.iRgb )
{
aGc.BitBlt( rect.iTl, gfx.iRgb, rect.Size() );
}
else
{
aGc.DrawRect( rect );
}
}
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateDecoratorImageFromResourceL
// ----------------------------------------------------------------------------
//
void CAknSlider::CreateDecoratorImageFromResourceL( TInt aImageResourceId )
{
iImage = new ( ELeave ) CEikImage();
TResourceReader reader;
CEikonEnv::Static()->CreateResourceReaderLC( reader, aImageResourceId );
iImage->ConstructFromResourceL( reader );
CleanupStack::PopAndDestroy(); // reader
}
// ----------------------------------------------------------------------------
// CAknSlider::SetDecimalPlaces
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetDecimalPlaces( TInt aDecimalPlaces )
{
SliderData()->SetDecimalPlaces( aDecimalPlaces );
}
// ----------------------------------------------------------------------------
// CAknSlider::DecimalPlaces
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CAknSlider::DecimalPlaces() const
{
return SliderData()->DecimalPlaces();
}
// ----------------------------------------------------------------------------
// CAknSlider::SetGraphics
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetGraphics( TInt aElement, CFbsBitmap* aBitmap,
CFbsBitmap* aMask )
{
if ( aElement < 0 || aElement > EElemMarkerSelected )//|| !aBitmap )
{
Panic( EAknPanicInvalidValue );
}
iExt->SetGraphics( aElement, aBitmap, aMask );
}
// ----------------------------------------------------------------------------
// CAknSlider::UseDefaultGraphics
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::UseDefaultGraphics( TInt aElement )
{
if ( aElement < 0 || aElement > EElemMarkerSelected )
{
Panic( EAknPanicInvalidValue );
}
iExt->UseDefaultGraphics( aElement );
}
// ----------------------------------------------------------------------------
// CAknSlider::UsesDefaultGraphics
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CAknSlider::UsesDefaultGraphics( TInt aElement ) const
{
if ( aElement < 0 || aElement > EElemMarkerSelected )
{
Panic( EAknPanicInvalidValue );
}
return iExt->UsesDefaultGraphics( aElement );
}
// ----------------------------------------------------------------------------
// CAknSlider::SetPositionIndicators
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetPositionIndicators( TUint32 aFlags )
{
iExt->ClearFlag( CAknSliderExtension::EFlagFillEnabled );
iExt->ClearFlag( CAknSliderExtension::EFlagMarkerEnabled );
if ( EPosFilling & aFlags )
{
iExt->SetFlag( CAknSliderExtension::EFlagFillEnabled );
}
else
{
// If no position indicator is set, always default to visible
// marker
iExt->SetFlag( CAknSliderExtension::EFlagMarkerEnabled );
}
if ( EPosMarker & aFlags )
{
iExt->SetFlag( CAknSliderExtension::EFlagMarkerEnabled );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::PositionIndicators
// ----------------------------------------------------------------------------
//
EXPORT_C TUint32 CAknSlider::PositionIndicators() const
{
TUint32 flags = 0;
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagMarkerEnabled ) )
{
flags |= EPosMarker;
}
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) )
{
flags |= EPosFilling;
}
return flags;
}
// ----------------------------------------------------------------------------
// CAknSlider::Orientation
// ----------------------------------------------------------------------------
//
EXPORT_C TAknOrientation CAknSlider::Orientation() const
{
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal ) )
{
return EAknOrientationHorizontal;
}
return EAknOrientationVertical;
}
// ----------------------------------------------------------------------------
// CAknSlider::SetTicksEnabled
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetTicksEnabled( TBool aStatus )
{
if ( aStatus )
{
iExt->SetFlag( CAknSliderExtension::EFlagTickMarksEnabled );
}
else
{
iExt->ClearFlag( CAknSliderExtension::EFlagTickMarksEnabled );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::TicksEnabled
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CAknSlider::TicksEnabled() const
{
return iExt->IsFlagSet( CAknSliderExtension::EFlagTickMarksEnabled );
}
// ----------------------------------------------------------------------------
// CAknSlider::SetTickInterval
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::SetTickInterval( TUint aInterval )
{
iExt->iTickInterval = aInterval;
}
// ----------------------------------------------------------------------------
// CAknSlider::TickInterval
// ----------------------------------------------------------------------------
//
EXPORT_C TUint CAknSlider::TickInterval() const
{
return iExt->iTickInterval;
}
// ----------------------------------------------------------------------------
// CAknSlider::NumberOfLines
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CAknSlider::NumberOfLines() const
{
TInt noOfLines = 1;
if ( iEditable )
{
switch ( Layout() )
{
case EAknFormSliderLayout1: // drop through
case EAknFormSliderLayout2:
noOfLines = 2;
break;
case EAknFormSliderLayout3:
noOfLines = 3;
break;
default:
break;
}
}
return noOfLines;
}
// ----------------------------------------------------------------------------
// CAknSlider::CreateValueTextInHBufCL
//
// Returns the text that would appear at the top of the slider setting page if
// it were opened Ownership of the text buffer is transferred to the caller.
// ----------------------------------------------------------------------------
//
EXPORT_C HBufC* CAknSlider::CreateValueTextInHBufCL(
TInt aValue, TInt aResourceId )
{
CAknSliderData* sliderResourceData = CAknSliderData::NewLC( aResourceId );
__ASSERT_DEBUG( aValue >= sliderResourceData->iMinimumValue &&
aValue <= sliderResourceData->iMaximumValue,
Panic( EAknPanicOutOfRange ) );
TBuf<KValueLabelTextMaxLength> textBuffer;
CAknSlider::DoSetValueTextL( textBuffer, aValue, *sliderResourceData );
CleanupStack::PopAndDestroy(); // sliderResourceData
HBufC* valueTextBufC = textBuffer.AllocL();
return valueTextBufC;
}
// ----------------------------------------------------------------------------
// CAknSlider::StepSize
// ----------------------------------------------------------------------------
//
TInt CAknSlider::StepSize() const
{
return iData->iStepSize;
}
// ----------------------------------------------------------------------------
// CAknSlider::Layout
// ----------------------------------------------------------------------------
//
TInt CAknSlider::Layout() const
{
return iData->iLayout;
}
// ----------------------------------------------------------------------------
// CAknSlider::MaximumValue
// ----------------------------------------------------------------------------
//
TInt CAknSlider::MaximumValue() const
{
return iData->iMaximumValue;
}
// ----------------------------------------------------------------------------
// CAknSlider::MinimumValue
// ----------------------------------------------------------------------------
//
TInt CAknSlider::MinimumValue() const
{
return iData->iMinimumValue;
}
// ----------------------------------------------------------------------------
// CAknSlider::Range
// ----------------------------------------------------------------------------
//
TInt CAknSlider::Range() const
{
return iData->Range();
}
// ----------------------------------------------------------------------------
// CAknSlider::SliderData
// ----------------------------------------------------------------------------
//
CAknSliderData* CAknSlider::SliderData() const
{
// This method is used to trap all the accesses to the internal data when
// the 2nd stage construction has not taken place
__ASSERT_DEBUG( iData, Panic( EAknPanicObjectNotFullyConstructed ) );
return iData;
}
// ----------------------------------------------------------------------------
// CAknSlider::HandlePointerEventL
//
// Handles slider's pointer events. This function calculates thumb position
// when button down happens. Then it compares position to thumb position and if
// pointerevent was for the thumb it will set dragging on. Otherwise, the thumb
// will be moved to down position.
//
// If value have to be changed with this pointerevent, the new value have to be
// calculated. The calculation is based for drawing, so we have to find "what
// value" would be drawn to clicked position and thus deside what value was
// selected from slider.
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::HandlePointerEventL( const TPointerEvent& aEvent )
{
if ( !AknLayoutUtils::PenEnabled() )
{
return;
}
if ( IsDimmed() )
{
iExt->ClearFlag( CAknSliderExtension::EFlagPointerDown );
iExt->ClearFlag( CAknSliderExtension::EFlagDraggingThumb );
return;
}
TBool thumbMoved = EFalse;
TBool valueChanged = EFalse;
TBool upFromDrag = EFalse;
TRect mrect;
GetMarkerRect( mrect );
TInt reportDragEvent(0);// if this value is 0, it means no need to report
TBool hor = iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal );
//Setting pane slider use extended touch area to hand pointer event
TRect touchDownArea;
TRect touchActiveArea;
if( Layout() == EAknSettingsItemSliderLayout ||
Layout() == EAknSettingsItemSliderLayoutWithGraphics
)
{
touchDownArea = iExt->iTouchDownArea;
touchActiveArea = iExt->iTouchActiveArea;
}
else
{
touchDownArea = iMarkerArea;
touchActiveArea = iMarkerArea;
}
if( iEditable )
{
switch ( aEvent.iType )
{
case TPointerEvent::EButton1Down:
{
if ( touchDownArea.Contains( aEvent.iPosition ) )
{
// repeat until thumb reaches the stylus down position
iExt->iPenInputPos = aEvent.iPosition;
// Click was inside and down slider marker area
iExt->SetFlag( CAknSliderExtension::EFlagPointerDown );
// Start draggint even if the click was not inside thumb rect
if ( mrect.Contains( aEvent.iPosition ) )
{
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->InstantFeedback( this, ETouchFeedbackSlider, aEvent );
}
iExt->SetFlag( CAknSliderExtension::EFlagDraggingThumb );
reportDragEvent = EDragMarkerStart;
}
// Marker icon changes - draw
if ( !iExt->iNoDraw )
{
DrawDeferred();
}
valueChanged = ETrue;
}
}
break;
case TPointerEvent::EButtonRepeat:
{
if ( touchActiveArea.Contains( aEvent.iPosition ) )
{
// repeat until thumb reaches the stylus down position
iExt->iPenInputPos = aEvent.iPosition;
// Click was inside and down slider marker area
iExt->SetFlag( CAknSliderExtension::EFlagPointerDown );
// Start draggint even if the click was not inside thumb rect
if ( mrect.Contains( aEvent.iPosition ) )
{
iExt->SetFlag( CAknSliderExtension::EFlagDraggingThumb );
reportDragEvent = EDragMarkerStart;
}
// Marker icon changes - draw
if ( !iExt->iNoDraw )
{
DrawDeferred();
}
valueChanged = ETrue;
}
if ( mrect.Contains( aEvent.iPosition ) )
{
StopFeedback();
}
}
break;
// Drag can out of touchDownArea to support finger touch out of range,
// when the pointer fall down the thumb,then use touchDragArea
case TPointerEvent::EDrag:
{
if ( ( iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) ||
touchActiveArea.Contains( aEvent.iPosition ) ) &&
iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) )
{
if ( hor && aEvent.iPosition.iX != iExt->iPenInputPos.iX )
{
thumbMoved = ETrue;
}
if ( !hor && aEvent.iPosition.iY != iExt->iPenInputPos.iY )
{
thumbMoved = ETrue;
}
iExt->iPenInputPos = aEvent.iPosition;
valueChanged = ETrue;
}
if ( !iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) &&
!touchActiveArea.Contains( aEvent.iPosition ))
{
StopFeedback();
}
}
break;
case TPointerEvent::EButton1Up:
{
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) &&
iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) )
{
iExt->iPenInputPos = aEvent.iPosition;
valueChanged = ETrue;
upFromDrag = ETrue;
reportDragEvent = EDragMarkerEnd;
}
iExt->ClearFlag( CAknSliderExtension::EFlagPointerDown );
iExt->ClearFlag( CAknSliderExtension::EFlagDraggingThumb );
if ( mrect.Contains( aEvent.iPosition ) )
{
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->InstantFeedback( this,
ETouchFeedbackSlider,
ETouchFeedbackVibra,
aEvent );
}
}
StopFeedback();
// Marker icon changes - draw
if ( !iExt->iNoDraw )
{
DrawDeferred();
}
}
break;
default:
break;
}
}
TBool valueStepChange = iExt->IsFlagSet( CAknSliderExtension::EFlagValueStepChange );
// if pointerevent causes value changing, we have to calculate the
// clicked value.
if ( valueChanged )
{
TInt betweenSteps;
TInt value = Value();
TBool isDragThumb = EFalse;
if( (iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) &&
iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown )) ||
!valueStepChange || upFromDrag )
{
//not value step or drag happened
isDragThumb = ETrue;
value = CalcAlignedValue( iExt->iPenInputPos );
}
else if( !mrect.Contains( aEvent.iPosition ) )
{// value step change begin
TInt step = StepSize();
TInt halfStepRange(0);
TBool repeat = ( ( aEvent.iType == TPointerEvent::EButton1Down ) ||
( aEvent.iType == TPointerEvent::EButtonRepeat ) ) ? ETrue : EFalse;
if(!hor)
{
halfStepRange = (iMarkerArea.Height() - mrect.Height())/( 2 * Range() );
if( aEvent.iPosition.iY < mrect.iTl.iY + mrect.Height()/2 - halfStepRange )
{
TranslateValueL( step, repeat );
value = iValue;
}
else if( aEvent.iPosition.iY > mrect.iTl.iY + mrect.Height()/2 + halfStepRange )
{
TranslateValueL( -step, repeat );
value = iValue;
}
else
{
value = iValue;
}
}
else
{
halfStepRange = (iMarkerArea.Width() - mrect.Width())/( 2 * Range() );
if( aEvent.iPosition.iX < mrect.iTl.iX + mrect.Width()/2 - halfStepRange )
{
TranslateValueL( -step, repeat );
value = iValue;
}
else if( aEvent.iPosition.iX > mrect.iTl.iX + mrect.Width()/2 + halfStepRange )
{
TranslateValueL( step, repeat );
value = iValue;
}
else
{
value = iValue;
}
}
Window().RequestPointerRepeatEvent( KScrollRepeatTimeout, touchActiveArea );
}// value step change over
// calculate how many pixels was clicked between steps
betweenSteps = value % StepSize();
if ( betweenSteps != 0 )
{
value = value - betweenSteps;
// if click was nearer or middle of values, then move it to
// next possible value
if ( betweenSteps > ( StepSize() / 2 ) )
{
value = value + StepSize();
}
}
// Move to Max/Min values if value is not withing range
if ( value > MaximumValue() )
{
value = MaximumValue();
}
else if ( value < MinimumValue() )
{
value = MinimumValue();
}
if( value == MinimumValue() )
{
//The value is minimum value, but the pointer fell on the position which is
//less than minimum + 1 position.
if( hor &&
aEvent.iPosition.iX < iMarkerArea.iTl.iX + iExt->iThumbRect.Width() / 2 +
( iMarkerArea.iTl.iX - iExt->iThumbRect.Width() ) / Range() )
{
iExt->iPenInputPos =
TPoint( iMarkerArea.iTl.iX + iExt->iThumbRect.Width() / 2,
iMarkerArea.iTl.iY );
thumbMoved = EFalse;
}
if( !hor &&
aEvent.iPosition.iY > iMarkerArea.iBr.iY - iExt->iThumbRect.Height() / 2 -
( iMarkerArea.iTl.iY - iExt->iThumbRect.Height() ) / Range() )
{
iExt->iPenInputPos =
TPoint( iMarkerArea.iBr.iX,
iMarkerArea.iTl.iY - iExt->iThumbRect.Height() / 2 );
thumbMoved = EFalse;
}
}
if( value == MaximumValue() )
{
if( hor )
{
iExt->iPenInputPos.iX = iMarkerArea.iTl.iX - iExt->iThumbRect.Width() / 2;
thumbMoved = EFalse;
}
else
{
iExt->iPenInputPos.iY = iMarkerArea.iTl.iY + iExt->iThumbRect.Height() / 2;
thumbMoved = EFalse;
}
}
if ( thumbMoved )
{
StartFeedback( &aEvent, KFeedbackTimeout );
}
if ( iValue != value )
{
SetValueL( value );
if ( &Window() != NULL )
{
ReportEventL( MCoeControlObserver::EEventStateChanged );
if ( !iExt->iNoDraw )
{
DrawDeferred();
}
}
}
else if( isDragThumb ) // fix TSW EAKH-7FAF63
{
// smoothly
DrawDeferred();
}
}
// Report drag event if it is needed
if( iExt->iReportMarkerDragEvent && reportDragEvent )
{
ReportEventL( static_cast<MCoeControlObserver::TCoeEvent>(reportDragEvent) );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::CalcAlignedValue
// ----------------------------------------------------------------------------
//
TInt CAknSlider::CalcAlignedValue( const TPoint& aPoint )
{
TBool hor = iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal );
TInt bitmapRun = 0;
TInt returnValue = MinimumValue();
if ( hor )
{
bitmapRun = iMarkerArea.Width() - iExt->iThumbRect.Width();
returnValue = ( ( Range() * ( aPoint.iX - iMarkerArea.iTl.iX -
iExt->iThumbRect.Width() / 2 ) + bitmapRun / 2 ) / bitmapRun ) + MinimumValue();
}
else
{
bitmapRun = iMarkerArea.Height() - iExt->iThumbRect.Height();
returnValue = ( ( Range() * ( iMarkerArea.iBr.iY - aPoint.iY -
iExt->iThumbRect.Height() / 2 ) + bitmapRun / 2 ) / bitmapRun ) + MinimumValue();
}
return returnValue;
}
// ----------------------------------------------------------------------------
// CAknSlider::ExtensionInterface
// ----------------------------------------------------------------------------
//
EXPORT_C void* CAknSlider::ExtensionInterface( TUid /*aInterface*/ )
{
return NULL;
}
// ----------------------------------------------------------------------------
// CAknSlider::StartTimerL
// ----------------------------------------------------------------------------
//
void CAknSlider::StartTimerL()
{
if ( iExt->iTimer->IsActive() )
{
return; // do not re-start as we have the feedback ongoing
}
iExt->iEffectTimerCount = 0;
TCallBack callback( IndicationDrawCallbackL, this );
iExt->iTimer->Start(
TTimeIntervalMicroSeconds32( KAknSliderFeedbackActionTime ),
KAknSliderFeedbackActionTime, callback );
}
// ----------------------------------------------------------------------------
// CAknSlider::IndicationDrawCallbackL
// ----------------------------------------------------------------------------
//
TInt CAknSlider::IndicationDrawCallbackL( TAny* aThis )
{
CAknSlider* slider = static_cast<CAknSlider*>( aThis );
slider->SmallDirectionIndicationL();
return KErrNone;
}
// ----------------------------------------------------------------------------
// CAknSlider::SmallDirectionIndicationL
// ----------------------------------------------------------------------------
//
void CAknSlider::SmallDirectionIndicationL()
{
Window().Invalidate( iMarkerArea );
ActivateGc();
Window().BeginRedraw( iMarkerArea );
CWindowGc& gc = SystemGc();
gc.SetBrushStyle( CGraphicsContext::ENullBrush );
gc.SetBrushColor( AKN_LAF_COLOR( 0 ) );
gc.SetPenColor( AKN_LAF_COLOR( 0 ) );
if( !Background() )
{
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
MAknsControlContext* cc = NULL;
if ( AknsUtils::AvkonSkinEnabled() )
{
cc = AknsDrawUtils::ControlContext( this );
}
AknsDrawUtils::Background( skin, cc, this, gc, Rect() );
}
else
{
TRect rect = Window().GetDrawRect();
Background()->Draw( gc, *this, rect );
}
TBool drawMarker = EFalse;
if ( iExt->iEffectTimerCount % 2 == 1 )
{
drawMarker = ETrue;
}
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal ) )
{
DrawHorizontal( drawMarker );
}
else // Must be vertical
{
DrawVertical( drawMarker );
}
Window().EndRedraw();
DeactivateGc();
iExt->iEffectTimerCount++;
// Stop timer if done normal-inverted-normal-inverted-normal sequence
if ( iExt->iEffectTimerCount > 3 )
{
iExt->iTimer->Cancel();
}
}
// ----------------------------------------------------------------------------
// CAknSlider::TranslateValueL
//
// Moves the current slider value by aDelta. If the value of aDelta is
// negative, the current value is decremented by |aDelta|. If the value of
// aDelta is positive, the current value is incremented by |aDelta|.
// ----------------------------------------------------------------------------
//
void CAknSlider::TranslateValueL( TInt aDelta, TBool aFeedback )
{
TInt sliderValue = Value();
sliderValue += aDelta;
// calculate how many pixels was clicked between steps
TInt betweenSteps = sliderValue % StepSize();
if ( betweenSteps != 0 )
{
sliderValue = sliderValue - betweenSteps;
// if click was nearer or middle of values, then move it to
// next possible value
if ( betweenSteps > ( StepSize() / 2 ) )
{
sliderValue = sliderValue + StepSize();
}
}
if ( sliderValue > MaximumValue() )
{
sliderValue = MaximumValue();
}
else if ( sliderValue < MinimumValue() )
{
sliderValue = MinimumValue();
}
TInt oldSliderValue = Value();
SetValueL( sliderValue );
ReportEventL( MCoeControlObserver::EEventStateChanged );
// start the timer if we tried to move the slider but the slider did
// not move (in either maximum or minimum already).
#ifdef RD_ANIMATION_EFFECTS
if ( sliderValue == oldSliderValue )
{
StartTimerL();
}
#endif
if ( sliderValue != oldSliderValue )
{
if( aFeedback )
{
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->InstantFeedback( this, ETouchFeedbackSlider );
}
}
Window().Invalidate( Rect() );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::GetMarkerRect
//
// Returns the marker rectangle (the knob). Note that this is not equal to
// iMarkerArea.
// ----------------------------------------------------------------------------
//
void CAknSlider::GetMarkerRect( TRect& aRect ) const
{
aRect = TRect( MarkerPos(), MarkerSize());
}
// ----------------------------------------------------------------------------
// CAknSlider::MarkerSize
//
// Returns the marker size (the knob). Note that this is not equal to
// iMarkerArea.Size().
// ----------------------------------------------------------------------------
//
TSize CAknSlider::MarkerSize() const
{
return iExt->iThumbRect.Size();
}
// ----------------------------------------------------------------------------
// CAknSlider::MarkerPos
//
// Returns the marker position (knob). Note that this is not equal to
// iMarkerArea.iTl.
// ----------------------------------------------------------------------------
//
TPoint CAknSlider::MarkerPos() const
{
TPoint p;
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal ) )
{
TSize markerSize( MarkerSize() );
TInt pixelRange = iMarkerArea.Width() - markerSize.iWidth;
TInt pos = ( pixelRange * ( iValue - MinimumValue() ) / Range() );
if ( AknLayoutUtils::PenEnabled() &&
iMarkerArea.Contains( iExt->iPenInputPos ) &&
&Window() != NULL )
{
if( !iExt->IsFlagSet( CAknSliderExtension::EFlagValueStepChange ) ||
( iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) &&
iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) ) )
{
p.iX = iExt->iPenInputPos.iX - ( markerSize.iWidth ) / 2;
}
else
{
p.iX = iMarkerArea.iTl.iX + pos;
}
}
else
{
p.iX = iMarkerArea.iTl.iX + pos;
}
p.iY = iMarkerArea.iTl.iY;
}
else
{
TSize markerSize( MarkerSize() );
TInt pixelRange = iMarkerArea.Height() - markerSize.iHeight;
TInt pos = ( pixelRange * ( iValue - MinimumValue() ) / Range() );
p.iX = iMarkerArea.iTl.iX;
if ( AknLayoutUtils::PenEnabled() &&
iMarkerArea.Contains( iExt->iPenInputPos ) &&
&Window() != NULL )
{
if( !iExt->IsFlagSet( CAknSliderExtension::EFlagValueStepChange ) ||
( iExt->IsFlagSet( CAknSliderExtension::EFlagDraggingThumb ) &&
iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) ) )
{
p.iY = iExt->iPenInputPos.iY - ( markerSize.iHeight ) / 2;
}
else
{
p.iY = iMarkerArea.iBr.iY - pos - markerSize.iHeight;
}
}
else
{
p.iY = iMarkerArea.iBr.iY - pos - markerSize.iHeight;
}
}
return p;
}
// ----------------------------------------------------------------------------
// CondBlit
//
// Helper C-function for conditional blitting, static to make the function
// visible to this compilation unit only.
// ----------------------------------------------------------------------------
//
inline static void CondBlit( CWindowGc& aGc, const TPoint& aPoint,
const CFbsBitmap* aBitmap, const TSize& aSourceSize,
const CFbsBitmap* aMask, TBool aInvertMask = ETrue )
{
const TPoint origin( 0, 0 );
aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
aGc.SetPenStyle( CGraphicsContext::ENullPen );
aGc.SetBrushColor( AKN_LAF_COLOR( 0 ) );
aGc.SetPenColor( AKN_LAF_COLOR( 0 ) );
if ( aBitmap && aMask )
{
aGc.BitBltMasked( aPoint, aBitmap,
TRect( origin, aSourceSize ),
aMask, aInvertMask );
}
else if ( aBitmap )
{
aGc.BitBlt( aPoint, aBitmap, TRect( origin, aSourceSize) );
}
else
{
// If no bitmap resource, it doesn't need to render default color any more
/*aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
aGc.SetBrushColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
aGc.SetPenStyle( CGraphicsContext::ESolidPen );
aGc.SetPenColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
aGc.DrawRect( TRect( aPoint, aSourceSize ) );*/
}
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawHorizontal
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawHorizontal( TBool aDrawMarker ) const
{
CWindowGc& gc = SystemGc();
gc.SetBrushStyle( CGraphicsContext::ENullBrush );
gc.SetBrushColor( AKN_LAF_COLOR( 0 ) );
gc.SetPenColor( AKN_LAF_COLOR( 0 ) );
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
MAknsControlContext* cc = NULL;
if ( AknsUtils::AvkonSkinEnabled() )
{
cc = AknsDrawUtils::ControlContext( this );
}
if ( !FindBackground() )
{
AknsDrawUtils::Background( skin, cc, this, gc, Rect() );
}
// Don't draw slider in form view mode
if ( !( Layout() == EAknSettingsItemSliderLayout ||
Layout() == EAknSettingsItemSliderLayoutWithGraphics ||
Layout() == EAknSliderLayoutVertical ||
Layout() == EAknSliderLayoutHorizontal ||
iEditable ) )
{
return;
}
DrawHorizontalLine( gc ); // Draw line and end caps
// Draw the tick marks, if any
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagTickMarksEnabled ) )
{
DrawHorizontalTickMarks( gc );
}
// Draw the marker
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagMarkerEnabled ) &&
aDrawMarker )
{
TRect rect;
TAknSliderGfx gfx;
GetMarkerRect( rect );
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) )
{
FetchGfx( gfx, EElemMarkerSelected, rect.Size() );
}
else
{
FetchGfx( gfx, EElemMarker, rect.Size() );
}
CondBlit( gc, rect.iTl, gfx.iRgb, rect.Size(), gfx.iMask, ETrue );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawVertical
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawVertical( TBool aDrawMarker ) const
{
CWindowGc& gc = SystemGc();
gc.SetBrushStyle( CGraphicsContext::ENullBrush );
gc.SetBrushColor( AKN_LAF_COLOR( 0 ) );
gc.SetPenColor( AKN_LAF_COLOR( 0 ) );
// Don't draw slider in form view mode
if ( !( Layout() == EAknSettingsItemSliderLayout ||
Layout() == EAknSettingsItemSliderLayoutWithGraphics ||
Layout() == EAknSliderLayoutVertical||
Layout() == EAknSliderLayoutHorizontal ||
iEditable ) )
{
return;
}
DrawVerticalLine( gc ); // Draw line and end caps
// Draw the tick marks, if any
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagTickMarksEnabled ) )
{
DrawVerticalTickMarks( gc );
}
// Draw the marker
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagMarkerEnabled ) &&
aDrawMarker )
{
TRect rect;
TAknSliderGfx gfx;
GetMarkerRect( rect );
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagPointerDown ) )
{
FetchGfx( gfx, EElemMarkerSelected, rect.Size() );
}
else
{
FetchGfx( gfx, EElemMarker, rect.Size() );
}
CondBlit( gc, rect.iTl, gfx.iRgb, rect.Size(), gfx.iMask, ETrue );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawHorizontalLine
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawHorizontalLine( CWindowGc& aGc ) const
{
TPoint pos;
TSize size;
TAknSliderGfx gfx;
TRect mrect;
GetMarkerRect( mrect );
TInt markerW2 = mrect.Width() / 2;
// End caps and line use the same height
size = iExt->iLeftCapRect.Size();
// Draw the left cap, if any
if ( iExt->iLeftCapRect.Size().iWidth > 0 )
{
pos = iExt->iLeftCapRect.iTl;
FetchGfx( gfx, EElemEmptyLeftCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
// Fill the left cap if needed
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) &&
iValue != MinimumValue())
{
FetchGfx( gfx, EElemFilledLeftCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
}
}
// Draw the right cap, if any
if ( iExt->iRightCapRect.Size().iWidth > 0 )
{
pos = iExt->iRightCapRect.iTl;
FetchGfx( gfx, EElemEmptyRightCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
// Fill the right cap if needed
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) &&
iValue >= MaximumValue() )
{
FetchGfx( gfx, EElemFilledRightCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
}
}
// Draw the line
FetchGfx( gfx, EElemEmptyLine, iLineRect.Size() );
CondBlit( aGc, iLineRect.iTl, gfx.iRgb, iLineRect.Size(), gfx.iMask );
// Draw the line filling, if any
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) )
{
if( Layout() == EAknSliderLayoutHorizontal )
{
//pos.SetXY( iLineRect.iTl.iX + mrect.Width(), mrect.iTl.iY );
pos.SetXY( iLineRect.iTl.iX, mrect.iTl.iY );
size = iLineRect.Size();
FetchGfx( gfx, EElemFilledLine, size );
//size.iWidth = iLineRect.iBr.iX - ( mrect.iTl.iX + mrect.Width() );
size.iWidth = mrect.iTl.iX - iLineRect.iTl.iX;
if ( MaximumValue() == iValue )
{
pos = iLineRect.iTl;
size.iWidth = iLineRect.Width();
}
if ( MinimumValue() == iValue )
{
//pos.SetXY( iLineRect.iTl.iX, mrect.iTl.iY + markerH2/*iLineRect.iBr.iY*/ );
//size.iHeight = size.iHeight - markerH2;
}
CondBlit( aGc, iLineRect.iTl, gfx.iRgb, size, gfx.iMask );
}
else
{
size.iWidth = mrect.iTl.iX + markerW2 - iLineRect.iTl.iX ;
FetchGfx( gfx, EElemFilledLine, size );
if ( MaximumValue() == iValue )
{
size.iWidth = iLineRect.Width();
}
CondBlit( aGc, iLineRect.iTl, gfx.iRgb, size, gfx.iMask );
}
}
}
// ----------------------------------------------------------------------------
// RectBlit
//
// Helper C-function for conditional blitting, static to make the function
// visible to this compilation unit only.
// ----------------------------------------------------------------------------
//
inline static void RectBlit( CWindowGc& aGc, const TPoint& aTl,
const TSize& aSize, const TInt aPosY,
const CFbsBitmap* aBitmap, const CFbsBitmap* aMask )
{
aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
aGc.SetPenStyle( CGraphicsContext::ENullPen );
aGc.SetBrushColor( AKN_LAF_COLOR( 0 ) );
aGc.SetPenColor( AKN_LAF_COLOR( 0 ) );
if ( aBitmap && aMask )
{
aGc.BitBltMasked( aTl,
aBitmap,
TRect( TPoint( 0, aPosY ),
TSize( aSize.iWidth, aSize.iHeight - aPosY ) ),
aMask,
ETrue );
}
else if ( aBitmap )
{
aGc.BitBlt( aTl,
aBitmap,
TRect( TPoint(0, aPosY),
TSize( aSize.iWidth, aSize.iHeight - aPosY ) ) );
}
else
{
// If no bitmap resource, it doesn't need to render default color any more
/*aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
aGc.SetBrushColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
aGc.SetPenStyle( CGraphicsContext::ESolidPen );
aGc.SetPenColor( AKN_LAF_COLOR( KAknSliderDefaultDrawColor ) );
aGc.DrawRect( TRect( aTl, TSize( aSize.iWidth, aSize.iHeight - aPosY ) ) );*/
}
}
// ----------------------------------------------------------------------------
// CAknSlider::DrawVerticalLine
// ----------------------------------------------------------------------------
//
void CAknSlider::DrawVerticalLine( CWindowGc& aGc ) const
{
TPoint pos;
TSize size;
TAknSliderGfx gfx;
TRect mrect;
GetMarkerRect( mrect );
TInt markerH2 = mrect.Height() / 2;
TInt fromTop(0);
// End caps and line use the same width
size = iExt->iLeftCapRect.Size();
// Draw the bottom cap, if any
if ( iExt->iLeftCapRect.Size().iWidth > 0 )
{
pos = iExt->iLeftCapRect.iTl;
FetchGfx( gfx, EElemEmptyLeftCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
// Fill the bottom cap if needed
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) )
{
//bottom cap filled when all the line filled
FetchGfx( gfx, EElemFilledLeftCap, size );
RectBlit( aGc, pos, size, fromTop,
gfx.iRgb, gfx.iMask );
}
}
// Draw the top cap, if any
if ( iExt->iRightCapRect.Size().iWidth > 0 )
{
pos = pos = iExt->iRightCapRect.iTl;
FetchGfx( gfx, EElemEmptyRightCap, size );
CondBlit( aGc, pos, gfx.iRgb, size, gfx.iMask );
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) &&
iValue >= MaximumValue() )
{
FetchGfx( gfx, EElemFilledRightCap, size );
RectBlit( aGc, pos, size, fromTop, gfx.iRgb, gfx.iMask );
}
}
// Draw the line
FetchGfx( gfx, EElemEmptyLine, iLineRect.Size() );
CondBlit( aGc, iLineRect.iTl, gfx.iRgb, iLineRect.Size(), gfx.iMask );
// Draw the line filling, if any
if ( iExt->IsFlagSet( CAknSliderExtension::EFlagFillEnabled ) )
{
pos.SetXY( iLineRect.iTl.iX, mrect.iTl.iY + mrect.Height() );
size = iLineRect.Size();
FetchGfx( gfx, EElemFilledLine, size );
size.iHeight = iLineRect.iBr.iY - ( mrect.iTl.iY + mrect.Height() );
if ( MaximumValue() == iValue )
{
pos = iLineRect.iTl;
size.iHeight = iLineRect.Height();
}
if ( MinimumValue() == iValue )
{
//pos.SetXY( iLineRect.iTl.iX, mrect.iTl.iY + markerH2/*iLineRect.iBr.iY*/ );
//size.iHeight = size.iHeight - markerH2;
}
RectBlit( aGc, pos, iLineRect.Size(),
iLineRect.Height() - size.iHeight,
gfx.iRgb, gfx.iMask );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::FetchGfx
// ----------------------------------------------------------------------------
//
void CAknSlider::FetchGfx(
TAknSliderGfx& aGfx, TInt aElement, const TSize& aSize ) const
{
if ( aElement < 0 || aElement > EElemMarkerSelected )
{
Panic( EAknPanicInvalidValue );
}
TScaleMode mode = EAspectRatioNotPreserved; // default ratio
// Step 1: Check if custom graphics have been defined for this element.
if ( !iExt->UsesDefaultGraphics( aElement ) ||
Layout() == EAknSliderLayoutVertical ||
Layout() == EAknSliderLayoutHorizontal )
{
iExt->GetGfx( aGfx, aElement );
if ( ( aElement == EElemEmptyLine ) || ( aElement == EElemFilledLine ) )
{
mode = EAspectRatioNotPreserved;
}
if ( aGfx.iRgb )
{
AknIconUtils::SetSize( aGfx.iRgb, aSize, mode );
}
if ( aGfx.iMask )
{
AknIconUtils::SetSize( aGfx.iMask, aSize, mode );
}
return;
}
else
{
aGfx.iRgb = NULL;
aGfx.iMask = NULL;
}
// Step 2: No custom graphics, try Avkon icons.
if( Layout() != EAknSliderLayoutVertical && Layout() != EAknSliderLayoutHorizontal )//vertical is always customized
{
if ( EElemEmptyLine == aElement )
{
aGfx.iRgb = iExt->iLineIcon;
aGfx.iMask = iExt->iLineIconMask;
}
else if ( EElemMarker == aElement ||
EElemMarkerSelected == aElement )
{
aGfx.iRgb = iMarkerBmp;
aGfx.iMask = iMarkerMaskBmp;
}
}
//resize the graphic
if ( aGfx.iRgb )
{
AknIconUtils::SetSize( aGfx.iRgb, aSize, mode );
}
if ( aGfx.iMask )
{
AknIconUtils::SetSize( aGfx.iMask, aSize, mode );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::EnableDrag
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::EnableDrag()
{
EnableDragEvents();
}
// ----------------------------------------------------------------------------
// CAknSlider::SetLabelColor
// ----------------------------------------------------------------------------
//
void CAknSlider::SetLabelColor()
{
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
TRgb color;
TInt error;
if ( Layout() != EAknSettingsItemSliderLayout &&
Layout() != EAknSettingsItemSliderLayoutWithGraphics &&
Layout() != EAknSliderLayoutVertical &&
Layout() != EAknSliderLayoutHorizontal )
{
error = AknsUtils::GetCachedColor( skin, color,
KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG8 );
}
else
{
error = AknsUtils::GetCachedColor( skin, color,
KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG7 );
}
if ( !error )
{
// ignore error
TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL(
*iMinLabel, EColorLabelText, color ) );
TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL(
*iMaxLabel, EColorLabelText, color ) );
TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL(
*iValueLabel, EColorLabelText, color ) );
}
AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnLineColors,
EAknsCIQsnLineColorsCG8 );
iColor = color;
}
// ----------------------------------------------------------------------------
// CAknSlider::ReportMarkerDragEvent
// ----------------------------------------------------------------------------
//
void CAknSlider::ReportMarkerDragEvent( TBool aEnable )
{
iExt->iReportMarkerDragEvent = aEnable;
}
void CAknSlider::SuppressDrawing( TBool aSuppress )
{
iExt->iNoDraw = aSuppress;
}
// ----------------------------------------------------------------------------
// CAknSlider::FocusChanged
// ----------------------------------------------------------------------------
//
EXPORT_C void CAknSlider::FocusChanged(TDrawNow /*aDrawNow*/)
{
if ( !IsFocused() )
{
iExt->ClearFlag( CAknSliderExtension::EFlagPointerDown );
iExt->ClearFlag( CAknSliderExtension::EFlagDraggingThumb );
// Marker icon changes - draw
if ( !iExt->iNoDraw )
{
DrawDeferred();
}
}
}
// ----------------------------------------------------------------------------
// CAknSlider::StartFeedback
// ----------------------------------------------------------------------------
//
void CAknSlider::StartFeedback( const TPointerEvent* aPointerEvent, TTimeIntervalMicroSeconds32 aTimeout )
{
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
TInt intensity = KStableFeedbackIntesity;
if ( SliderData()->iFeedbackStyle == EAknSliderFbDynamic )
{
intensity = FeedbackIntensity();
}
feedback->StartFeedback( this, ETouchContinuousSlider, aPointerEvent, intensity, aTimeout );
iExt->SetFlag( CAknSliderExtension::EFlagPlayingContinuousFb );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::StopFeedback
// ----------------------------------------------------------------------------
//
void CAknSlider::StopFeedback()
{
iExt->ClearFlag( CAknSliderExtension::EFlagPlayingContinuousFb );
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->StopFeedback( this );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::ModifyFeedback
// ----------------------------------------------------------------------------
//
void CAknSlider::ModifyFeedback()
{
TInt intensity = FeedbackIntensity();
MTouchFeedback* feedback = MTouchFeedback::Instance();
if ( feedback )
{
feedback->ModifyFeedback( this, intensity );
}
}
// ----------------------------------------------------------------------------
// CAknSlider::FeedbackIntensity
// ----------------------------------------------------------------------------
//
TInt CAknSlider::FeedbackIntensity()
{
TRect mrect;
GetMarkerRect( mrect );
TBool hor = iExt->IsFlagSet( CAknSliderExtension::EFlagHorizontal );
if ( hor )
{
TInt position = mrect.iTl.iX - iMarkerArea.iTl.iX;
return TReal( position )/TReal( iMarkerArea.Width()-mrect.Width() )*100;
}
else
{
TInt position = iMarkerArea.iBr.iY - mrect.iBr.iY;
return TReal( position )/TReal( iMarkerArea.Height()-mrect.Height() )*100;
}
}
// ---------------------------------------------------------------------------
// Provides the touch active area for setting page slider.
// ---------------------------------------------------------------------------
//
TRect CAknSlider::TouchActiveArea() const
{
TRect touchActiveArea;
TPoint winPosition( Window().AbsPosition() );
TRect appRect;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,
appRect );
TAknLayoutRect mainpaneRect;
mainpaneRect.LayoutRect( appRect, AknLayoutScalable_Apps::main_pane(3) );
touchActiveArea = mainpaneRect.Rect();
// Convert main pane rect location to slider window coordinates
touchActiveArea.Move(
touchActiveArea.iTl.iX - winPosition.iX,
touchActiveArea.iTl.iY - winPosition.iY );
return touchActiveArea;
}
// End of File