uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/statehandler.cpp
Change HuiStatic.cpp to avoid VFP instructions in the static initialiser - avoids Bug 3937
/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: State machine interface. Used for the statemachine in the
* server drawer to keep track on when a transition should be made
* and when not.
*
*/
#include "statehandler.h"
#include "states.h"
#include "uidblock.h"
#include "uidexception.h"
#include <alflogger.h>
// ---------------------------------------------------------------------------
// This LUT defines what fullscreen transitions is of wich type.
// It is needed by the filter, but is part of platform requirements,
// so it feels logical to keep it here.
// ---------------------------------------------------------------------------
//
#include <akntranseffect.h>
const CStateHandler::TFullscreenType FullscreenTypeLUT[] =
{
CStateHandler::ENone, //none
CStateHandler::EActivation, //activation
CStateHandler::EError, //removed action
CStateHandler::EStart, //start
CStateHandler::EStart, //start embedded
CStateHandler::EExit, //exit
CStateHandler::EStart, //start rect
CStateHandler::EStart, //start switch
CStateHandler::EStart, //start switch rect
CStateHandler::EExit, //exit for end key
CStateHandler::EExit, //exit embedded
CStateHandler::EError, //right?
CStateHandler::ELayoutSwitch, //ELayoutSwitch
CStateHandler::ELayoutSwitch, //ELayoutSwitch
CStateHandler::ELayoutSwitch, //ELayoutSwitch
};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateBase::CStateBase(MAlfDrawerEngine& aEngine, CStateHandler& aHandler) :
iEngine(aEngine),
iHandler(aHandler)
{
}
CStateBase::~CStateBase()
{
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
TBool CStateBase::IsBlocked(const TUid& aFromUid, const TUid& aToUid)
{
return iHandler.IsBlocked(aFromUid, aToUid);
}
// ---------------------------------------------------------------------------
// StateHandler Implementation:
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CStateHandler::Signal(CStateBase::TSignal aSignal)
{
CStateBase* newstate = NULL;
TRAPD(err, newstate = iState->SignalL(aSignal));
if((KErrNone == err) && (NULL != newstate))
{
delete iState;
iState = newstate;
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
TBool CStateHandler::IsBlocked(const TUid& aFromUid, const TUid& aToUid)
{
__ALFFXLOGSTRING2("CStateHandler::IsBlocked - aFromUid: 0x%x, aToUid: 0x%x", aFromUid, aToUid );
TInt flags = iEngine.Flags();
if(flags & AknTransEffect::TParameter::EActivateExplicitContinue)
{
// return EFalse;
}
for(TInt i = iExceptionList.Count() - 1; i >= 0; i--)
{
if(iExceptionList[i]->IsAllowed(aFromUid,aToUid))
{
__ALFFXLOGSTRING("CStateHandler::IsBlocked - return EFalse <<");
return EFalse;
}
}
for(TInt i = iBlockList.Count() - 1; i >= 0; i--)
{
if(iBlockList[i]->IsBlocked(aFromUid,aToUid))
{
__ALFFXLOGSTRING("CStateHandler::IsBlocked - return ETrue <<");
return ETrue;
}
}
__ALFFXLOGSTRING("CStateHandler::IsBlocked - return EFalse <<");
return EFalse;
}
// ---------------------------------------------------------------------------
// OOM condition means block will not be added, this is ok.
// ---------------------------------------------------------------------------
//
void CStateHandler::AddBlockUid(const TUid& aUid)
{
CFullUidBlock* uidblock = new CFullUidBlock(aUid);
if(uidblock)
{
if(KErrNone != iBlockList.Append(uidblock))
{
//Failed to add, forget about it.
delete uidblock;
}
}
}
// ---------------------------------------------------------------------------
// OOM condition means block will not be added, this is ok.
// ---------------------------------------------------------------------------
//
void CStateHandler::AddBlockUidPair(const TUid& aFromUid, const TUid& aToUid)
{
CPairedUidBlock* uidblock = new CPairedUidBlock(aFromUid, aToUid);
if(uidblock)
{
if(KErrNone != iBlockList.Append(uidblock))
{
//Failed to add, forget about it.
delete uidblock;
}
}
}
// ---------------------------------------------------------------------------
// OOM condition means exception will not be added, this is ok.
// ---------------------------------------------------------------------------
//
void CStateHandler::AddExceptionUid(const TUid& aUid)
{
CFullUidException* uidexception = new CFullUidException(aUid);
if(uidexception)
{
if(KErrNone != iExceptionList.Append(uidexception))
{
//Failed to add, forget about it.
delete uidexception;
}
}
}
// ---------------------------------------------------------------------------
// OOM condition means exception will not be added, this is ok.
// ---------------------------------------------------------------------------
//
void CStateHandler::AddExceptionUidPair(const TUid& aFromUid, const TUid& aToUid)
{
CPairedUidException* uidexception = new CPairedUidException(aFromUid, aToUid);
if(uidexception)
{
if(KErrNone != iExceptionList.Append(uidexception))
{
//Failed to add, forget about it.
delete uidexception;
}
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CStateHandler::RemoveBlockUid(const TUid& aUid)
{
for(TInt i = iBlockList.Count() - 1; i >= 0; i--)
{
if(iBlockList[i]->IsBlocked(aUid,aUid))
{
delete iBlockList[i];
iBlockList.Remove(i);
}
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateHandler::TFullscreenType CStateHandler::GetFullscreenType(TUint aAction)
{
TFullscreenType type = EError;
if(aAction < (sizeof(FullscreenTypeLUT) / sizeof(TInt)))
{
type = FullscreenTypeLUT[aAction];
}
if(aAction >= AknTransEffect::EAppSpesificEvent)
type = EAppSpecific;
return type;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateHandler::TFullscreenType CStateHandler::GetCurrentFullscreenType()
{
return GetFullscreenType(iState->StateInfo().iAction);
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateHandler* CStateHandler::NewL(MAlfDrawerEngine* aEngine)
{
CStateHandler* self = new (ELeave) CStateHandler(aEngine);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateBase::TState CStateHandler::GetState()
{
return iState->StateInfo().iState;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CStateHandler::CStateHandler(MAlfDrawerEngine* aEngine) :
iEngine(*aEngine)
{
}
void CStateHandler::ConstructL()
{
iState = CRestingState::NewL(iEngine,*this);
}
CStateHandler::~CStateHandler()
{
iBlockList.ResetAndDestroy();
iExceptionList.ResetAndDestroy();
delete iState;
}