--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mulwidgets/mulsliderwidget/src/mulhorizontalslider.cpp Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,1207 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: The implementation for presentation elements.
+*
+*/
+
+#include <avkon.hrh>
+#include <avkon.mbg>
+//Toolkit Includes
+// Alfred Client includes
+#include <alf/alfenv.h>
+#include <alf/alfroster.h>
+#include <alf/alfdisplay.h>
+#include <alf/alfbitmapprovider.h>
+#include <alf/alftexture.h>
+#include <alf/alfbrusharray.h>
+#include <alf/alftextvisual.h>
+#include <alf/alfevent.h>
+
+//Widget Model Includes
+#include <alf/alfwidgetevents.h>
+#include <alf/alfwidgetenvextension.h>
+#include <alf/ialfmodel.h>
+
+//Avkon Includes
+#include <AknUtils.h>
+#include <AknsConstants.h>
+#include <utf.h>
+#include <math.h>
+
+//slider widget includes
+#include <mul/mulevent.h>
+#include "mulsliderhorizontal.h"
+#include "mulsliderwidget.h"
+#include "mulslidercontrol.h"
+#include "mulslidermodel.h"
+#include "mulsliderdefinitions.h"
+
+#include "mulsliderutils.h"
+
+//Timer function includes
+#include "mulsliderlongtaptimer.h"
+
+
+namespace Alf
+ {
+
+// Structure to store data for the slider element class
+
+ struct MulHorizontalSliderDataImpl
+ {
+
+ bool mOperation;// Drag state
+ float mTickInPixels;// Tick size in Pixel
+ bool mIsLongTapObserverSet;// Is LongTap Event observer set
+ CAlfVisual * mVisual;// Stores thje current visual hit
+ TPoint mDragPoint;// Point at which drag started
+ TPoint mLongTapPos;// Point at which button down happened
+ bool mLongTapStarted;// Long tap timer started (true)
+ int mDragStartStep;// Tick positon of Drag Start
+ int mCurrTick;// Stores current tick
+ int mTrackStartPoint;// Slider Track Start Point in pixel
+ int mTick;// Stores Tick Size
+ bool mLayoutMirrored;//
+ int mdirection;// 0 - nomovement,1 left movement 2 right
+ int mImageTextureId; // to differtiate between textures
+ int mTrackTopTextureId;// to store the auto generated texture id's
+ int mTrackBottomTextureId;
+ int mTrackMiddleTextureId;
+ int mMarkerTextureId;
+ // Visualization Layouts
+ CAlfLayout* mMainLayout;
+ CAlfLayout* mBaseSliderLayout;
+ CAlfLayout* mSliderCentre;
+ CAlfImageVisual* mTrackLeftImage;
+ CAlfImageVisual* mTrackMiddleImage;
+ CAlfImageVisual* mTrackRightImage;
+ CAlfLayout* mSliderCentreGhost;
+ CAlfImageVisual* mSliderHandle;
+ CAlfLayout* mSliderHandleGhost;
+ CAlfImageVisual* mSliderProgressDownload;
+ CAlfImageVisual* mSliderProgressCentre;
+ CAlfTexture* mTexture;
+
+ MulHorizontalSliderDataImpl()
+ {
+ mOperation = 0;
+ mTickInPixels = 0;
+ mIsLongTapObserverSet = 0;
+ mDragPoint.SetXY(0,0) ;
+ mLongTapPos.SetXY(0,0);
+ mLongTapStarted = 0;
+ mDragStartStep = 0;
+ mCurrTick = 0;
+ mTrackStartPoint = 0;
+ mImageTextureId = 0;
+ mTrackTopTextureId = 0 ;
+ mTrackBottomTextureId = 0;
+ mTrackMiddleTextureId = 0;
+ mMarkerTextureId = 0;
+ mVisual = NULL;
+ mMainLayout = NULL;
+ mBaseSliderLayout = NULL;
+ mSliderCentre = NULL;
+ mSliderHandle = NULL;
+ mSliderProgressCentre = NULL;
+ mBaseSliderLayout = NULL;
+ mSliderCentreGhost = NULL;
+ mSliderHandleGhost = NULL;
+ mLayoutMirrored = false;
+ mdirection = 0;
+ }
+
+ };
+
+ // Bitmaps for slider
+_LIT(KAvkonBitmapFile,"\\resource\\apps\\avkon2.mbm");
+//_LIT(KImageViewerBitmapFile,"\\resource\\apps\\ImageViewer.mif");
+// Bitmap Texture ID
+const TInt KAlfTrackTopTextureId = 1;
+const TInt KAlfTrackBottomTextureId = 2;
+const TInt KAlfTrackMiddleTextureId = 3;
+const TInt KAlfMarkerTextureId = 4;
+//const TInt KAlfMarkerSelectedTextureId = 5;
+
+// ---------------------------------------------------------------------------
+// C++ default constructor.
+// ---------------------------------------------------------------------------
+//
+MulSliderHorizontal::MulSliderHorizontal(
+ CAlfWidgetControl& aControl,
+ const char* aName,
+ AlfCustomInitDataBase* /*aCustomData*/)
+ : mData(NULL)
+ {
+ // Base class (AlfElement) construct
+ construct(aControl, aName);
+ mData = new (EMM) MulHorizontalSliderDataImpl;
+ mPosData.reset(new(EMM)MulSliderPos);
+ // Timer for generating tap and hold repeat events
+ mLongTapTimer.reset(new (EMM) MulSliderLongTapTimer(this));
+ mDragVisual = NULL;
+ mSliderModel = NULL;
+ mSliderWidget = NULL;
+ // Store the widget and model pointer
+ initializeSliderData();
+ }
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+MulSliderHorizontal::~MulSliderHorizontal()
+ {
+ if(mData)
+ {
+
+ (&control().Env())->TextureManager().UnloadTexture(mData->mTrackTopTextureId);
+ (&control().Env())->TextureManager().UnloadTexture(mData->mTrackBottomTextureId);
+ (&control().Env())->TextureManager().UnloadTexture(mData->mTrackMiddleTextureId);
+ // (&control().Env())->TextureManager().UnloadTexture(KAlfMarkerSelectedTextureId);
+ (&control().Env())->TextureManager().UnloadTexture(mData->mMarkerTextureId);
+ // Visualization Data
+ delete mData;
+ }
+ else
+ {
+
+ }
+
+ }//End of Destructor
+
+// ---------------------------------------------------------------------------
+// From class MAlfInterfaceBase.
+// Getter for interfaces provided by the slider widget.
+// ---------------------------------------------------------------------------
+//
+IAlfInterfaceBase* MulSliderHorizontal::makeInterface(
+ const IfId& aType)
+ {
+ UString param (aType.mImplementationId);
+ if (param == IAlfWidgetEventHandler::type().mImplementationId)
+ {
+ return static_cast<IAlfWidgetEventHandler*>(this);
+ }
+
+ else if (param ==
+ IMulSliderBaseElementInternal::type().mImplementationId)
+ {
+ return static_cast<IMulSliderBaseElementInternal*>(this);
+ }
+ else
+ {
+ return AlfElement ::makeInterface(aType);
+ }
+
+ }
+
+
+//--------------------------------------------------------------------------
+// APIs from the IMulSliderBaseElement
+//--------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Gets called when the parent layout is relayouted.
+// resets all the anchor points and updates the visualization
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::baseLayoutSizeChanged()
+ {
+ mData->mMainLayout->ClearFlag(EAlfVisualFlagLayoutUpdateNotification);
+ if(mData->mMainLayout)
+ {
+ // This is a hack to resolve screen refresh issue
+ control().Env().RefreshCallBack(&(control().Env()));
+ // Layout the visualization with correct LCT values
+ layoutVisuals(mSliderModel->GetTemplate());
+ // Convert all the user defined data to pixels
+ ConvertDataToPixels();
+ // Set the thumb position to the current tick
+ SetThumbPosition();
+ if(!mSliderModel->IsLandscape())
+ {
+ if(mSliderWidget->GetOpacity())
+ {
+ TAlfTimedValue opacity(1,0);
+ mData->mMainLayout->SetOpacity(opacity);
+ }
+ }
+ else
+ {
+ TAlfTimedValue opacity(0,0);
+ mData->mMainLayout->SetOpacity(opacity);
+ }
+ }
+
+ mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);
+ }
+
+// ---------------------------------------------------------------------------
+// From class IAlfWidgetEventHandler.
+// ---------------------------------------------------------------------------
+//
+
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::setActiveStates(
+ unsigned int /*aStates*/)
+ {
+ //do nothing
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// initializes Model and Widget Pointer
+// ---------------------------------------------------------------------------
+//
+
+void MulSliderHorizontal::initializeSliderData()
+ {
+ // initialize the Slider Widget Pointer;
+ IAlfWidgetFactory& widgetFactory =
+ AlfWidgetEnvExtension::widgetFactory(control().Env());
+ mSliderWidget = static_cast<MulSliderWidget*>(widgetFactory.findWidget(
+ control().widget()->widgetName()));
+
+ // initialize the Slider Model Pointer;
+ mSliderModel = static_cast<MulSliderModel*>(mSliderWidget->model());
+ }
+
+// ---------------------------------------------------------------------------
+// layoutVisuals
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::layoutVisuals(sliderTemplate /*aTemplateId*/)
+ {
+ // TAknLayoutRect to store the Lct rect
+ TAknLayoutRect layoutRect;
+ CAlfControl* ctrl = (CAlfControl*)&control();
+
+ //get the lct rect for mBaseSliderLayout and set it
+ //aacf_slider_pane(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderPane,
+ mData->mMainLayout,
+ KVariety0);
+ mData->mBaseSliderLayout->SetRect(
+ TRect( TPoint( 0,0 ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+
+ mData->mSliderCentreGhost->SetRect(
+ TRect( TPoint( 0,0 ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+
+ //get the lct rect for mSliderCentre and set it
+ //aaslider_bg_pane(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderCenter,
+ mData->mBaseSliderLayout,
+ KVariety0);
+
+
+ mData->mSliderCentre->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ layoutRect.Rect().iTl.iY ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight))) ;
+
+
+
+ //TAknLayoutRect handleGostRect = layoutRect;
+ //get the lct rect for mSliderHandle and set it
+ //aacf_slider_pane_g1(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderHandle,mData->mBaseSliderLayout,KVariety1);
+
+ // This is a correction since the handle LCT data is not correct
+ /* mData->mSliderHandle->SetRect(
+ TRect( TPoint(handleGostRect.Rect().iTl.iX +
+ (handleGostRect.Rect().Size().iWidth -
+ layoutRect.Rect().Size().iWidth)/2 ,
+ handleGostRect.Rect().iTl.iY +
+ (handleGostRect.Rect().Size().iHeight -
+ layoutRect.Rect().Size().iHeight)/2 ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ; */
+ mData->mSliderHandle->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ layoutRect.Rect().iTl.iY ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+ mData->mSliderHandleGhost->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ mData->mBaseSliderLayout->Pos().iX.ValueNow() ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ mData->mBaseSliderLayout->Size().iY.ValueNow() ))) ;
+ //get the lct rect for mTrackLeftImage and set it
+ //aaslider_bg_pane_g1(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderLeft,mData->mSliderCentre,0);
+
+ mData->mTrackLeftImage->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ layoutRect.Rect().iTl.iY ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+
+ //get the lct rect for mTrackMiddleImage and set it
+ //aaslider_bg_pane_g2_copy1(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderCentre,mData->mSliderCentre,0);
+
+ mData->mTrackMiddleImage->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ layoutRect.Rect().iTl.iY ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+
+ //get the lct rect for mTrackRightImage and set it
+ //aaslider_bg_pane_g2(0)
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderRight,mData->mSliderCentre,0);
+
+ mData->mTrackRightImage->SetRect(
+ TRect( TPoint(layoutRect.Rect().iTl.iX,
+ layoutRect.Rect().iTl.iY ),
+ TSize( layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight ))) ;
+
+
+ if(mData->mTrackLeftImage &&
+ mData->mTrackMiddleImage &&
+ mData->mTrackRightImage)
+ {
+ setTrackImage();
+ }
+
+ if(mData->mSliderHandle)
+ {
+ mData->mImageTextureId = KAlfMarkerTextureId;
+ mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(
+ KAlfAutoGeneratedTextureId/*KAlfMarkerTextureId*/,
+ (MAlfBitmapProvider *)this,
+ (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));
+
+ TAlfImage markerImage(*mData->mTexture );
+ mData->mSliderHandle->SetImage(markerImage);
+
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// Used for setting images for the track
+// ---------------------------------------------------------------------------
+//
+
+void MulSliderHorizontal::setTrackImage()
+ {
+ TInt flags = EAlfTextureFlagSkinContent;
+ flags |= EAlfTextureFlagAutoSize;
+ CAlfControl* ctrl = (CAlfControl*)&control();
+ //create texture for leftimage
+ mData->mImageTextureId = KAlfTrackTopTextureId;
+ mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(
+ KAlfAutoGeneratedTextureId/*KAlfTrackTopTextureId*/,
+ (MAlfBitmapProvider *)this,
+ (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|
+ EAlfTextureFlagSkinContent)));
+
+ TAlfImage trackLeftImage(*mData->mTexture );
+
+ //create texture for middleimage
+ mData->mImageTextureId = KAlfTrackMiddleTextureId;
+ mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(
+ KAlfAutoGeneratedTextureId/*KAlfTrackMiddleTextureId*/,
+ (MAlfBitmapProvider *)this,
+ (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|
+ EAlfTextureFlagSkinContent)));
+ TAlfImage trackMiddleImage(*mData->mTexture );
+ //create texture for right image
+ mData->mImageTextureId = KAlfTrackBottomTextureId;
+ mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(
+ KAlfAutoGeneratedTextureId/*KAlfTrackBottomTextureId*/,
+ (MAlfBitmapProvider *)this,
+ (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|
+ EAlfTextureFlagSkinContent)));
+
+ TAlfImage trackRightImage(*mData->mTexture );
+ // Set Image on visuals
+ if(AknLayoutUtils::LayoutMirrored())
+ {
+ mData->mTrackLeftImage->SetImage(trackRightImage);
+ mData->mTrackRightImage->SetImage(trackLeftImage);
+ }
+ else
+ {
+ mData->mTrackLeftImage->SetImage(trackLeftImage);
+ mData->mTrackRightImage->SetImage(trackRightImage);
+ }
+
+ mData->mTrackMiddleImage->SetImage(trackMiddleImage);
+
+ }//End of setImage
+
+// ---------------------------------------------------------------------------
+// ProvideBitmapL()
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::ProvideBitmapL (TInt aId,
+ CFbsBitmap *& aBitmap,
+ CFbsBitmap *& aMaskBitmap)
+ {
+ TAknLayoutRect layoutRect;
+ TRect rect;
+ TSize size;
+ switch(mData->mImageTextureId)
+ {
+ case KAlfTrackTopTextureId:
+ {
+ AknIconUtils::CreateIconL(
+ aBitmap,
+ aMaskBitmap,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_graf_nslider_end_left,
+ EMbmAvkonQgn_graf_nslider_end_left_mask );
+
+
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderLeft,mData->mSliderCentre,KVariety0);
+
+ AknIconUtils::SetSize( aBitmap,
+ TSize(layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight),
+ EAspectRatioNotPreserved);
+ mData->mImageTextureId = 0;
+ mData->mTrackTopTextureId = aId;
+ }
+ break;
+ case KAlfTrackBottomTextureId:
+ {
+ AknIconUtils::CreateIconL(
+ aBitmap,
+ aMaskBitmap,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_graf_nslider_end_right,
+ EMbmAvkonQgn_graf_nslider_end_right_mask );
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderRight,
+ mData->mSliderCentre,
+ KVariety0);
+
+ AknIconUtils::SetSize( aBitmap,
+ TSize(layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight),
+ EAspectRatioNotPreserved);
+
+
+ mData->mImageTextureId = 0;
+ mData->mTrackBottomTextureId = aId;
+ }
+ break;
+ case KAlfTrackMiddleTextureId:
+ {
+ AknIconUtils::CreateIconL(
+ aBitmap,
+ aMaskBitmap,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_graf_nslider_middle,
+ EMbmAvkonQgn_graf_nslider_middle_mask );
+
+ //AknIconUtils::SetSize( aBitmap,TSize(304,14),EAspectRatioNotPreserved);
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EPSliderCentre,
+ mData->mSliderCentre,
+ KVariety0);
+ AknIconUtils::SetSize( aBitmap,
+ TSize(layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight),
+ EAspectRatioNotPreserved);
+ mData->mImageTextureId = 0;
+ mData->mTrackMiddleTextureId = aId;
+ }
+ break;
+ case KAlfMarkerTextureId:
+ {
+ AknIconUtils::CreateIconL(
+ aBitmap,
+ aMaskBitmap,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_graf_nslider_marker,
+ EMbmAvkonQgn_graf_nslider_marker_mask );
+
+ layoutRect = MulSliderUtils::GetComponentRect(
+ EHSliderHandle,
+ mData->mBaseSliderLayout,
+ KVariety1);
+
+ AknIconUtils::SetSize( aBitmap,
+ TSize(layoutRect.Rect().Size().iWidth,
+ layoutRect.Rect().Size().iHeight),
+ EAspectRatioNotPreserved);
+ mData->mImageTextureId = 0;
+ mData->mMarkerTextureId = aId;
+ }
+ default:
+ break;
+
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// ConvertDataToPixels
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::ConvertDataToPixels()
+ {
+ // Calculate the range in pixel values
+ int distance = (mData->mSliderCentre->Size().iX.ValueNow() -
+ mData->mSliderHandle->Size().iX.ValueNow());
+ if((mSliderModel->MaxRange() - mSliderModel->MinRange()) != 0)
+ {
+ // Calculate Tick Size in Pixels
+ mData->mTickInPixels =
+ (float)distance /(mSliderModel->MaxRange()
+ - mSliderModel->MinRange()) ;
+ }
+ // Get the track start pixel value
+ mData->mTrackStartPoint = mData->mSliderCentre->Pos().iX.ValueNow() ;
+ // Store current tick
+ mData->mCurrTick = mSliderModel->PrimaryValue() ;
+ mData->mTick = mSliderModel->Tick();
+ }
+
+
+// ---------------------------------------------------------------------------
+// createVisualization
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::createVisualization(sliderTemplate /*aTemplateId*/)
+ {
+ // Create the visualization
+ CAlfControl* ctrl = (CAlfControl*)&control();
+ // Visual Hierarchy creation
+ //creating mMainLayout
+ mData->mMainLayout = CAlfLayout::AddNewL(*ctrl,NULL);
+ // set the flag for Notifications and mirroring
+ mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);
+ mData->mMainLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);
+ // create mBaseSliderLayout
+ mData->mBaseSliderLayout = CAlfLayout::AddNewL(*ctrl,mData->mMainLayout);
+ mData->mBaseSliderLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);
+ //create dummy layout for slider track
+ mData->mSliderCentreGhost =
+ CAlfLayout::AddNewL(*ctrl,mData->mBaseSliderLayout);
+ //create dummy layout for slider Thumb
+ // create imagevisual for slider track
+ mData->mSliderCentre =
+ CAlfLayout::AddNewL(*ctrl,mData->mBaseSliderLayout);
+ mData->mTrackLeftImage = CAlfImageVisual::AddNewL(*ctrl,mData->mSliderCentre);
+ mData->mTrackMiddleImage = CAlfImageVisual::AddNewL(*ctrl,mData->mSliderCentre);
+ mData->mTrackRightImage = CAlfImageVisual::AddNewL(*ctrl,mData->mSliderCentre);
+
+ // create imagevisual for slider thumb
+ mData->mSliderHandle =
+ CAlfImageVisual::AddNewL(*ctrl,mData->mBaseSliderLayout);
+ // Attach brush and transfer its ownership to the visual.
+ mData->mSliderHandleGhost =
+ CAlfLayout::AddNewL(*ctrl,mData->mBaseSliderLayout);
+
+ // Get the widget opacity and apply on root visual
+ mSliderWidget->ShowWidget(mSliderWidget->GetOpacity(),0);
+ }
+
+
+// ---------------------------------------------------------------------------
+// eventHandlerType
+// ---------------------------------------------------------------------------
+//
+IAlfWidgetEventHandler::AlfEventHandlerType MulSliderHorizontal::eventHandlerType()
+ {
+ return IAlfWidgetEventHandler::EPresentationEventHandler;
+ }
+
+
+// ---------------------------------------------------------------------------
+// eventExecutionPhase
+// ---------------------------------------------------------------------------
+//
+IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase MulSliderHorizontal::eventExecutionPhase()
+ {
+ return IAlfWidgetEventHandler::ETunnellingPhaseEventHandler;
+ }
+
+// ---------------------------------------------------------------------------
+// offerEvent
+// ---------------------------------------------------------------------------
+//
+AlfEventStatus MulSliderHorizontal::offerEvent( CAlfWidgetControl& /*aControl*/,
+ const TAlfEvent& aEvent )
+ {
+ AlfEventStatus ret = EEventNotHandled;
+ if(!mSliderWidget->IsHidden())
+ {
+ if(aEvent.IsCustomEvent())
+ {
+ if(aEvent.CustomParameter() == EEventMissedPointerUp)
+ {
+ mData->mLongTapStarted = false;
+ ret=EEventHandled;
+ handlePointerUpEvent();
+ }
+ }
+ // handle key events
+ else if(aEvent.IsKeyEvent() && mSliderWidget->IsKeyEnabled())
+ {
+ ret = HandleKeyEvents(aEvent);
+ }
+ // Pointer drag events and single tap events
+ else if(aEvent.IsPointerEvent())
+ {
+ ret = HandlePointerEvents((TAlfEvent *)&aEvent);
+ }
+ }
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// handleLongTap ( Long TapTimer calls inside its RUNL)
+// ---------------------------------------------------------------------------
+//
+ AlfEventStatus MulSliderHorizontal::handleLongTap()
+ {
+ mData->mMainLayout->ClearFlag(EAlfVisualFlagLayoutUpdateNotification);
+ //CAlfVisual * focusvisual = aEvent->Visual();
+ AlfEventStatus ret = EEventNotHandled;
+ if (mData->mVisual == mData->mSliderCentre || mData->mVisual == mData->mSliderCentreGhost)
+ {
+ mData->mLongTapStarted = true;
+ ret = trackVisualHit(mData->mVisual);
+ // Handle Long tap timer tactile feedback
+ MulSliderControl& sldrcntrl = static_cast<MulSliderControl&>(control());
+ sldrcntrl.TactileEffectOnTouchandHold();
+ }
+
+ // ret = HandlePointerEvents(aEvent);
+ mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// HandleKeyEvents
+// ---------------------------------------------------------------------------
+//
+ AlfEventStatus MulSliderHorizontal::HandleKeyEvents(const TAlfEvent& aEvent)
+ {
+ AlfEventStatus ret = EEventNotHandled;
+ int newPos = 0;
+ int data = 0;
+ if(AknLayoutUtils::LayoutMirrored())
+ {
+ data= - mData->mTick;
+ }
+ else
+ {
+ data= mData->mTick;
+ }
+ if(aEvent.Code() == EEventKey )
+ {
+ if(aEvent.KeyEvent().iScanCode == EStdKeyRightArrow)
+ {
+ ret = EEventHandled;
+ newPos = mSliderModel->PrimaryValue() + data;
+ updateModelPrimaryValue(newPos);
+ }
+ else if(aEvent.KeyEvent().iScanCode == EStdKeyLeftArrow)
+ {
+ ret = EEventHandled;
+ newPos = mSliderModel->PrimaryValue() - data;
+ updateModelPrimaryValue(newPos);
+ }
+ }
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Sends drag Up or Down event, according to the hit position
+// on track
+// ---------------------------------------------------------------------------
+//
+AlfEventStatus MulSliderHorizontal::trackVisualHit(CAlfVisual * /*aHitVisual*/)
+ {
+
+ //Find the thumb Anchor Layout.
+ TAlfTimedPoint thumbVisPos = mData->mSliderHandle->Pos();
+ TAlfTimedPoint thumbVisSize = mData->mSliderHandle->Size();
+ //Check if click was above/to left or below/to right of
+ //thumb
+ if (mData->mLongTapPos.iX < thumbVisPos.iX.ValueNow())
+ {// Pointer down happened left side of Handle
+
+ int newPos = mSliderModel->PrimaryValue() - mData->mTick;
+ if(mData->mLongTapStarted)
+ {
+ if(mData->mdirection !=2)
+ {
+ // Move Handle
+ updateModelPrimaryValue(newPos);
+ mData->mdirection = 1;
+ }
+ }
+ }
+ else if (mData->mLongTapPos.iX > (thumbVisPos.iX.ValueNow() +
+ thumbVisSize.iX.ValueNow()) )
+ {
+ // Pointer down happened right side of Handle
+ int newPos = mSliderModel->PrimaryValue() + mData->mTick;
+ if(mData->mLongTapStarted)
+ {
+ if(mData->mdirection !=1)
+ {
+ // Move Handle
+ updateModelPrimaryValue(newPos);
+ mData->mdirection = 2;
+ }
+ }
+ }
+ else
+ {
+ if(mData->mIsLongTapObserverSet)
+ {
+ // Stop the long tap timer
+ mLongTapTimer->Stop();
+ mData->mLongTapStarted = false;
+ if(AknLayoutUtils::LayoutMirrored() )
+ {
+ mData->mLongTapPos.iX = mData->mMainLayout->Size().iX.ValueNow() -
+ mData->mLongTapPos.iX;
+ }
+ mData->mIsLongTapObserverSet = EFalse;
+ if(!mData->mOperation)
+ {
+ mData->mVisual = mData->mSliderHandle;
+ initializeThumbDragData(
+ mData->mLongTapPos);
+ }
+ }
+ else
+ {
+ //Do Nothing.
+ }
+ }
+ return EEventHandled;
+ }
+
+
+// ---------------------------------------------------------------------------
+// handles the pointerDown event
+//
+// ---------------------------------------------------------------------------
+//
+AlfEventStatus MulSliderHorizontal::handlePointerDownEvent(TAlfEvent * aPntrEvent)
+ {
+ CAlfVisual * focusvisual = aPntrEvent->Visual();
+ AlfEventStatus result = EEventNotHandled;
+ if (focusvisual)
+ {
+ mData->mVisual = focusvisual;
+
+ if (IsSliderVisual(focusvisual))
+ {
+ control().processEvent(TAlfEvent(ECustomEventIconClick));
+ control().Display()->Roster().SetPointerEventObservers(
+ EAlfPointerEventReportDrag ,control());
+ if(!mData->mOperation)
+ {
+ mData->mIsLongTapObserverSet = ETrue;
+ //mData->mLongTapPos = aPntrEvent->PointerEvent().iParentPosition;
+ mirrorPointerPosition(aPntrEvent->PointerEvent().iParentPosition);
+ mData->mLongTapStarted = true;
+ mLongTapTimer->Start();
+ // Dont send custom event at pointer up
+
+ }
+ //Tick Movement
+ if (focusvisual == mData->mSliderCentre ||
+ focusvisual == mData->mSliderCentreGhost)
+ {
+ mData->mLongTapStarted = true;
+ return trackVisualHit(focusvisual);
+ }
+
+ // Drag
+ else if (focusvisual == mData->mSliderHandle ||
+ focusvisual == mData->mSliderHandleGhost )
+ {
+ // Initialize the drag variables
+ if(!mData->mOperation)
+ {
+ initializeThumbDragData(
+ aPntrEvent->PointerEvent().iParentPosition);
+ //Tactile Feedback for thumb touch
+ MulSliderControl& sldrcntrl = static_cast<MulSliderControl&>(control());
+ sldrcntrl.TactileEffectOnTouchandHold();
+ }
+
+ result = EEventHandled;
+ }
+ }
+
+ }
+ return result;
+ }
+
+
+// ---------------------------------------------------------------------------
+// HandlePointerEvents
+// ---------------------------------------------------------------------------
+//
+ AlfEventStatus MulSliderHorizontal::HandlePointerEvents(TAlfEvent* aEvent)
+ {
+ AlfEventStatus ret = EEventHandled;
+ if (aEvent->PointerEvent().iType == TPointerEvent::EButton1Down)
+ {
+ mData->mdirection = 0;
+ ret = handlePointerDownEvent(aEvent);
+ }
+ // Drag Events
+ else if (aEvent->PointerEvent().iType == TPointerEvent::EDrag)
+ {
+
+ if(!mData->mOperation)
+ {// Drag during tap and hold on track .
+ if(mData->mIsLongTapObserverSet)
+ {// Store the new pointer position
+ //mData->mLongTapPos=aEvent->PointerEvent().iParentPosition;
+ mirrorPointerPosition(aEvent->PointerEvent().iParentPosition);
+ }
+ else
+ {
+ //Do Nothing.
+ }
+ }
+ else
+ {
+ // Drag on Handle
+ if(mData->mIsLongTapObserverSet &&
+ mData->mVisual &&
+ mData->mSliderHandle &&
+ mData->mSliderHandleGhost)
+ {
+ // Store the new pointer position
+ mirrorPointerPosition(aEvent->PointerEvent().iParentPosition);
+ }
+ else
+ {
+ // Do nothing
+ }
+ int dist;
+ // Calculate the distance moved from the drag start point
+ if(AknLayoutUtils::LayoutMirrored())
+ {
+ dist = mData->mDragPoint.iX -
+ aEvent->PointerEvent().iParentPosition.iX ;
+ }
+ else
+ {
+ dist = aEvent->PointerEvent().iParentPosition.iX -
+ mData->mDragPoint.iX ;
+ }
+ // Calculate the new tick position
+ int precision = KRoundupvalue;
+ if(dist<0)
+ {
+ precision = -KRoundupvalue;
+ }
+ int newPos= (int)(((float)dist / mData->mTickInPixels ) + precision) +
+ mData->mDragStartStep;
+ // send tactile sensitive event
+ // Update the model hence update visualization
+ updateModelPrimaryValue(newPos);
+ }
+ // Tactile Feedback for Drag
+ //Tactile Feedback for thumb drag
+ MulSliderControl& sldrcntrl = static_cast<MulSliderControl&>(control());
+ sldrcntrl.TactileEffectOnDrag(*aEvent);
+ }
+ else if(aEvent->PointerUp() )
+ {
+ mData->mLongTapStarted = false;
+ handlePointerUpEvent();
+
+ }
+ else
+ {
+ //Do Nothing.
+ }
+
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// updateModelPrimaryValue
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::updateModelPrimaryValue( int aNewPosValue)
+ {
+ // Validate the new tick value
+ if(aNewPosValue< mSliderModel->MinRange())
+ {
+ aNewPosValue = mSliderModel->MinRange();
+ }
+ else if(aNewPosValue > mSliderModel->MaxRange())
+ {
+ aNewPosValue = mSliderModel->MaxRange();
+ }
+ if(mSliderModel->PrimaryValue() != aNewPosValue && mData->mTick != 0)
+ {
+ // Update visualization and model only if data is changed
+ mPosData.reset(new(EMM)MulSliderPos);
+ mPosData->mPreviousValue = mSliderModel->PrimaryValue() ;
+ mSliderModel->SetPrimaryValue(aNewPosValue);
+ mPosData->mCurrentValue =aNewPosValue;
+ mData->mCurrTick = aNewPosValue;
+
+ // Send event to the slider widget
+ TAlfEvent customevent(ETypePrimaryValueChange,
+ (uint)mPosData.get());
+ control().processEvent(customevent);
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// snapPrimaryValueToTicks
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::snapPrimaryValueToTicks()
+ {
+ // If the position is not a multiple of ticks then
+ //snap to the nearest tick multiple
+
+ int currHandlePos = mSliderModel->PrimaryValue() - mSliderModel->MinRange();
+ int tick = mSliderModel->Tick();
+ int newPos = currHandlePos + mSliderModel->MinRange();
+ if(mSliderModel->PrimaryValue() < mSliderModel->MaxRange())
+ {
+ int diff = 0;
+ if(tick > 0) //model
+ {
+ diff = currHandlePos - ((currHandlePos /tick) * tick);
+ }
+ if(diff !=0)
+ {
+ newPos = currHandlePos + tick - diff + mSliderModel->MinRange();
+ }
+ }
+
+ // Update model
+ updateModelPrimaryValue(newPos);
+ }
+
+
+// ---------------------------------------------------------------------------
+// handlePointerUpEvent
+//
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::handlePointerUpEvent()
+ {
+ // if thumb or track is clicked, change the graphics
+ // Send event if single click has hapened
+
+ snapPrimaryValueToTicks();
+
+ if(mData->mOperation)
+ {
+ //Somehow missed the Up event?
+ stopDrag();
+ //Tactile Feedback For Thumb Release
+ MulSliderControl& sldrcntrl = static_cast<MulSliderControl&>(control());
+ sldrcntrl.TactileEffectOnRelease();
+ }
+ if(mData->mIsLongTapObserverSet)
+ {
+ // Stop the long tap timer
+ mLongTapTimer->Stop();
+ // Un-register with the roster for long tap events
+ control().Display()->Roster().SetPointerEventObservers(0,
+ control());
+ mData->mIsLongTapObserverSet = EFalse;
+ }
+ else
+ {
+ //Do Nothing.
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// UpdateVisualization
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::updateVisualization()
+ {
+ ConvertDataToPixels();
+ SetThumbPosition();
+ }
+
+// ---------------------------------------------------------------------------
+//Mirror pointer position
+// ---------------------------------------------------------------------------
+//
+void MulSliderHorizontal::mirrorPointerPosition(const TPoint& aPointerPos )
+ {
+ mData->mLongTapPos = aPointerPos;
+ if(AknLayoutUtils::LayoutMirrored())
+ {
+ mData->mLongTapPos.iX = mData->mMainLayout->Size().iX.ValueNow() -
+ mData->mLongTapPos.iX ;
+ }
+ }
+// ---------------------------------------------------------------------------
+// SetThumbPosition
+// ---------------------------------------------------------------------------
+//
+
+void MulSliderHorizontal::SetThumbPosition()
+ {
+ // Current primary value in pixels
+ int newTickVal = (mSliderModel->PrimaryValue() - mSliderModel->MinRange()) *
+ mData->mTickInPixels;
+ // Handle
+ int handleY = mData->mSliderHandle->Pos().iY.ValueNow();
+ int ghostHandleY = mData->mSliderHandleGhost->Pos().iY.ValueNow();
+ // Handle new pos
+ int widthDiff = (mData->mSliderHandleGhost->Size().iX.ValueNow() -
+ mData->mSliderHandle->Size().iX.ValueNow())/2;
+ TAlfRealPoint pnt(mData->mTrackStartPoint + newTickVal,handleY);
+ // Ghost Handle ( Extended) new pos
+ TAlfRealPoint pnt1(mData->mTrackStartPoint -
+ widthDiff/2 + newTickVal,ghostHandleY);
+ // Set the position
+ mData->mSliderHandle->SetPos(pnt,0);
+ mData->mSliderHandleGhost->SetPos(pnt1,0);
+
+ // Update visualization variables
+ mData->mCurrTick = mSliderModel->PrimaryValue();
+ }
+
+
+// ---------------------------------------------------------------------------
+// accept
+// ---------------------------------------------------------------------------
+//
+bool MulSliderHorizontal::accept( CAlfWidgetControl& /*aControl*/,
+ const TAlfEvent& aEvent ) const
+ {
+ // Accept only key or pointer events.
+ if(aEvent.IsKeyEvent()||aEvent.IsPointerEvent())
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+//initializeThumbDragData
+// ---------------------------------------------------------------------------
+//
+bool MulSliderHorizontal::initializeThumbDragData( const TPoint& aPointerPos )
+ {
+ TRAPD(err,control().Display()->Roster().SetPointerDragThreshold(control(),
+ TAlfXYMetric(TAlfMetric(KXToleranceInPixel,EAlfUnitPixel),
+ TAlfMetric(KYToleranceInPixel,EAlfUnitPixel))) );
+
+ if(mData->mVisual && err == KErrNone)
+ {
+ mData->mOperation = EMoveItem;
+ mData->mDragPoint = aPointerPos;
+ mData->mDragStartStep = mSliderModel->PrimaryValue();
+
+ }
+ else
+ {
+ // Do Nothing
+ }
+ return ETrue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// stopDrag
+//
+// ---------------------------------------------------------------------------
+//
+bool MulSliderHorizontal::stopDrag()
+ {
+ TRAPD(err,
+ control().Display()->Roster().SetPointerEventObservers(
+ 0,
+ control()));
+ if(err == KErrNone)
+ {
+ mData->mVisual = NULL;
+ mData->mOperation = ENop;
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+
+
+// ---------------------------------------------------------------------------
+// IsSliderVisual
+//
+// ---------------------------------------------------------------------------
+//
+bool MulSliderHorizontal::IsSliderVisual(CAlfVisual *aVisual)
+ {
+ if(aVisual == mData->mSliderCentre||
+ aVisual == mData->mTrackLeftImage ||
+ aVisual == mData->mTrackMiddleImage ||
+ aVisual == mData->mTrackRightImage ||
+ aVisual == mData->mSliderCentreGhost||
+ aVisual == mData->mSliderHandle||
+ aVisual == mData->mSliderHandleGhost)
+ {
+ return true;
+ }
+ return false;
+ }
+
+ void MulSliderHorizontal::updateTextVisualization()
+ {
+
+ }
+ }//namespace Alf
+
+//End Of File