TBool CWsSpriteBase::UpdateMemberL(CWsSpriteMember *aMember, const TCmdSpriteMember &aCmdSpriteMember)
{
CFbsBitmap *old=aMember->iBitmap;
CFbsBitmap *oldMask=aMember->iMaskBitmap;
aMember->iBitmap=NULL;
aMember->iMaskBitmap=NULL;
TBool ret=EFalse;
TRAPD(err,ret=aMember->SetL(aCmdSpriteMember));
if (err!=KErrNone)
{
um_error:
delete aMember->iBitmap;
delete aMember->iMaskBitmap;
aMember->iBitmap=old;
aMember->iMaskBitmap=oldMask;
User::Leave(err);
}
TRAP(err,CheckSizesL());
if (err!=KErrNone)
goto um_error;
SetMember(0);
delete old;
delete oldMask;
return(ret);
}
void Transform::ChangeData(const QString& member, const QVariant& data)
{
Q_UNUSED(member); Q_UNUSED(data);
if(member == "Scale")
{
SetMember(m_scale,data);
}
else if(member == "Translate")
{
SetMember(m_pos,data);
}
else
{
SetMember(m_rotation,data);
}
}
void CWsSpriteBase::TimerExpired()
{
if (!Screen()->ChangeTracking())
Screen()->SpriteManager()->Schedule(this);
SetMember((iCurIndex+1)==iMembers->Count() ? 0 : iCurIndex+1);
SetDirty(ETrue);
Screen()->SpriteManager()->Schedule(this);
QueueDeltaTimer();
}
void CWsSpriteBase::CommandL(TInt aOpcode, const TAny *aCmdData)
{
TWsSpriteCmdUnion pData;
pData.any=aCmdData;
switch(aOpcode)
{
case EWsSpriteOpAppendMember:
AppendMemberL(*pData.SpriteMember);
break;
case EWsSpriteOpActivate:
if(!(iFlags&ESpriteActive))
CompleteL();
break;
case EWsSpriteOpUpdateMember:
if (pData.UpdateMember->index==iCurIndex)
{
SetDirty(ETrue);
TRect rect(Pos(), iMaxSize);
Screen()->SpriteManager()->Schedule(this,&rect);
}
break;
case EWsSpriteOpUpdateMember2:
{
SetDirty(ETrue);
Screen()->SpriteManager()->Schedule(this);
if (pData.UpdateMember->index<0 || pData.UpdateMember->index>=iMembers->Count())
User::Leave(KErrArgument);
CWsSpriteMember *member=(*iMembers)[pData.UpdateMember->index];
TBool ret=EFalse;
TRAPD(err,ret=UpdateMemberL(member,pData.UpdateMember->data));
if (err==KErrNone)
{
TRAP(err,CheckSizesL());
SetMember(0);
}
Screen()->SpriteManager()->Schedule(this);
User::LeaveIfError(err);
if (ret)
OwnerPanic(EWservPanicBitmap);
}
break;
default:
OwnerPanic(EWservPanicOpcode);
break;
}
}
void CWsSpriteBase::CompleteL()
{
if (iMembers->Count() <= 0)
{
if(iWin)
iWin->OwnerPanic(EWservPanicNoSpriteMember);
//Not sure if this is a neccessary fall back if iWin is NULL.
else if(iWin==NULL && iGroupWin)
iGroupWin->OwnerPanic(EWservPanicNoSpriteMember);
}
else
{
iMembers->Compress();
CheckSizesL();
SetMember(0);
}
}
VOID
FASTCALL
KiSetPriorityThread (
IN PRKTHREAD Thread,
IN KPRIORITY Priority
)
/*++
Routine Description:
This function set the priority of the specified thread to the specified
value. If the thread is in the standby or running state, then the processor
may be redispatched. If the thread is in the ready state, then some other
thread may be preempted.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Priority - Supplies the new thread priority value.
Return Value:
None.
--*/
{
PRKPRCB Prcb;
ULONG Processor;
KPRIORITY ThreadPriority;
PRKTHREAD Thread1;
ASSERT(Priority <= HIGH_PRIORITY);
//
// Capture the current priority of the specified thread.
//
ThreadPriority = Thread->Priority;
//
// If the new priority is not equal to the old priority, then set the
// new priority of the thread and redispatch a processor if necessary.
//
if (Priority != ThreadPriority) {
Thread->Priority = (SCHAR)Priority;
//
// Case on the thread state.
//
switch (Thread->State) {
//
// Ready case - If the thread is not in the process ready queue,
// then remove it from its current dispatcher ready queue. If the
// new priority is less than the old priority, then insert the
// thread at the tail of the dispatcher ready queue selected by
// the new priority. Else reready the thread for execution.
//
case Ready:
if (Thread->ProcessReadyQueue == FALSE) {
RemoveEntryList(&Thread->WaitListEntry);
if (IsListEmpty(&KiDispatcherReadyListHead[ThreadPriority])) {
ClearMember(ThreadPriority, KiReadySummary);
}
if (Priority < ThreadPriority) {
InsertTailList(&KiDispatcherReadyListHead[Priority],
&Thread->WaitListEntry);
SetMember(Priority, KiReadySummary);
} else {
KiReadyThread(Thread);
}
}
break;
//
// Standby case - If the thread's priority is being lowered, then
// attempt to find another thread to execute. If a new thread is
// found, then put the new thread in the standby state, and reready
// the old thread.
//
case Standby:
#if !defined(NT_UP)
Processor = Thread->NextProcessor;
#endif
if (Priority < ThreadPriority) {
#if !defined(NT_UP)
Thread1 = KiFindReadyThread(Processor, Priority);
#else
Thread1 = KiFindReadyThread(0, Priority);
#endif
if (Thread1 != NULL) {
#if !defined(NT_UP)
Prcb = KiProcessorBlock[Processor];
#else
Prcb = KiProcessorBlock[0];
#endif
Thread1->State = Standby;
Prcb->NextThread = Thread1;
KiReadyThread(Thread);
}
}
break;
//
// Running case - If there is not a thread in the standby state
// on the thread's processor and the thread's priority is being
// lowered, then attempt to find another thread to execute. If
// a new thread is found, then put the new thread in the standby
// state, and request a redispatch on the thread's processor.
//
case Running:
#if !defined(NT_UP)
Processor = Thread->NextProcessor;
Prcb = KiProcessorBlock[Processor];
#else
Prcb = KiProcessorBlock[0];
#endif
if (Prcb->NextThread == NULL) {
if (Priority < ThreadPriority) {
#if !defined(NT_UP)
Thread1 = KiFindReadyThread(Processor, Priority);
#else
Thread1 = KiFindReadyThread(0, Priority);
#endif
if (Thread1 != NULL) {
Thread1->State = Standby;
Prcb->NextThread = Thread1;
#if !defined(NT_UP)
KiRequestDispatchInterrupt(Processor);
#endif
}
}
}
break;
//
// Initialized, Terminated, Waiting, Transition case - For
// these states it is sufficient to just set the new thread
// priority.
//
default:
break;
}
}
return;
}
VOID
FASTCALL
KiReadyThread (
IN PRKTHREAD Thread
)
/*++
Routine Description:
This function readies a thread for execution and attempts to immediately
dispatch the thread for execution by preempting another lower priority
thread. If a thread can be preempted, then the specified thread enters
the standby state and the target processor is requested to dispatch. If
another thread cannot be preempted, then the specified thread is inserted
either at the head or tail of the dispatcher ready selected by its priority
acccording to whether it was preempted or not.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Return Value:
None.
--*/
{
PRKPRCB Prcb;
BOOLEAN Preempted;
KPRIORITY Priority;
PRKPROCESS Process;
ULONG Processor;
KPRIORITY ThreadPriority;
PRKTHREAD Thread1;
KAFFINITY IdleSet;
//
// Save value of thread's preempted flag, set thread preempted FALSE,
// capture the thread priority, and set clear the read wait time.
//
Preempted = Thread->Preempted;
Thread->Preempted = FALSE;
ThreadPriority = Thread->Priority;
Thread->WaitTime = KiQueryLowTickCount();
//
// If the thread's process is not in memory, then insert the thread in
// the process ready queue and inswap the process.
//
Process = Thread->ApcState.Process;
if (Process->State != ProcessInMemory) {
Thread->State = Ready;
Thread->ProcessReadyQueue = TRUE;
InsertTailList(&Process->ReadyListHead, &Thread->WaitListEntry);
if (Process->State == ProcessOutOfMemory) {
Process->State = ProcessInTransition;
InsertTailList(&KiProcessInSwapListHead, &Process->SwapListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
}
return;
} else if (Thread->KernelStackResident == FALSE) {
//
// The thread's kernel stack is not resident. Increment the process
// stack count, set the state of the thread to transition, insert
// the thread in the kernel stack inswap list, and set the kernel
// stack inswap event.
//
Process->StackCount += 1;
Thread->State = Transition;
InsertTailList(&KiStackInSwapListHead, &Thread->WaitListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
return;
} else {
//
// If there is an idle processor, then schedule the thread on an
// idle processor giving preference to the processor the thread
// last ran on. Otherwise, try to preempt either a thread in the
// standby or running state.
//
#if defined(NT_UP)
Prcb = KiProcessorBlock[0];
if (KiIdleSummary != 0) {
KiIdleSummary = 0;
KiIncrementSwitchCounter(IdleLast);
#else
IdleSet = KiIdleSummary & Thread->Affinity;
if (IdleSet != 0) {
Processor = Thread->IdealProcessor;
if ((IdleSet & (1 << Processor)) == 0) {
Processor = Thread->NextProcessor;
if ((IdleSet & (1 << Processor)) == 0) {
Prcb = KeGetCurrentPrcb();
if ((IdleSet & Prcb->SetMember) == 0) {
FindFirstSetLeftMember(IdleSet, &Processor);
KiIncrementSwitchCounter(IdleAny);
} else {
Processor = Prcb->Number;
KiIncrementSwitchCounter(IdleCurrent);
}
} else {
KiIncrementSwitchCounter(IdleLast);
}
} else {
KiIncrementSwitchCounter(IdleIdeal);
}
Thread->NextProcessor = (CCHAR)Processor;
ClearMember(Processor, KiIdleSummary);
Prcb = KiProcessorBlock[Processor];
#endif
Prcb->NextThread = Thread;
Thread->State = Standby;
return;
} else {
#if !defined(NT_UP)
Processor = Thread->IdealProcessor;
if ((Thread->Affinity & (1 << Processor)) == 0) {
Processor = Thread->NextProcessor;
if ((Thread->Affinity & (1 << Processor)) == 0) {
FindFirstSetLeftMember(Thread->Affinity, &Processor);
}
}
Thread->NextProcessor = (CCHAR)Processor;
Prcb = KiProcessorBlock[Processor];
#endif
if (Prcb->NextThread != NULL) {
Thread1 = Prcb->NextThread;
if (ThreadPriority > Thread1->Priority) {
Thread1->Preempted = TRUE;
Prcb->NextThread = Thread;
Thread->State = Standby;
KiReadyThread(Thread1);
KiIncrementSwitchCounter(PreemptLast);
return;
}
} else {
Thread1 = Prcb->CurrentThread;
if (ThreadPriority > Thread1->Priority) {
Thread1->Preempted = TRUE;
Prcb->NextThread = Thread;
Thread->State = Standby;
KiRequestDispatchInterrupt(Thread->NextProcessor);
KiIncrementSwitchCounter(PreemptLast);
return;
}
}
}
}
//
// No thread can be preempted. Insert the thread in the dispatcher
// queue selected by its priority. If the thread was preempted and
// runs at a realtime priority level, then insert the thread at the
// front of the queue. Else insert the thread at the tail of the queue.
//
Thread->State = Ready;
if (Preempted != FALSE) {
InsertHeadList(&KiDispatcherReadyListHead[ThreadPriority],
&Thread->WaitListEntry);
} else {
InsertTailList(&KiDispatcherReadyListHead[ThreadPriority],
&Thread->WaitListEntry);
}
SetMember(ThreadPriority, KiReadySummary);
return;
}
PRKTHREAD
FASTCALL
KiSelectNextThread (
IN PRKTHREAD Thread
)
/*++
Routine Description:
This function selects the next thread to run on the processor that the
specified thread is running on. If a thread cannot be found, then the
idle thread is selected.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Return Value:
The address of the selected thread object.
--*/
{
PRKPRCB Prcb;
ULONG Processor;
PRKTHREAD Thread1;
//
// Get the processor number and the address of the processor control block.
//
#if !defined(NT_UP)
Processor = Thread->NextProcessor;
Prcb = KiProcessorBlock[Processor];
#else
Prcb = KiProcessorBlock[0];
#endif
//
// If a thread has already been selected to run on the specified processor,
// then return that thread as the selected thread.
//
if ((Thread1 = Prcb->NextThread) != NULL) {
Prcb->NextThread = (PKTHREAD)NULL;
} else {
//
// Attempt to find a ready thread to run.
//
#if !defined(NT_UP)
Thread1 = KiFindReadyThread(Processor, 0);
#else
Thread1 = KiFindReadyThread(0, 0);
#endif
//
// If a thread was not found, then select the idle thread and
// set the processor member in the idle summary.
//
if (Thread1 == NULL) {
KiIncrementSwitchCounter(SwitchToIdle);
Thread1 = Prcb->IdleThread;
#if !defined(NT_UP)
SetMember(Processor, KiIdleSummary);
#else
KiIdleSummary = 1;
#endif
}
}
//
// Return address of selected thread object.
//
return Thread1;
}
void ILuaObject::SetMember( int iKey, CFunc f )
{
SetMember( (double) iKey, f );
}
void ILuaObject::SetMember( int iKey, const char* s, unsigned int iLen )
{
SetMember( (double) iKey, s, iLen );
}
void ILuaObject::SetMember( int iKey, bool b )
{
SetMember( (double) iKey, b );
}
void ILuaObject::SetMember( int iKey, double d )
{
SetMember( (double) iKey, d );
}
void ILuaObject::SetMember( int iKey, ILuaObject* obj )
{
SetMember( (double) iKey, obj );
}
void ILuaObject::SetMember( float fKey, CFunc f )
{
SetMember( (double) fKey, f );
}
void ILuaObject::SetMember( float fKey, bool b )
{
SetMember( (double) fKey, b );
}
void ILuaObject::SetMember( float fKey, double d )
{
SetMember( (double) fKey, d );
}
void ILuaObject::SetMember( float fKey, ILuaObject* obj )
{
SetMember( (double) fKey, obj );
}
