--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/coretoolkit/src/HuiTransformation.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,368 @@
+/*
+* Copyright (c) 2006-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:   Implementation of CHuiTransformaton. CHuiTransformation 
+*                describes a series of matrix transformation operations.
+*
+*/
+
+
+
+#include "uiacceltk/HuiTransformation.h"
+#include "HuiRenderPlugin.h"
+
+
+EXPORT_C CHuiTransformation* CHuiTransformation::NewL()
+    {
+    CHuiTransformation* self = CHuiTransformation::NewLC();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+
+EXPORT_C CHuiTransformation* CHuiTransformation::NewLC()
+    {
+    CHuiTransformation* self = new (ELeave) CHuiTransformation();
+    CleanupStack::PushL(self);
+    return self;
+    }
+
+
+CHuiTransformation::CHuiTransformation()
+    : iOriginPoint(0.5f,0.5f)
+    {
+    }
+
+EXPORT_C CHuiTransformation::~CHuiTransformation()
+    {
+    iTransforms.ResetAndDestroy();
+    }
+
+
+EXPORT_C TInt CHuiTransformation::Count() const
+    {
+    return iTransforms.Count();
+    }
+
+
+EXPORT_C TInt CHuiTransformation::NonIdentityCount() const
+    {
+    TInt i = 0;
+    TInt nonIdentityCount = 0;
+
+    for(i = 0; i < iTransforms.Count(); ++i)
+        {
+        const TTransform& xf = *iTransforms[i];
+        switch(xf.iType)
+            {
+            case ETypeTranslate:
+                if(xf.iParams[EHuiTransformParamTranslateX].Now() != 0.0f ||
+                   xf.iParams[EHuiTransformParamTranslateY].Now() != 0.0f ||
+                   xf.iParams[EHuiTransformParamTranslateZ].Now() != 0.0f)
+                    {
+                    nonIdentityCount++;
+                    }
+                break;
+
+            case ETypeScale:
+                if(xf.iParams[EHuiTransformParamScaleX].Now() != 1.0f ||
+                   xf.iParams[EHuiTransformParamScaleY].Now() != 1.0f ||
+                   xf.iParams[EHuiTransformParamScaleZ].Now() != 1.0f)
+                    {
+                    nonIdentityCount++;
+                    }
+                break;
+
+            case ETypeRotate:
+                if(xf.iParams[EHuiTransformParamRotateAngle].Now() != 0.0f)
+                    {
+                    nonIdentityCount++;
+                    }
+                break;
+            }
+        }
+    return nonIdentityCount;
+    }
+
+
+EXPORT_C CHuiTransformation::TTransform& CHuiTransformation::Step(TInt aIndex)
+    {
+    return (*this)[aIndex];
+    }
+
+
+EXPORT_C CHuiTransformation::TTransform& 
+    CHuiTransformation::operator [] (TInt aIndex)
+    {
+    iChanged = ETrue;
+    return *iTransforms[aIndex];
+    }
+
+
+EXPORT_C void CHuiTransformation::LoadIdentity()
+    {
+    iChanged = ETrue;
+    iTransforms.ResetAndDestroy();
+    }
+
+
+EXPORT_C void CHuiTransformation::Translate(TReal32 aX, TReal32 aY) __SOFTFP
+    {
+    TTransform translate;
+
+    translate.iType = ETypeTranslate;
+    translate.iParams[EHuiTransformParamTranslateX] = THuiTimedValue(aX);
+    translate.iParams[EHuiTransformParamTranslateY] = THuiTimedValue(aY);
+
+    /*TInt err = */Append(translate);
+    }
+
+
+EXPORT_C void CHuiTransformation::Translate(const THuiTimedValue& aX,
+                                            const THuiTimedValue& aY)
+    {
+    TTransform translate;
+
+    translate.iType = ETypeTranslate;
+    translate.iParams[EHuiTransformParamTranslateX] = aX;
+    translate.iParams[EHuiTransformParamTranslateY] = aY;
+
+    /*TInt err = */Append(translate);
+    }
+
+
+EXPORT_C void CHuiTransformation::Scale(TReal32 aX, TReal32 aY) __SOFTFP
+    {
+    TTransform scale;
+
+    scale.iType = ETypeScale;
+    scale.iParams[EHuiTransformParamScaleX] = THuiTimedValue(aX);
+    scale.iParams[EHuiTransformParamScaleY] = THuiTimedValue(aY);
+    scale.iParams[EHuiTransformParamScaleZ] = THuiTimedValue(1.f);
+
+    /*TInt err = */Append(scale);
+    }
+
+
+EXPORT_C void CHuiTransformation::Scale(const THuiTimedValue& aX,
+                                        const THuiTimedValue& aY)
+    {
+    TTransform scale;
+
+    scale.iType = ETypeScale;
+    scale.iParams[EHuiTransformParamScaleX] = aX;
+    scale.iParams[EHuiTransformParamScaleY] = aY;
+    scale.iParams[EHuiTransformParamScaleZ] = THuiTimedValue(1.f);
+
+    /*TInt err = */Append(scale);
+    }
+
+
+EXPORT_C void CHuiTransformation::Scale(TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP
+    {
+    TTransform scale;
+
+    scale.iType = ETypeScale;
+    scale.iParams[EHuiTransformParamScaleX] = THuiTimedValue(aX);
+    scale.iParams[EHuiTransformParamScaleY] = THuiTimedValue(aY);
+    scale.iParams[EHuiTransformParamScaleZ] = THuiTimedValue(aZ);
+
+    /*TInt err = */Append(scale);
+    }
+
+
+EXPORT_C void CHuiTransformation::Scale(const THuiTimedValue& aX,
+                                        const THuiTimedValue& aY,
+                                        const THuiTimedValue& aZ)
+    {
+    TTransform scale;
+
+    scale.iType = ETypeScale;
+    scale.iParams[EHuiTransformParamScaleX] = aX;
+    scale.iParams[EHuiTransformParamScaleY] = aY;
+    scale.iParams[EHuiTransformParamScaleZ] = aZ;
+
+    /*TInt err = */Append(scale);
+    }
+
+
+EXPORT_C void CHuiTransformation::Rotate(TReal32 aAngle) __SOFTFP
+    {
+    Rotate(aAngle, 0.f, 0.f, -1.f);
+    }
+
+
+EXPORT_C void CHuiTransformation::Rotate(const THuiTimedValue& aAngle)
+    {
+    Rotate(aAngle, 0.f, 0.f, -1.f);
+    }
+
+
+EXPORT_C void CHuiTransformation::Rotate(
+    TReal32 aAngle, 
+    TReal32 aAxisX, 
+    TReal32 aAxisY, 
+    TReal32 aAxisZ) __SOFTFP
+    {
+    TTransform rotate;
+    rotate.iType = ETypeRotate;
+    rotate.iParams[EHuiTransformParamRotateAngle] = THuiTimedValue(aAngle);
+    rotate.iParams[EHuiTransformParamRotateAxisX] = THuiTimedValue(aAxisX);
+    rotate.iParams[EHuiTransformParamRotateAxisY] = THuiTimedValue(aAxisY);
+    rotate.iParams[EHuiTransformParamRotateAxisZ] = THuiTimedValue(aAxisZ);
+
+    /*TInt err = */Append(rotate);
+    }
+
+
+EXPORT_C void CHuiTransformation::Rotate(
+    const THuiTimedValue& aAngle,
+    TReal32 aAxisX, 
+    TReal32 aAxisY, 
+    TReal32 aAxisZ) __SOFTFP
+    {
+    TTransform rotate;
+    rotate.iType = ETypeRotate;
+    rotate.iParams[EHuiTransformParamRotateAngle] = aAngle;
+    rotate.iParams[EHuiTransformParamRotateAxisX] = THuiTimedValue(aAxisX);
+    rotate.iParams[EHuiTransformParamRotateAxisY] = THuiTimedValue(aAxisY);
+    rotate.iParams[EHuiTransformParamRotateAxisZ] = THuiTimedValue(aAxisZ);
+
+    /*TInt err = */Append(rotate);
+    }
+
+
+TInt CHuiTransformation::Append(const TTransform& aTransform)
+    {
+    TTransform* copy = new TTransform;
+    if ( !copy )
+        {
+        return KErrNoMemory;
+        }
+
+    *copy = aTransform;
+    TInt err = iTransforms.Append(copy);
+    
+    if ( err == KErrNone )
+        {
+        iChanged = ETrue;
+        }
+    else
+        {
+        delete copy;
+        }
+    return err;
+    }
+
+
+EXPORT_C void CHuiTransformation::Execute(
+    THuiGcMatrix aMatrix, 
+    CHuiGc& aGc) const
+    {
+    for(TInt i = 0; i < iTransforms.Count(); ++i)
+        {
+        const TTransform& x = *iTransforms[i];
+        switch(x.iType)
+            {
+            case ETypeTranslate:
+                aGc.Translate(aMatrix,
+                              x.iParams[EHuiTransformParamTranslateX].Now(),
+                              x.iParams[EHuiTransformParamTranslateY].Now(),
+                              x.iParams[EHuiTransformParamTranslateZ].Now());
+                break;
+
+            case ETypeScale:
+                aGc.Scale(aMatrix,
+                          x.iParams[EHuiTransformParamScaleX].Now(),
+                          x.iParams[EHuiTransformParamScaleY].Now(),
+                          x.iParams[EHuiTransformParamScaleZ].Now());
+                break;
+
+            case ETypeRotate:
+                aGc.Rotate(aMatrix,
+                           x.iParams[EHuiTransformParamRotateAngle].Now(),
+                           x.iParams[EHuiTransformParamRotateAxisX].Now(),
+                           x.iParams[EHuiTransformParamRotateAxisY].Now(),
+                           x.iParams[EHuiTransformParamRotateAxisZ].Now());
+                break;
+            }
+        }
+    }
+
+
+TBool CHuiTransformation::Changed() const
+    {
+    if(iChanged)
+        {
+        return ETrue;
+        }
+
+    for(TInt i = 0; i < iTransforms.Count(); ++i)
+        {
+        const TTransform& xf = *iTransforms[i];
+        switch(xf.iType)
+            {
+            case ETypeTranslate:
+                if(xf.iParams[EHuiTransformParamTranslateX].Changed() ||
+                   xf.iParams[EHuiTransformParamTranslateY].Changed() ||
+                   xf.iParams[EHuiTransformParamTranslateZ].Changed())
+                    {
+                    return ETrue;
+                    }
+                break;
+
+            case ETypeScale:
+                if(xf.iParams[EHuiTransformParamScaleX].Changed() ||
+                   xf.iParams[EHuiTransformParamScaleY].Changed() ||
+                   xf.iParams[EHuiTransformParamScaleZ].Changed())
+                    {
+                    return ETrue;
+                    }
+                break;
+
+            case ETypeRotate:
+                if(xf.iParams[EHuiTransformParamRotateAngle].Changed() ||
+                   xf.iParams[EHuiTransformParamRotateAxisX].Changed() ||
+                   xf.iParams[EHuiTransformParamRotateAxisY].Changed() ||
+                   xf.iParams[EHuiTransformParamRotateAxisZ].Changed())
+                    {
+                    return ETrue;
+                    }
+                break;
+            }
+        }
+
+    return EFalse;
+    }
+
+
+void CHuiTransformation::ClearChanged()
+    {
+    TInt i = 0;
+    TInt k = 0;
+
+    for(i = 0; i < iTransforms.Count(); ++i)
+        {
+        for(k = 0; k < KHuiTransformParamCount; ++k)
+            {
+            iTransforms[i]->iParams[k].ClearChanged();
+            }
+        }
+
+    iChanged = EFalse;
+    }
+
+const THuiTimedPoint& CHuiTransformation::OriginPoint() const
+    {
+    return iOriginPoint;
+    }