--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/activepalette/Src/ActivePalette2Model.cpp Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,2350 @@
+/*
+* 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: Active Palette 2 Model*
+*/
+
+
+/**
+ * @file ActivePalette2Model.cpp
+ * Active Palette 2 Model
+ */
+
+// INCLUDE FILES
+#include <activepalette2eventdata.h>
+#include <activepalette2observer.h>
+#include <activepalette2itemvisible.h>
+#include <activepalette2genericpluginint.h>
+
+#include "ActivePalette2Item.h"
+#include "ActivePalette2Model.h"
+#include "ActivePalette2ModelObserver.h"
+#include "ActivePalette2Logger.h"
+#include "ActivePalette2Cfg.h"
+#include "activepalette2configuration.h"
+#include "ActivePalette2Utils.h"
+
+
+// -----------------------------------------------------------------------------
+// TRendererCallBacks::TRendererCallBacks()
+// -----------------------------------------------------------------------------
+//
+TRendererCallBacks::TRendererCallBacks()
+: iTooltipTimer(NULL),
+ iFocusTimer(NULL),
+ iItemScrollTimer(NULL),
+ iAppearanceTimer(NULL),
+ iTooltipDescriptive(NULL),
+ iFocusDescriptive(NULL),
+ iItemScrollDescriptive(NULL),
+ iAppearanceDescriptive(NULL)
+ {
+ // no implementation needed
+ }
+
+
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::NewL()
+// 2 phase construction
+// -----------------------------------------------------------------------------
+//
+CActivePalette2Model* CActivePalette2Model::NewL(
+ MActivePalette2ModelObserver& aModelObserver,
+ TSize aItemSize,
+ const TRendererCallBacks& aCallbacks,
+ CActivePalette2Configuration* aConfiguration /*=NULL*/ )
+ {
+ CActivePalette2Model * self =
+ new (ELeave) CActivePalette2Model( aModelObserver,
+ aItemSize,
+ aCallbacks,
+ aConfiguration );
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(); // this
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CActivePalette2Model()
+// C++ Constuctor
+// -----------------------------------------------------------------------------
+//
+CActivePalette2Model::CActivePalette2Model(
+ MActivePalette2ModelObserver& aModelObserver,
+ TSize aItemSize,
+ const TRendererCallBacks& aCallbacks,
+ CActivePalette2Configuration* aConfiguration )
+ : iPreviousItemID(KInvalidId),
+ iFocusedItemID(KInvalidId),
+ iPaletteMoveCurrentOffset(0),
+ iPaletteMoveOffsetTotalFrames(NAP2Cfg::KPaletteAppearFrames),
+ iPaletteMoveAnimationDuration(NAP2Cfg::KPaletteAppearTotalTime / KMicrosecondsPerMillisecond),
+ iAnimState(EPaletteAnimIdle),
+ iCallbacks(aCallbacks),
+ iModelObserver(aModelObserver),
+ iItemSize(aItemSize),
+ iTooltipConfig()
+ {
+ LOGTEXT( _L( "CActivePalette2Model::CActivePalette2Model entered" ));
+ if( aConfiguration )
+ {
+ aConfiguration->TooltipConfiguration( iTooltipConfig );
+ }
+ else
+ {
+ iTooltipConfig.iPreshowDelay = NAP2Cfg::KTooltipPreshowDelay;
+ iTooltipConfig.iFullshowPeriod = NAP2Cfg::KTooltipFullshowPeriod;
+ iTooltipConfig.iTimerTickLength = NAP2Cfg::KTooltipTimerTickLength;
+ iTooltipConfig.iTransitionSpeed = NAP2Cfg::KTooltipShowSpeed;
+ iTooltipConfig.iTransitionFrames = KErrNotSupported;
+ }
+ LOGTEXT( _L( "CActivePalette2Model::CActivePalette2Model left" ));
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ConstructL(void)
+// 2nd phase constructor
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ConstructL(void)
+ {
+ iTooltipTimer = CPeriodic::NewL(CActive::EPriorityHigh); // high priority for smooth animation
+ iFocusChangeTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ iItemScrollTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ iItemAnimTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ iPaletteMoveTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::~CActivePalette2Model()
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CActivePalette2Model::~CActivePalette2Model()
+ {
+ LOGTEXT( _L( "CActivePalette2Model::~CActivePalette2Model entered" ));
+
+ if (iTooltipTimer)
+ {
+ iTooltipTimer->Cancel();
+ delete iTooltipTimer;
+ }
+
+ if (iFocusChangeTimer)
+ {
+ iFocusChangeTimer->Cancel();
+ delete iFocusChangeTimer;
+ }
+
+ if (iItemScrollTimer)
+ {
+ iItemScrollTimer->Cancel();
+ delete iItemScrollTimer;
+ }
+
+ if (iItemAnimTimer)
+ {
+ iItemAnimTimer->Cancel();
+ delete iItemAnimTimer;
+ }
+
+ if (iPaletteMoveTimer)
+ {
+ iPaletteMoveTimer->Cancel();
+ delete iPaletteMoveTimer;
+ }
+
+ iItemsArray.ResetAndDestroy();
+ iItemsArray.Close();
+ iVisibilityArray.Reset();
+ iVisibilityArray.Close();
+
+ LOGTEXT( _L( "CActivePalette2Model::~CActivePalette2Model left" ));
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FindItem()
+// item data management
+// -----------------------------------------------------------------------------
+//
+CActivePalette2Item* CActivePalette2Model::FindItem(const TInt aItemId) const
+ {
+ TInt index = ItemIndexFromId(aItemId);
+
+ if ( ValidItemIndex(index) )
+ {
+ return static_cast<CActivePalette2Item *>(iItemsArray[index]);
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::DoInstallItemL()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::DoInstallItemL(TInt aItemId,
+ TBool aVisible,
+ const TUid& aPluginUid,
+ const TDesC8& aCustomDataDes,
+ TInt aCustomDataInt)
+ {
+ // check if item ID is unique
+ if ( ItemIndexFromId(aItemId) != KInvalidItemIndex )
+ {
+ return KErrArgument;
+ }
+
+ // item and plugin instantiate
+ CActivePalette2Item* item = CActivePalette2Item::NewLC(aItemId,aPluginUid, *this);
+
+ item->InitPluginL(aCustomDataDes, aCustomDataInt);
+
+ User::LeaveIfError(iItemsArray.Append(item));
+ User::LeaveIfError(iVisibilityArray.Append(aVisible));
+
+ CleanupStack::Pop(item);
+
+ if ( aVisible )
+ {
+ EnforceConstraints();
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::RemoveItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::RemoveItem(const TInt aItemId)
+ {
+ LOGTEXT1( _L( "CActivePalette2Model::RemoveItem entered, Item ID: %d" ),
+ aItemId);
+
+ TInt res(KErrNone);
+
+ CActivePalette2Item* item = FindItem(aItemId);
+ TInt index = ItemIndexFromId(aItemId);
+
+ if (item) // valid item
+ {
+ iItemsArray.Remove(index); // unregister
+ iVisibilityArray.Remove(index);
+
+ // destroy item
+ CBase::Delete(item); // implies plugin shutodown and DLL unload
+
+ EnforceConstraints();
+ }
+ else
+ {
+ res = KErrArgument;
+ }
+
+ LOGTEXT1( _L( "CActivePalette2Model::RemoveItem left, res %d" ), res);
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::HandleItemSelected()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::HandleItemSelected(const TInt aItemIndex)
+ {
+ LOGTEXT1( _L( "CActivePalette2Model::HandleItemSelected entered, Item ID: %d" ),
+ aItemIndex);
+
+ if ( ValidItemIndex(aItemIndex) )
+ {
+ CActivePalette2Item* item = iItemsArray[aItemIndex];
+ if (item)
+ {
+ TInt err;
+
+ LOGTEXT( _L( "... calling plugin's HandleItemSelectedL" ));
+
+ TRAP(err, item->Plugin().HandleItemSelectedL());
+
+ LOGTEXT1( _L( "... res : %d" ), err);
+
+ if (KErrNone != err)
+ {
+ // leave during item selection handling, invoke callback now
+ NotifyItemComplete(*item, err, KNullDesC8, KActivePaletteNoDataInt);
+ }
+ }
+ else
+ {
+ LOGTEXT( _L( "... INTERNAL FAULT: item object not found" ));
+ }
+ }
+
+ LOGTEXT( _L( "CActivePalette2Model::HandleItemSelected left" ));
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::DispatchMessage()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::DispatchMessage(const TInt aItemId, const TInt aMessageID, const TDesC8& aDataDes, const TInt aDataInt)
+ {
+ LOGTEXT2( _L( "CActivePalette2Model::DispatchMessgage entered, Item ID: %d, Message ID : %d" ),
+ aItemId, aMessageID);
+
+ TInt res;
+ CActivePalette2Item* item = FindItem(aItemId);
+ if (item)
+ {
+ TInt err;
+
+ LOGTEXT( _L( "...calling plugin's HandleMessageL" ));
+
+ TRAP(err, item->Plugin().HandleMessageL(aMessageID, aDataDes, aDataInt));
+
+ LOGTEXT1( _L( "... res : %d" ), err);
+
+ res = err; // retransmit error code
+ }
+ else
+ {
+ res = KErrArgument;
+ }
+
+ LOGTEXT1( _L( "CActivePalette2Model::DispatchMessgage left, res %d" ), res);
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::Observer()
+// -----------------------------------------------------------------------------
+//
+MActivePalette2ModelObserver& CActivePalette2Model::Observer(void) const
+ {
+ return iModelObserver;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemIndexFromId()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemIndexFromId(const TInt aItemId) const
+ {
+ TInt res = KInvalidItemIndex;
+ TInt currentItemIndex = 0;
+
+ while ( res == KInvalidItemIndex && ValidItemIndex(currentItemIndex) )
+ {
+ if ( iItemsArray[currentItemIndex]->ItemId() == aItemId )
+ {
+ res = currentItemIndex;
+ }
+ else
+ {
+ currentItemIndex++;
+ }
+ }
+
+ return res;
+ }
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::TooltipText()
+// -----------------------------------------------------------------------------
+//
+TDesC* CActivePalette2Model::TooltipText()
+ {
+ if ( ValidItemIndex(iFocusedItem) )
+ {
+ CActivePalette2Item& api = static_cast<CActivePalette2Item &> (*iItemsArray[iFocusedItem]);
+ return api.Tooltip();
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ShowTooltip()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::ShowTooltip()
+ {
+ return iShowTooltip;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::TooltipCurrentFrame()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipCurrentFrame()
+ {
+ return iTooltipCurrentFrame;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::TooltipTotalFrames()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipTotalFrames()
+ {
+ return iTooltipTotalFrames;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::TooltipScreenPosition()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipScreenPosition()
+ {
+ return FocusedItem();
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CompelTooltip()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::CompelTooltip()
+ {
+ TInt tooltip_width = iModelObserver.TooltipUpdated();
+
+ if( iTooltipConfig.iTransitionFrames > 0 )
+ iTooltipTotalFrames = iTooltipConfig.iTransitionFrames;
+ else
+ iTooltipTotalFrames = tooltip_width / iTooltipConfig.iTransitionSpeed;
+
+ TooltipSetState( ETooltipRise );
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::RemoveTooltip(void)
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::RemoveTooltip(void)
+ {
+ TooltipSetState(ETooltipNone);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::TooltipSteadyAniAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipSteadyAniAction(void)
+ {
+ // start shrinking
+ TooltipSetState(ETooltipSet);
+ return KCallbackFinished;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::TooltipRiseAniAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipRiseAniAction(void)
+ {
+ TInt res = KCallbackFinished;
+
+ iShowTooltip = ETrue;
+
+ if ( iCallbacks.iTooltipTimer )
+ {
+ if (iTooltipCurrentFrame >= iTooltipTotalFrames)
+ {
+ TooltipSetState(ETooltipSteady);
+ }
+ else
+ {
+ res = KCallbackCallAgain;
+ iTooltipCurrentFrame++;
+ }
+
+ iCallbacks.iTooltipTimer->TooltipAnimated();
+ }
+ else if ( iCallbacks.iTooltipDescriptive )
+ {
+ TInt duration( (iTooltipTotalFrames*iTooltipConfig.iTimerTickLength) / KMicrosecondsPerMillisecond );
+ iCallbacks.iTooltipDescriptive->AnimateTooltip( ETrue, duration );
+ iTooltipTimer->Cancel();
+ }
+ else
+ {
+ // just for Lint.
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::TooltipDisappearAniAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipDisappearAniAction(void)
+ {
+ TInt res = KCallbackFinished;
+
+ if ( iCallbacks.iTooltipTimer )
+ {
+ if (iTooltipCurrentFrame <= 0)
+ {
+ TooltipSetState(ETooltipNone);
+ }
+ else
+ {
+ res = KCallbackCallAgain;
+ iTooltipCurrentFrame--;
+ }
+
+ if ( iCallbacks.iTooltipTimer )
+ {
+ iCallbacks.iTooltipTimer->TooltipAnimated();
+ }
+ }
+ else if ( iCallbacks.iTooltipDescriptive )
+ {
+ TInt duration( (iTooltipTotalFrames*iTooltipConfig.iTimerTickLength) / KMicrosecondsPerMillisecond );
+ iCallbacks.iTooltipDescriptive->AnimateTooltip( EFalse, duration );
+ iTooltipTimer->Cancel();
+ }
+ else
+ {
+ // just for Lint.
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::TooltipTimerCallback()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::TooltipTimerCallback(TAny* aPtr)
+ {
+ CActivePalette2Model* self = (CActivePalette2Model*) aPtr;
+ TInt res = KCallbackFinished;
+
+ switch (self->iTooltipState)
+ {
+ case ETooltipSteady:
+ res = self->TooltipSteadyAniAction();
+ break;
+
+ case ETooltipRise:
+ res = self->TooltipRiseAniAction();
+ break;
+
+ case ETooltipSet:
+ res = self->TooltipDisappearAniAction();
+ break;
+
+ default:
+ break;
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Tooltip::TooltipSetState()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::TooltipSetState(TTooltipState aState)
+ {
+ iTooltipTimer->Cancel();
+ TBool isOk = ETrue;
+
+ switch (aState)
+ {
+ case ETooltipNone:
+ iTooltipTimer->Cancel();
+ if ( iShowTooltip || iTooltipCurrentFrame > 0 )
+ {
+ iShowTooltip = EFalse;
+ iTooltipCurrentFrame = 0;
+ iModelObserver.ShowTooltipUpdated();
+ }
+ break;
+
+ case ETooltipSteady:
+ iTooltipTimer->Start(
+ iTooltipConfig.iFullshowPeriod,
+ iTooltipConfig.iFullshowPeriod,
+ TCallBack(&CActivePalette2Model::TooltipTimerCallback,(TAny *)this));
+ break;
+
+ case ETooltipRise:
+ iTooltipCurrentFrame = 0;
+ iTooltipTimer->Start(
+ iTooltipConfig.iPreshowDelay,
+ iTooltipConfig.iTimerTickLength,
+ TCallBack(&CActivePalette2Model::TooltipTimerCallback,(TAny *)this));
+ break;
+
+ case ETooltipSet:
+// iTooltipCurrentFrame = 0;
+ iTooltipTimer->Start(
+ iTooltipConfig.iTimerTickLength,
+ iTooltipConfig.iTimerTickLength,
+ TCallBack(&CActivePalette2Model::TooltipTimerCallback,(TAny *)this));
+ break;
+
+ default:
+ isOk = EFalse;
+ break;
+ }
+
+ if (isOk)
+ {
+ iTooltipState = aState;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusChangeComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::AnimateTooltipRendererComplete()
+ {
+ switch (iTooltipState)
+ {
+ case ETooltipRise:
+ TooltipSetState(ETooltipSteady);
+ break;
+
+ case ETooltipSet:
+ TooltipSetState(ETooltipNone);
+ break;
+
+ default:
+ case ETooltipNone:
+ case ETooltipSteady:
+ break;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CountItemsOnScreen()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::CountItemsOnScreen(void)
+ {
+ return iNoItemsOnScreen;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ShowTopScrollIndicator()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::ShowTopScrollIndicator(void)
+ {
+ return iShowTopScrollArrow;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ShowBottomScrollIndicator()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::ShowBottomScrollIndicator(void)
+ {
+ return iShowBottomScrollArrow;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::InitialiseConstraints()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::InitialiseConstraints(void)
+ {
+ iTopItemOnScreen = FindVisibleItem(0);
+
+ iFocusedItem = iTopItemOnScreen;
+
+ iNoVisibleItems = CountVisibleItems(0);
+
+ iNoItemsOnScreen = Min(NAP2Cfg::KMaxNofItemsInView, iNoVisibleItems);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::EnforceConstraints()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::EnforceConstraints(void)
+ {
+ CompleteAnyItemBasedAnimations();
+
+ iNoVisibleItems = CountVisibleItems(0);
+
+ iNoItemsOnScreen = Min(NAP2Cfg::KMaxNofItemsInView, iNoVisibleItems);
+
+ iTopItemOnScreen = FindVisibleItem(iTopItemOnScreen);
+
+ if(CountVisibleItems(iTopItemOnScreen) < iNoItemsOnScreen)
+ {
+ iTopItemOnScreen = FindVisibleItem(0);
+
+ if ( iNoVisibleItems > iNoItemsOnScreen )
+ {
+ while ( CountVisibleItems(iTopItemOnScreen) < iNoItemsOnScreen )
+ {
+ iTopItemOnScreen = FindVisibleItem(iTopItemOnScreen + 1);
+ }
+ }
+ }
+
+ if ( iNoVisibleItems > 0 )
+ {
+ if ( iFocusedItem < 0 )
+ {
+ iFocusedItem = FindVisibleItem(0);
+ }
+
+ if ( iFocusedItem >= iItemsArray.Count() )
+ {
+ iFocusedItem = PreviousVisibleItem(iItemsArray.Count() - 1);
+ }
+
+ if ( ValidItemIndex(iFocusedItem) )
+ {
+ if ( !iVisibilityArray[iFocusedItem] )
+ {
+ TInt previousFocusedItem = iFocusedItem;
+
+ iFocusedItem = FindVisibleItem(iFocusedItem);
+
+ if ( iFocusedItem == KInvalidItemIndex )
+ {
+ iFocusedItem = PreviousVisibleItem(previousFocusedItem);
+ }
+
+ if ( iFocusedItem == KInvalidItemIndex )
+ {
+ iFocusedItem = FindVisibleItem(0);
+ }
+ }
+ }
+
+ if ( iFocusedItem < iTopItemOnScreen )
+ {
+ iTopItemOnScreen = iFocusedItem;
+ }
+ else
+ {
+ while ( iFocusedItem > BottomItemOnScreen() )
+ {
+ iTopItemOnScreen = FindVisibleItem(iTopItemOnScreen + 1);
+ }
+ }
+ }
+ else
+ {
+ iFocusedItem = KInvalidItemIndex;
+ }
+
+ ItemsUpdated();
+ FocusedItemUpdated();
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CompleteAnyItemBasedAnimations()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::CompleteAnyItemBasedAnimations()
+ {
+ switch (iAnimState)
+ {
+ case EPaletteAnimItemScroll:
+ case EPaletteAnimFocusChange:
+ case EPaletteAnimItemAnim:
+ SetAnimState(EPaletteAnimIdle);
+ break;
+
+ default:
+ // do nothing
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::BottomItemOnScreen()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::BottomItemOnScreen(void)
+ {
+ TInt bottomItemOnScreen = iTopItemOnScreen;
+
+ for(TInt i = 1; i < iNoItemsOnScreen; i++)
+ {
+ bottomItemOnScreen = FindVisibleItem(bottomItemOnScreen + 1);
+ }
+
+ return bottomItemOnScreen;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FindVisibleItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FindVisibleItem(TInt aStartingItem)
+ {
+ TInt result = KInvalidItemIndex;
+ TInt currentItem = aStartingItem;
+ TBool found = EFalse;
+ TInt arraySize = iVisibilityArray.Count();
+
+ if ( aStartingItem != KInvalidItemIndex )
+ {
+ while(!found && currentItem < arraySize)
+ {
+ if(iVisibilityArray[currentItem])
+ {
+ result = currentItem;
+ found = ETrue;
+ }
+ else
+ {
+ currentItem++;
+ }
+ }
+ }
+
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PreviousVisibleItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::PreviousVisibleItem(TInt aStartingItem)
+ {
+ TInt result = KInvalidItemIndex;
+ TInt currentItem = aStartingItem;
+ TBool found = EFalse;
+
+ if ( aStartingItem != KInvalidItemIndex )
+ {
+ while(!found && currentItem >= 0)
+ {
+ if(iVisibilityArray[currentItem])
+ {
+ result = currentItem;
+ found = ETrue;
+ }
+ else
+ {
+ currentItem--;
+ }
+ }
+ }
+
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CountVisibleItems()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::CountVisibleItems(TInt aStartingItem)
+ {
+ TInt result = 0;
+ TInt currentItem = aStartingItem;
+ TInt arraySize = iVisibilityArray.Count();
+
+ if ( aStartingItem != KInvalidItemIndex )
+ {
+ while(currentItem < arraySize)
+ {
+ if(iVisibilityArray[currentItem])
+ {
+ result++;
+ }
+ currentItem++;
+ }
+ }
+ else
+ {
+ result = KInvalidItemIndex;
+ }
+
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemIndexFromScreenPos()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemIndexFromScreenPos(TInt aScreenPos)
+ {
+ TInt result = KInvalidItemIndex;
+
+ if ( aScreenPos >= 0 && iNoItemsOnScreen > 0 && aScreenPos < NAP2Cfg::KMaxNofItemsInView + 1 )
+ {
+ result = iOnScreenItemIndex[aScreenPos];
+ }
+
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemFromScreenPos()
+// -----------------------------------------------------------------------------
+//
+CActivePalette2Item* CActivePalette2Model::ItemFromScreenPos(TInt aScreenPos)
+ {
+ CActivePalette2Item* result = NULL;
+
+ TInt itemIndex = ItemIndexFromScreenPos(aScreenPos);
+
+ if ( itemIndex != KInvalidItemIndex )
+ {
+ result = iItemsArray[itemIndex];
+ }
+
+ return result;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ScreenPosFromItemIndex()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ScreenPosFromItemIndex(TInt aItem)
+ {
+ TInt result = KInvalidScreenPos;
+ TInt currentItem = iTopItemOnScreen;
+ TInt currentScreenPos = 0;
+ TBool found = EFalse;
+
+ if ( aItem >= iItemsArray.Count() )
+ {
+ result = iNoItemsOnScreen;
+ }
+ else if ( aItem < 0)
+ {
+ result = NAP2Cfg::KScreenPosAboveTop;
+ }
+ else
+ {
+ while ( !found && currentScreenPos < iNoItemsOnScreen )
+ {
+ if ( aItem == currentItem )
+ {
+ found = ETrue;
+ }
+ else
+ {
+ currentItem = FindVisibleItem(currentItem + 1);
+ currentScreenPos++;
+ }
+ }
+
+ if ( found )
+ {
+ result = currentScreenPos;
+ }
+ }
+
+ return result;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusedItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FocusedItem()
+ {
+ return ScreenPosFromItemIndex(iFocusedItem);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusCurrentOffset()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FocusCurrentOffset()
+ {
+ return iFocusedCurrentOffset;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusCurrentTotalOffsetFrames()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FocusCurrentTotalOffsetFrames()
+ {
+ return NAP2Cfg::KFocusChangeFrames;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteAppearingCurrentFrame()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::PaletteAppearingCurrentFrame()
+ {
+ return iPaletteMoveCurrentOffset;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteAppearingTotalFrames()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::PaletteAppearingTotalFrames()
+ {
+ return iPaletteMoveOffsetTotalFrames;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ProcessInputEvent()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::ProcessInputEvent(TActivePalette2InputEvent aEvent)
+ {
+ TBool eventConsumed = EFalse;
+
+ if ( PaletteActive() )
+ {
+ SetAnimState(EPaletteAnimIdle);
+
+ switch(aEvent)
+ {
+ case EAP2InputUp:
+ RemoveTooltip();
+
+ iFocusChangeTargetItem = PreviousVisibleItem(iFocusedItem - 1);
+
+ if ( iFocusChangeTargetItem != KInvalidItemIndex && iFocusChangeTargetItem != iFocusedItem )
+ {
+ if ( ScreenPosFromItemIndex(iFocusedItem) == 0 )
+ {
+ // Item scroll
+ iTopItemOnScreen = iFocusChangeTargetItem;
+ iFocusedItem = iFocusChangeTargetItem;
+
+ iItemScrollCurrentOffset = NAP2Cfg::KItemScrollFrames;
+
+ ItemsUpdated();
+
+ ScrollItems(-1);
+ }
+ else
+ {
+ // Focus change
+ ChangeFocus();
+
+ eventConsumed = ETrue;
+ }
+ }
+ else
+ {
+ iFocusChangeTargetItem = PreviousVisibleItem(iItemsArray.Count() - 1);
+
+ if ( iFocusChangeTargetItem != KInvalidItemIndex && iFocusChangeTargetItem != iFocusedItem )
+ {
+ // Focus wrap
+ TInt screenPos = iNoItemsOnScreen - 1;
+ iTopItemOnScreen = iFocusChangeTargetItem;
+
+ while ( screenPos > 0 )
+ {
+ iTopItemOnScreen = PreviousVisibleItem(iTopItemOnScreen-1);
+ screenPos--;
+ }
+
+ ItemsUpdated();
+
+ iFocusedItem = iItemsArray.Count();
+
+ ChangeFocus();
+
+ eventConsumed = ETrue;
+ }
+ }
+ break;
+ case EAP2InputDown:
+ RemoveTooltip();
+
+ iFocusChangeTargetItem = FindVisibleItem(iFocusedItem + 1);
+
+ if ( iFocusChangeTargetItem != KInvalidItemIndex && iFocusChangeTargetItem != iFocusedItem )
+ {
+ if ( ScreenPosFromItemIndex(iFocusedItem) == (iNoItemsOnScreen - 1))
+ {
+ // Item scroll
+ iItemScrollCurrentOffset = 0;
+
+ ScrollItems(+1);
+ }
+ else
+ {
+ // Focus change
+ ChangeFocus();
+ }
+
+ eventConsumed = ETrue;
+ }
+ else
+ {
+ // wrap focus to top
+ iFocusChangeTargetItem = FindVisibleItem(0);
+
+ if ( iFocusChangeTargetItem != KInvalidItemIndex && iFocusChangeTargetItem != iFocusedItem )
+ {
+ iTopItemOnScreen = iFocusChangeTargetItem;
+ ItemsUpdated();
+ iFocusedItem = -1;
+
+ ChangeFocus();
+ }
+ }
+
+ break;
+
+ case EAP2InputSelect:
+ RemoveTooltip();
+
+ if ( iFocusedItem >= 0 && iFocusedItem < iItemsArray.Count())
+ {
+ if ( iVisibilityArray[iFocusedItem] )
+ {
+ TActivePalette2EventData res(PrepareEventData(*iItemsArray[iFocusedItem], KErrNone));
+
+ if ( iModelObserver.APObserver() )
+ {
+ iModelObserver.APObserver()->NotifyItemSelected(res);
+ }
+
+ HandleItemSelected(iFocusedItem);
+
+ eventConsumed = ETrue;
+ }
+ }
+ break;
+ }
+ }
+
+ return eventConsumed;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ScrollItems()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ScrollItems(TInt aDirection)
+ {
+ SetAnimState(EPaletteAnimItemScroll);
+
+ if ( iCallbacks.iItemScrollTimer )
+ {
+ iItemScrollDirection = aDirection;
+
+ iItemScrollTimer->Start(
+ NAP2Cfg::KItemScrollTimerTickLength,
+ NAP2Cfg::KItemScrollTimerTickLength,
+ TCallBack(&CActivePalette2Model::ItemScrollTimerCallback,(TAny *)this));
+ }
+ else if ( iCallbacks.iItemScrollDescriptive )
+ {
+ iCallbacks.iItemScrollDescriptive->AnimateItemScroll(aDirection, NAP2Cfg::KItemScrollTotalTime / KMicrosecondsPerMillisecond);
+ }
+ else
+ {
+ // just for Lint.
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ChangeFocus()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ChangeFocus()
+ {
+ if ( iCallbacks.iFocusTimer )
+ {
+ if ( iFocusedItem < iFocusChangeTargetItem )
+ {
+ iFocusedCurrentOffset = 0;
+ iFocusChangeDirection = +1;
+ }
+ else
+ {
+ iFocusedCurrentOffset = NAP2Cfg::KFocusChangeFrames;
+ iFocusChangeDirection = -1;
+ iFocusedItem = iFocusChangeTargetItem;
+ }
+
+ SetAnimState(EPaletteAnimFocusChange);
+ iFocusChangeTimer->Start(
+ NAP2Cfg::KFocusChangeTimerTickLength,
+ NAP2Cfg::KFocusChangeTimerTickLength,
+ TCallBack(&CActivePalette2Model::FocusChangeTimerCallback,(TAny *)this));
+ }
+ else if ( iCallbacks.iFocusDescriptive )
+ {
+ SetAnimState(EPaletteAnimFocusChange);
+ iCallbacks.iFocusDescriptive->AnimateFocus(ScreenPosFromItemIndex(iFocusedItem), ScreenPosFromItemIndex(iFocusChangeTargetItem), NAP2Cfg::KFocusChangeTotalTime / KMicrosecondsPerMillisecond);
+ }
+ else
+ {
+ // lint
+ }
+ }
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemAnimInfo()
+// -----------------------------------------------------------------------------
+//
+CActivePalettePluginBase::TPluginAnimationInfo CActivePalette2Model::ItemAnimInfo()
+ {
+ return iAniItemInfo;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetPaletteVisibility()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SetPaletteVisibility(TBool aVisible, TBool aAnimated, TInt aDelayedStartMilliseconds)
+ {
+ // Check if we're already in an appearance animation
+ if ( iAnimState == EPaletteAnimAppearing
+ && iCallbacks.iAppearanceDescriptive )
+ {
+ // If so, update state
+ iPaletteMoveCurrentOffset = iCallbacks.iAppearanceDescriptive->GuessCurrentAppearanceFrame();
+
+ if ( iPaletteMoveCurrentOffset < 0 || iPaletteMoveCurrentOffset > iPaletteMoveOffsetTotalFrames )
+ {
+ iPaletteMoveOffsetTotalFrames = iPaletteMoveOffsetTotalFrames;
+ }
+ }
+
+
+ if ( aAnimated || aDelayedStartMilliseconds > 0)
+ {
+ if ( aVisible )
+ {
+ if ( iPaletteMoveOffsetTotalFrames > iPaletteMoveCurrentOffset )
+ {
+ RemoveTooltip();
+ SetAnimState(EPaletteAnimAppearing);
+ iModelObserver.PaletteAppearingUpdated();
+
+ if ( aAnimated )
+ {
+ iPaletteMoveAnimationDirection = +1;
+ }
+ else
+ {
+ iPaletteMoveAnimationDirection = +iPaletteMoveOffsetTotalFrames;
+ }
+
+ iPaletteMoveTimer->Cancel();
+ iPaletteMoveTimer->Start(Max(1, aDelayedStartMilliseconds * KMicrosecondsPerMillisecond),
+ NAP2Cfg::KPaletteAppearTimerTickLength,
+ TCallBack(&CActivePalette2Model::PaletteAnimTimerCallback,(TAny*)this));
+ }
+ else if ( aAnimated && 0 >= iPaletteMoveAnimationDirection )
+ {
+ iPaletteMoveAnimationDirection = +1;
+ }
+ }
+ else
+ {
+ if ( iPaletteMoveCurrentOffset > 0 )
+ {
+ RemoveTooltip();
+ SetAnimState(EPaletteAnimAppearing);
+ iModelObserver.PaletteAppearingUpdated();
+
+ if ( aAnimated )
+ {
+ iPaletteMoveAnimationDirection = -1;
+ }
+ else
+ {
+ iPaletteMoveAnimationDirection = -iPaletteMoveOffsetTotalFrames;
+ }
+
+
+ iPaletteMoveTimer->Cancel();
+ iPaletteMoveTimer->Start(Max(1, aDelayedStartMilliseconds * KMicrosecondsPerMillisecond),
+ NAP2Cfg::KPaletteAppearTimerTickLength,
+ TCallBack(&CActivePalette2Model::PaletteAnimTimerCallback,(TAny*)this));
+ }
+ //Start fix for ERCK-77PCZJ
+ else
+ {
+ iPaletteMoveAnimationDirection = -iPaletteMoveOffsetTotalFrames;
+ SetAnimState(EPaletteAnimIdle);
+ }
+ //End fix ERCK-77PCZJ
+ }
+ }
+ else
+ {
+ if ( aVisible )
+ {
+ if ( iPaletteMoveOffsetTotalFrames != iPaletteMoveCurrentOffset )
+ {
+ RemoveTooltip();
+ SetAnimState(EPaletteAnimIdle);
+ iPaletteMoveCurrentOffset = iPaletteMoveOffsetTotalFrames;
+ iModelObserver.PaletteAppearingUpdated();
+ }
+ }
+ else
+ {
+ if ( iPaletteMoveCurrentOffset != 0 )
+ {
+ RemoveTooltip();
+ SetAnimState(EPaletteAnimIdle);
+ iPaletteMoveCurrentOffset = 0;
+ iModelObserver.PaletteAppearingUpdated();
+ }
+ //Start fix for ERCK-77PCZJ
+ else
+ {
+ iPaletteMoveAnimationDirection = -iPaletteMoveOffsetTotalFrames;
+ SetAnimState(EPaletteAnimIdle);
+ }
+ //End fix ERCK-77PCZJ
+ }
+ }
+
+ return KErrNone;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::NotifyItemComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::NotifyItemComplete(const CActivePalette2Item& aItem,
+ TInt aResult,
+ const TDesC8& aDataDes,
+ TInt aDataInt)
+ {
+ if ( iModelObserver.APObserver() )
+ {
+ TActivePalette2EventData evt(PrepareEventData(aItem, aResult));
+ iModelObserver.APObserver()->NotifyItemComplete(evt, aDataDes, aDataInt);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::NotifyMessage()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::NotifyMessage(const CActivePalette2Item& aItem,
+ const TInt aResult,
+ const TInt aMessageID,
+ const TDesC8& aDataDes,
+ TInt aDataInt)
+ {
+ if ( iModelObserver.APObserver() )
+ {
+ TActivePalette2EventData eventData = PrepareEventData(aItem, aResult);
+ iModelObserver.APObserver()->NotifyMessage(eventData, aMessageID, aDataDes, aDataInt);
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::NotifyGraphicsChanged()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::NotifyGraphicsChanged(const CActivePalette2Item& /*aItem*/,
+ const TBool aIsIconChanged,
+ const TBool aIsTooltipChanged)
+ {
+ if ( aIsTooltipChanged )
+ {
+ RemoveTooltip();
+ }
+
+ if ( aIsIconChanged )
+ {
+ ItemsUpdated();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PrepareEventData()
+// -----------------------------------------------------------------------------
+//
+TActivePalette2EventData CActivePalette2Model::PrepareEventData(const CActivePalette2Item& aItem,
+ TInt aResult)
+ {
+ TActivePalette2EventData evt
+ (
+ aResult,
+ aItem.ItemId(),
+ iPreviousItemID,
+ aItem.ItemId(),
+ aItem.PluginUid()
+ );
+
+ return evt;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetItemVisibility()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SetItemVisibility(const TInt aItemId, const TBool aIsVisible)
+ {
+ TInt index = ItemIndexFromId(aItemId);
+ TInt res = KErrNotFound;
+
+ if ( ValidItemIndex(index) )
+ {
+ if ( iVisibilityArray[index] != aIsVisible )
+ {
+ iVisibilityArray[index] = aIsVisible;
+ EnforceConstraints();
+ }
+ res = KErrNone;
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::GetItemVisibility()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::GetItemVisibility(const TInt aItemId, TBool &aIsVisible) const
+ {
+ TInt index = ItemIndexFromId(aItemId);
+ TInt res = KErrNone;
+
+ if ( ValidItemIndex(index) )
+ {
+ aIsVisible = iVisibilityArray[index];
+ }
+ else
+ {
+ res = KErrArgument;
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::GetAvailablePlugins()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::GetAvailablePlugins(RArray<TUid>& aPluginList) const
+ {
+ aPluginList.Reset();
+
+ // Generic plugin always available
+ aPluginList.Append(TUid::Uid(KActivePalette2GenericPluginUID));
+
+ AppendPluginIdIfAvailable(aPluginList, TUid::Uid(KPrintPluginUid), TFileName(KPrintPluginDLLName));
+ AppendPluginIdIfAvailable(aPluginList, TUid::Uid(KPrintIntentPluginUid), TFileName(KPrintIntentPluginDLLName));
+ AppendPluginIdIfAvailable(aPluginList, TUid::Uid(KOnlineSharingPluginUid), TFileName(KOnlineSharingPluginDLLName));
+#ifdef ACTIVEPALETTE_SUPPORT_PLUGIN_CAM
+ AppendPluginIdIfAvailable(aPluginList, TUid::Uid(KCamAPPluginUid), TFileName(KCamAPluginDLLName));
+#endif
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::AppendPluginIdIfAvailable()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::AppendPluginIdIfAvailable(RArray<TUid>& aPluginList, const TUid aDllUid, const TFileName aDllFileName) const
+ {
+ RLibrary dll;
+
+ TInt err = dll.Load(aDllFileName);
+
+ if ( err == KErrNone )
+ {
+ aPluginList.Append(aDllUid);
+ }
+
+ dll.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetPaletteVisibilityAnimationDuration()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SetPaletteVisibilityAnimationDuration(TInt aTimeInMilliSeconds)
+ {
+ iPaletteMoveAnimationDuration = aTimeInMilliSeconds;
+
+ TInt targetTotalFrames = (aTimeInMilliSeconds * KMicrosecondsPerMillisecond) / NAP2Cfg::KPaletteAppearTimerTickLength;
+
+ if ( targetTotalFrames < 1 )
+ {
+ targetTotalFrames = 1;
+ }
+
+ // update current frame
+ if ( iPaletteMoveCurrentOffset == iPaletteMoveOffsetTotalFrames )
+ {
+ iPaletteMoveCurrentOffset = targetTotalFrames;
+ }
+ else if ( iPaletteMoveCurrentOffset > 0 && iPaletteMoveOffsetTotalFrames > 0)
+ {
+ iPaletteMoveCurrentOffset = (iPaletteMoveCurrentOffset * targetTotalFrames) / iPaletteMoveOffsetTotalFrames;
+ }
+ else
+ {
+ iPaletteMoveCurrentOffset = 0;
+ }
+
+ iPaletteMoveOffsetTotalFrames = targetTotalFrames;
+
+ // double check we're in range
+ if ( iPaletteMoveCurrentOffset < 0 )
+ {
+ iPaletteMoveCurrentOffset = 0;
+ }
+
+ if ( iPaletteMoveCurrentOffset > iPaletteMoveOffsetTotalFrames )
+ {
+ iPaletteMoveCurrentOffset = iPaletteMoveOffsetTotalFrames;
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::GetItemList()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::GetItemList(RArray<TActivePalette2ItemVisible>& aItemVisibleList) const
+ {
+ aItemVisibleList.Reset();
+
+ TInt currentItem = 0;
+ TInt totalItems = iItemsArray.Count();
+
+ while ( currentItem < totalItems )
+ {
+ aItemVisibleList.Append(
+ TActivePalette2ItemVisible(
+ iItemsArray[currentItem]->ItemId(),
+ iVisibilityArray[currentItem]));
+ currentItem++;
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetItemList()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SetItemList(const RArray<TActivePalette2ItemVisible>& aItemVisibleList)
+ {
+ TInt res = KErrNone;
+ TInt currentItem = 0;
+ TInt totalItems = iItemsArray.Count();
+ TInt totalInputItems = aItemVisibleList.Count();
+ TInt destIndex = 0;
+
+ TInt focusedItemId = 0;
+
+ // Backup the current focused item
+ if ( ValidItemIndex(iFocusedItem) )
+ {
+ focusedItemId = iItemsArray[iFocusedItem]->ItemId();
+ }
+
+ // Check that there aren't any invalid IDs in the list
+ while ( currentItem < totalInputItems && res == KErrNone )
+ {
+ TInt itemId = aItemVisibleList[currentItem].ItemId();
+ TInt foundIndex = ItemIndexFromId(itemId);
+
+ if ( foundIndex == KInvalidItemIndex )
+ {
+ res = KErrNotFound;
+ }
+
+ currentItem++;
+ }
+
+ // Rearrange the item & visibility lists
+ currentItem = 0;
+ while ( currentItem < totalInputItems && destIndex < totalItems && res == KErrNone )
+ {
+ TInt itemId = aItemVisibleList[currentItem].ItemId();
+ TBool visible = aItemVisibleList[currentItem].Visible();
+
+ TInt foundIndex = ItemIndexFromId(itemId);
+
+ if ( foundIndex >= currentItem )
+ {
+ iItemsArray.Insert(iItemsArray[foundIndex], destIndex);
+ iItemsArray.Remove(foundIndex + 1);
+
+ iVisibilityArray.Insert(visible, destIndex);
+ iVisibilityArray.Remove(foundIndex + 1);
+
+ destIndex++;
+ }
+
+ currentItem++;
+ }
+
+ // Update the focus
+ if ( res == KErrNone )
+ {
+ iFocusedItem = ItemIndexFromId(focusedItemId);
+
+ EnforceConstraints();
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::GetPaletteVisibilityAnimationDuration()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::GetPaletteVisibilityAnimationDuration(TInt& aTimeInMilliseconds) const
+ {
+ aTimeInMilliseconds = iPaletteMoveAnimationDuration;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetCurrentItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SetCurrentItem(const TInt aItemId)
+ {
+ TInt err = KErrNotFound;
+ TInt index = ItemIndexFromId(aItemId);
+
+ if ( ValidItemIndex(index) )
+ {
+ err = KErrGeneral;
+
+ if ( iVisibilityArray[index] )
+ {
+ iFocusedItem = index;
+
+ EnforceConstraints();
+
+ err = KErrNone;
+ }
+ }
+
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::GetCurrentItem()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::GetCurrentItem(TInt& aItemId) const
+ {
+ TInt err = KErrGeneral;
+
+ if ( ValidItemIndex(iFocusedItem) )
+ {
+ if ( iItemsArray[iFocusedItem] )
+ {
+ aItemId = iItemsArray[iFocusedItem]->ItemId();
+
+ err = KErrNone;
+ }
+ }
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemsUpdated()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ItemsUpdated()
+ {
+ RemoveTooltip();
+
+ // Update cached data
+ TInt onScreenPos = 0;
+ TInt onScreenIndex = iTopItemOnScreen;
+
+ while ( onScreenIndex != KInvalidItemIndex && onScreenPos < (NAP2Cfg::KMaxNofItemsInView + 1))
+ {
+ iOnScreenItemIndex[onScreenPos] = onScreenIndex;
+ onScreenIndex = FindVisibleItem(onScreenIndex + 1);
+ onScreenPos++;
+ }
+
+ while (onScreenPos < (NAP2Cfg::KMaxNofItemsInView + 1))
+ {
+ iOnScreenItemIndex[onScreenPos] = KInvalidItemIndex;
+ onScreenPos++;
+ }
+
+ iShowTopScrollArrow = iTopItemOnScreen > FindVisibleItem(0);
+ iShowBottomScrollArrow = CountVisibleItems(iTopItemOnScreen) > iNoItemsOnScreen;
+
+ iModelObserver.ItemsUpdated();
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemScrollOffset()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemScrollOffset()
+ {
+ return iItemScrollCurrentOffset;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemScrollTotalFrames()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemScrollTotalFrames()
+ {
+ return NAP2Cfg::KItemScrollFrames;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetAnimState()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::SetAnimState(TPaletteAnimState aNewState)
+ {
+ if ( iAnimState != aNewState )
+ {
+ // Exit old state
+ switch ( iAnimState )
+ {
+ case EPaletteAnimItemScroll:
+ ItemScrollComplete();
+ break;
+
+ case EPaletteAnimFocusChange:
+ FocusChangeComplete();
+ break;
+
+ case EPaletteAnimItemAnim:
+ ItemAnimationComplete();
+ break;
+
+ case EPaletteAnimAppearing:
+ PaletteAnimComplete();
+ break;
+
+ case EPaletteAnimIdle:
+ default:
+ // do nothing;
+ break;
+ }
+
+ // Enter new state
+ switch ( aNewState )
+ {
+ case EPaletteAnimItemScroll:
+ break;
+
+ case EPaletteAnimFocusChange:
+ break;
+
+ case EPaletteAnimItemAnim:
+ StartItemAnimation();
+ break;
+
+ case EPaletteAnimAppearing:
+ break;
+
+ case EPaletteAnimIdle:
+ default:
+ // do nothing;
+ break;
+ }
+
+ iAnimState = aNewState;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteActive()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::PaletteActive()
+ {
+ return ( iAnimState != EPaletteAnimAppearing && iPaletteMoveCurrentOffset == iPaletteMoveOffsetTotalFrames);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ValidItemIndex()
+// -----------------------------------------------------------------------------
+//
+TBool CActivePalette2Model::ValidItemIndex(TInt aItemIndex) const
+ {
+ return (aItemIndex >= 0 && aItemIndex < iItemsArray.Count());
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SendMessage()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SendMessage(TInt aItemId, TInt aMessageId, const TDesC8& aDataDes)
+ {
+ return DispatchMessage(aItemId,aMessageId,aDataDes,KActivePaletteNoDataInt);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SendMessage()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::SendMessage(TInt aItemId, TInt aMessageId, TInt aDataInt)
+ {
+ return DispatchMessage(aItemId,aMessageId,KNullDesC8,aDataInt);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::InstallItemL()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::InstallItemL(const TActivePalette2ItemVisible& aItemVisible,
+ const TUid& aPluginUid,
+ const TDesC8& aCustomDataDes)
+ {
+ return DoInstallItemL(aItemVisible.ItemId(),
+ aItemVisible.Visible(),
+ aPluginUid,aCustomDataDes,
+ KActivePaletteNoDataInt);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::InstallItemL()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::InstallItemL(const TActivePalette2ItemVisible& aItemVisible,
+ const TUid& aPluginUid,
+ TInt aCustomDataInt)
+ {
+ return DoInstallItemL(aItemVisible.ItemId(),
+ aItemVisible.Visible(),
+ aPluginUid,
+ KNullDesC8,
+ aCustomDataInt);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::InstallItemL()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::InstallItemL(const TActivePalette2ItemVisible& aItemVisible,
+ const TUid& aPluginUid,
+ TInt aCustomDataInt,
+ const TDesC8& aCustomDataDes)
+ {
+ return DoInstallItemL(aItemVisible.ItemId(),
+ aItemVisible.Visible(),
+ aPluginUid,
+ aCustomDataDes,
+ aCustomDataInt);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemSize()
+// -----------------------------------------------------------------------------
+//
+TSize CActivePalette2Model::ItemSize()
+ {
+ return iItemSize;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::LocateTo()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::LocateTo(const TPoint& /*aTopLeft*/)
+ {
+ // unused
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::Location()
+// -----------------------------------------------------------------------------
+//
+TPoint CActivePalette2Model::Location() const
+ {
+ // unused
+ return TPoint(0,0);
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::CoeControl()
+// -----------------------------------------------------------------------------
+//
+CCoeControl* CActivePalette2Model::CoeControl()
+ {
+ // unused
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::HuiControl()
+// -----------------------------------------------------------------------------
+//
+CHuiControl* CActivePalette2Model::HuiControl()
+ {
+ // unused
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetGc()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::SetGc(CBitmapContext* /*aGc*/)
+ {
+ // unused
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::RenderActivePalette()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::RenderActivePalette(const TRect& /*aRect*/) const
+ {
+ // unused
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetObserver()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::SetObserver(MActivePalette2Observer* /*aObserver*/)
+ {
+ // unused
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetNavigationKeys()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::SetNavigationKeys(const TActivePalette2NavigationKeys& /*aNavigationKeys*/)
+ {
+ // unused
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::AnimateAppearanceRendererComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::AnimateAppearanceRendererComplete()
+ {
+ if ( iAnimState == EPaletteAnimAppearing )
+ {
+ SetAnimState(EPaletteAnimIdle);
+ iModelObserver.PaletteAppearingUpdated();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::AnimateItemScrollRendererComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::AnimateItemScrollRendererComplete()
+ {
+ if ( iAnimState == EPaletteAnimItemScroll )
+ {
+ SetAnimState(EPaletteAnimItemAnim);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::SetFocusedItem()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::FocusedItemUpdated()
+ {
+ if ( ValidItemIndex(iFocusedItem) )
+ {
+ TInt currentID = iItemsArray[iFocusedItem]->ItemId();
+
+ iPreviousItemID = iFocusedItemID;
+ iFocusedItemID = currentID;
+
+ if ( iModelObserver.APObserver() )
+ {
+ iModelObserver.APObserver()->NotifyItemFocused(iPreviousItemID, iFocusedItemID);
+ }
+
+ if ( iCallbacks.iFocusTimer )
+ {
+ iCallbacks.iFocusTimer->FocusUpdated();
+ }
+ }
+ }
+
+
+
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::StartItemAnimation()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::StartItemAnimation()
+ {
+ CompelTooltip();
+
+ CActivePalettePluginBase::TPluginAnimationInfo animConfig;
+
+ animConfig.iFrameSize = ActivePalette2Utils::APDimensionSize( ActivePalette2Utils::EItemSize );
+ animConfig.iNofFrames = NAP2Cfg::KItemAnimNoFrames;
+ animConfig.iFrameTimeGapMs = NAP2Cfg::KItemAnimFrameDuration;
+
+ iAniItem = iItemsArray[iFocusedItem];
+ iAniItemScreenPos = ScreenPosFromItemIndex(iFocusedItem);
+
+ iAnimationFrame = 0;
+
+ TRAP_IGNORE(iAniItem->Plugin().PrepareAniFramesL(
+ CActivePalettePluginBase::EAniFocused,
+ iAniItemInfo,
+ animConfig,
+ iAniItem->Icon(),
+ iAniItem->Mask()));
+
+ iItemAnimTimer->Start(iAniItemInfo.iFrameTimeGapMs, iAniItemInfo.iFrameTimeGapMs,
+ TCallBack(&CActivePalette2Model::ItemAnimTimerCallback,(TAny*)this));
+
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemAnimTimerCallback()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemAnimTimerCallback(TAny* aPtr)
+ {
+ CActivePalette2Model* self = (CActivePalette2Model*) aPtr;
+
+ if ( self )
+ {
+ return self->ItemAnimAction();
+ }
+ else
+ {
+ return KCallbackFinished;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemAnimAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemAnimAction()
+ {
+ TInt res = KCallbackCallAgain;
+
+ if ( iAnimationFrame > iAniItemInfo.iNofFrames)
+ {
+ res = KCallbackFinished;
+ SetAnimState(EPaletteAnimIdle);
+ }
+ else
+ {
+ iModelObserver.ItemAnimated(iAniItemScreenPos, iAniItem, iAnimationFrame);
+ iAnimationFrame++;
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemAnimationComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ItemAnimationComplete()
+ {
+ iItemAnimTimer->Cancel();
+ iModelObserver.ItemAnimationComplete(iAniItemScreenPos, iAniItem);
+ iAniItem = NULL;
+ iAniItemScreenPos = KInvalidScreenPos;
+ }
+
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemScrollTimerCallback()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemScrollTimerCallback(TAny* aPtr)
+ {
+ CActivePalette2Model* self = (CActivePalette2Model*) aPtr;
+
+ if ( self )
+ {
+ return self->ItemScrollAction();
+ }
+ else
+ {
+ return KCallbackFinished;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemScrollAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::ItemScrollAction()
+ {
+ TInt res = KCallbackCallAgain;
+
+ iItemScrollCurrentOffset += iItemScrollDirection;
+
+ if ( iItemScrollCurrentOffset <= 0 || iItemScrollCurrentOffset >= NAP2Cfg::KItemScrollFrames )
+ {
+ res = KCallbackFinished;
+ SetAnimState(EPaletteAnimItemAnim);
+ }
+ else
+ {
+ if ( iCallbacks.iItemScrollTimer )
+ {
+ iCallbacks.iItemScrollTimer->ItemsScrolled();
+ }
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::ItemScrollComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::ItemScrollComplete()
+ {
+ iItemScrollTimer->Cancel();
+
+ iItemScrollCurrentOffset = 0;
+
+ if ( iFocusedItem != iFocusChangeTargetItem )
+ {
+ iFocusedItem = iFocusChangeTargetItem;
+ iTopItemOnScreen = FindVisibleItem(iTopItemOnScreen + 1);
+ ItemsUpdated();
+ }
+ else
+ {
+ if ( iCallbacks.iItemScrollTimer )
+ {
+ iCallbacks.iItemScrollTimer->ItemsScrolled();
+ }
+ }
+ }
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteAnimTimerCallback()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::PaletteAnimTimerCallback(TAny* aPtr)
+ {
+ CActivePalette2Model* self = (CActivePalette2Model*) aPtr;
+
+ if ( self )
+ {
+ return self->PaletteAnimAction();
+ }
+ else
+ {
+ return KCallbackFinished;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteAnimAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::PaletteAnimAction()
+ {
+ TInt res = KCallbackCallAgain;
+
+ iPaletteMoveCurrentOffset += iPaletteMoveAnimationDirection;
+
+ if ( (iPaletteMoveCurrentOffset <= 0) || (iPaletteMoveCurrentOffset >= iPaletteMoveOffsetTotalFrames))
+ {
+ res = KCallbackFinished;
+ SetAnimState(EPaletteAnimIdle);
+ iModelObserver.PaletteAppearingUpdated();
+ }
+ else
+ {
+ iModelObserver.PaletteAppearingUpdated();
+
+ if ( iCallbacks.iAppearanceDescriptive )
+ {
+ iPaletteMoveTimer->Cancel();
+
+ if ( iPaletteMoveAnimationDirection > 0 )
+ {
+ // Palette is appearing
+ iCallbacks.iAppearanceDescriptive->AnimateAppearance(ETrue,
+ (iPaletteMoveAnimationDuration * (iPaletteMoveOffsetTotalFrames - iPaletteMoveCurrentOffset))
+ / iPaletteMoveOffsetTotalFrames);
+ }
+ else
+ {
+ // Palette is disappearing
+ iCallbacks.iAppearanceDescriptive->AnimateAppearance(EFalse,
+ (iPaletteMoveAnimationDuration * (iPaletteMoveCurrentOffset))
+ / iPaletteMoveOffsetTotalFrames);
+ }
+
+ res = KCallbackFinished;
+ }
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::PaletteAnimComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::PaletteAnimComplete()
+ {
+ iPaletteMoveTimer->Cancel();
+
+ if ( iPaletteMoveAnimationDirection > 0 )
+ {
+ iPaletteMoveCurrentOffset = iPaletteMoveOffsetTotalFrames;
+ }
+ else
+ {
+ iPaletteMoveCurrentOffset = 0;
+ }
+ }
+
+
+
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::AnimateFocusRendererComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::AnimateFocusRendererComplete()
+ {
+ // Check we're expecting call
+ if ( iAnimState == EPaletteAnimFocusChange )
+ {
+ SetAnimState(EPaletteAnimItemAnim);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusChangeTimerCallback()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FocusChangeTimerCallback(TAny* aPtr)
+ {
+ CActivePalette2Model* self = (CActivePalette2Model*) aPtr;
+
+ if ( self )
+ {
+ return self->FocusChangeAction();
+ }
+ else
+ {
+ return KCallbackFinished;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusChangeAction()
+// -----------------------------------------------------------------------------
+//
+TInt CActivePalette2Model::FocusChangeAction()
+ {
+ TInt res = KCallbackCallAgain;
+
+ iFocusedCurrentOffset += iFocusChangeDirection;
+
+ if ( iFocusedCurrentOffset <= 0 || iFocusedCurrentOffset >= NAP2Cfg::KFocusChangeFrames )
+ {
+ res = KCallbackFinished;
+ SetAnimState(EPaletteAnimItemAnim);
+ }
+ else
+ {
+ if ( iCallbacks.iFocusTimer )
+ {
+ iCallbacks.iFocusTimer->FocusAnimated();
+ }
+ }
+
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CActivePalette2Model::FocusChangeComplete()
+// -----------------------------------------------------------------------------
+//
+void CActivePalette2Model::FocusChangeComplete()
+ {
+ iFocusChangeTimer->Cancel();
+
+ iFocusedItem = iFocusChangeTargetItem;
+ iFocusedCurrentOffset = 0;
+
+ FocusedItemUpdated();
+ }
+
+
+// End of File