diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/Client/src/alfutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/Client/src/alfutil.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,571 @@ +/* +* 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: Misc. utils +* +*/ + + + +// +// NOTE THAT THIS FILE IS ALMOST IDENTICAL WITH HUIUTIL.CPP ! +// +// HuiUtil.h functions are not called from this file because we want alfclient.dll +// to not have unnecessary (any) static dependencies to core toolkit hitchcock.dll +// (a.k.a huitk.dll, uiaccel.dll,...). There is no other reason to duplicate +// this code. +// + +#include "alf/alfutil.h" +#include "alf/alftimedvalue.h" + +#include +#include +#include + +const TReal32 KLengthUnitDivisor = 320.0; + +/// Character used for separating tags in a tag descriptor. +const TInt KTagSeparator = ':'; + + +// Calculates the smallest power-of-two that is equal to or greater than +// a value. +EXPORT_C TInt AlfUtil::Power2(TInt aValue) + { + ASSERT(aValue>0); + if(aValue<=0) + { + return 0; + } + + TInt i; + for(i = 1; i < aValue && i < KMaxTInt/2; i *= 2) + {} + return i; + } + +EXPORT_C TInt AlfUtil::Power2RoundDown(TInt aValue) + { + ASSERT(aValue>0); + if(aValue <= 0) + { + return 0; + } + + TInt i = 1; + for(; (i * 4 <= aValue) && (i < KMaxTInt/4); i *= 4) + {} + for(; (i * 2 <= aValue) && (i < KMaxTInt/2); i *= 2) + {} + return i; + } + + +EXPORT_C TReal32 AlfUtil::Interpolate(TReal32 aPos, TReal32 aMin, TReal32 aMax) __SOFTFP + { + aPos = Max(0.f, aPos); + aPos = Min(aPos, 1.f); + return (1 - aPos) * aMin + aPos * aMax; + } + + +EXPORT_C void AlfUtil::WrapValue(TReal32& aValue, TReal32 aLow, TReal32 aHigh) __SOFTFP + { + TReal32 segments = 0; + TReal32 length = aHigh - aLow; + + if(length <= 0) + { + aValue = aLow; + return; + } + + if(aValue < aLow) + { + // Wrap from below. + segments = (aLow - aValue) / length; + aValue += (TInt(segments) + 1) * length; + } + else if(aValue >= aHigh) + { + // Wrap from above. + segments = (aValue - aHigh) / length; + aValue -= (TInt(segments) + 1) * length; + } + else + { + // for PC lint + } + } + + +EXPORT_C TInt AlfUtil::RandomInt(TInt aMin, TInt aMax) + { + TUint32 random = Math::Random(); + TUint range = aMax - aMin; + if(range > 0) + { + return aMin + (random % (range + 1)); + } + else + { + return aMin; + } + } + + +EXPORT_C TReal32 AlfUtil::RandomReal(TReal32 aMin, TReal32 aMax) __SOFTFP + { + /** @todo Could use Math::FRand(). */ + TReal32 random = RandomInt(0, 10000000) / 10000000.0; + return aMin + (aMax - aMin) * random; + } + + +EXPORT_C TUint AlfUtil::FreeMemory(TUint* aTotalMemory) + { + TInt total = 0; + TInt free = 0; + + HAL::Get(HALData::EMemoryRAM, total); + HAL::Get(HALData::EMemoryRAMFree, free); + if(aTotalMemory) + { + *aTotalMemory = total; + } + return free; + } + + +EXPORT_C TSize AlfUtil::ScreenSize() + { + TSize screenSize(320, 240); + + AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EScreen, screenSize); + + return screenSize; + } + + +EXPORT_C CFont* AlfUtil::NearestFontInTwipsL(const TFontSpec& aFontSpec) + { + /// @todo Accessing the screen device during a display resizing event may + /// result in a font that is suitable for the display size that + /// was in use prior to the resize. Probably we should use + /// AknLayoutUtils here. + + CFont* font = NULL; + CWsScreenDevice* screenDev = CCoeEnv::Static()->ScreenDevice(); + User::LeaveIfError( screenDev->GetNearestFontInTwips(font, aFontSpec) ); + return font; + } + + +EXPORT_C void AlfUtil::ReleaseFont(CFont* aFont) + { + CCoeEnv::Static()->ScreenDevice()->ReleaseFont(aFont); + } + + +EXPORT_C TReal32 AlfUtil::LengthUnit() __SOFTFP + { + return Max(ScreenSize().iWidth, ScreenSize().iHeight) / KLengthUnitDivisor; + } + + +EXPORT_C TReal32 AlfUtil::QuickLength(TAlfRealPoint& aVector) __SOFTFP + { + TReal32 dx = Abs(aVector.iX); + TReal32 dy = Abs(aVector.iY); + if(dx < dy) + { + return dx + dy - dx/2; + } + else + { + return dx + dy - dy/2; + } + } + + +EXPORT_C TReal32 AlfUtil::QuickLength(TReal32 aDx, TReal32 aDy) __SOFTFP + { + TReal32 dx = Abs(aDx); + TReal32 dy = Abs(aDy); + if(dx < dy) + { + return dx + dy - dx/2; + } + else + { + return dx + dy - dy/2; + } + } + + +EXPORT_C void AlfUtil::QuickNormalize(TAlfRealPoint& aNormal) + { + TReal32 approxLength = QuickLength(aNormal); + + if(approxLength > 0) + { + aNormal.iX /= approxLength; + aNormal.iY /= approxLength; + } + } + + +EXPORT_C void AlfUtil::QuickNormalize(TReal32 aVector[3]) __SOFTFP + { + TReal32 approxLength = QuickLength(QuickLength(aVector[0], aVector[1]), aVector[2]); + + if(approxLength > 0) + { + aVector[0] /= approxLength; + aVector[1] /= approxLength; + aVector[2] /= approxLength; + } + } + + +EXPORT_C void AlfUtil::CrossProduct(const TReal32 aA[3], const TReal32 aB[3], + TReal32 aProduct[3]) __SOFTFP + { + aProduct[0] = aA[1] * aB[2] - aB[1] * aA[2]; + aProduct[1] = aA[2] * aB[0] - aB[2] * aA[0]; + aProduct[2] = aA[0] * aB[1] - aB[0] * aA[1]; + } + + +EXPORT_C void AlfUtil::NormalFromPoints(const TReal32 aPoints[3][3], TReal32 aNormal[3]) __SOFTFP + { + TReal32 vectors[2][3]; + TInt i; + + for(i = 0; i < 3; ++i) + { + vectors[0][i] = aPoints[0][i] - aPoints[1][i]; + vectors[1][i] = aPoints[0][i] - aPoints[2][i]; + } + + CrossProduct(vectors[0], vectors[1], aNormal); + QuickNormalize(aNormal); + } + + +EXPORT_C void AlfUtil::ShadowMatrix(const TReal32 aPlanePoint[3], + const TReal32 aPlaneNormal[3], + const TReal32 aLightPos[4], + TReal32 aDestMat[16]) __SOFTFP + { + TReal32 planeCoeff[4]; + TReal32 dot; + + // Find the plane equation coefficients + // Find the first three coefficients the same way we find a normal. + //NormalFromPoints(aPoints, planeCoeff); + + planeCoeff[0] = aPlaneNormal[0]; + planeCoeff[1] = aPlaneNormal[1]; + planeCoeff[2] = aPlaneNormal[2]; + + // Find the last coefficient by back substitutions + planeCoeff[3] = - ((planeCoeff[0] * aPlanePoint[0]) + (planeCoeff[1] * aPlanePoint[1]) + + (planeCoeff[2] * aPlanePoint[2])); + + // Dot product of plane and light position + dot = planeCoeff[0] * aLightPos[0] + planeCoeff[1] * aLightPos[1] + + planeCoeff[2] * aLightPos[2] + planeCoeff[3] * aLightPos[3]; + + // Now do the projection + // First column + aDestMat[0] = dot - aLightPos[0] * planeCoeff[0]; + aDestMat[4] = 0.0f - aLightPos[0] * planeCoeff[1]; + aDestMat[8] = 0.0f - aLightPos[0] * planeCoeff[2]; + aDestMat[12] = 0.0f - aLightPos[0] * planeCoeff[3]; + + // Second column + aDestMat[1] = 0.0f - aLightPos[1] * planeCoeff[0]; + aDestMat[5] = dot - aLightPos[1] * planeCoeff[1]; + aDestMat[9] = 0.0f - aLightPos[1] * planeCoeff[2]; + aDestMat[13] = 0.0f - aLightPos[1] * planeCoeff[3]; + + // Third Column + aDestMat[2] = 0.0f - aLightPos[2] * planeCoeff[0]; + aDestMat[6] = 0.0f - aLightPos[2] * planeCoeff[1]; + aDestMat[10] = dot - aLightPos[2] * planeCoeff[2]; + aDestMat[14] = 0.0f - aLightPos[2] * planeCoeff[3]; + + // Fourth Column + aDestMat[3] = 0.0f - aLightPos[3] * planeCoeff[0]; + aDestMat[7] = 0.0f - aLightPos[3] * planeCoeff[1]; + aDestMat[11] = 0.0f - aLightPos[3] * planeCoeff[2]; + aDestMat[15] = dot - aLightPos[3] * planeCoeff[3]; + } + + +EXPORT_C TReal32 AlfUtil::ColorLightness(const TRgb& aColor) __SOFTFP + { + TReal32 red = aColor.Red() / 255.0f; + TReal32 green = aColor.Red() / 255.0f; + TReal32 blue = aColor.Red() / 255.0f; + + return (red*2 + green*3 + blue) / 6.f; + } + +EXPORT_C void AlfUtil::ScaleFbsBitmapL(const CFbsBitmap & aSrcBitmap, + CFbsBitmap & aScaledBitmap) + { + CFbsDevice* targetdevice = NULL; + CFbsBitGc* gc = NULL; + // create device for drawing onto the target cropped bitmap area + targetdevice = CFbsBitmapDevice::NewL(&aScaledBitmap); + CleanupStack::PushL(targetdevice); + // create graphics context for drawing + User::LeaveIfError(targetdevice->CreateContext(gc)); + // Perform downscale using DrawBitmap + gc->DrawBitmap(TRect(TPoint(0,0), aScaledBitmap.SizeInPixels()), + (const CFbsBitmap *)&aSrcBitmap); + delete gc; + CleanupStack::PopAndDestroy(targetdevice); + } + +EXPORT_C void AlfUtil::CombineMaskFbsBitmapL(const CFbsBitmap & aSrcBitmap, + const CFbsBitmap & aSrcMaskBitmap, + CFbsBitmap & aCombinedBitmap) + { + + ASSERT(aCombinedBitmap.DisplayMode() == EColor16MA); + ASSERT(aSrcMaskBitmap.DisplayMode() == EGray2 || aSrcMaskBitmap.DisplayMode() == EGray256 || aSrcMaskBitmap.DisplayMode() == EGray16 || aSrcMaskBitmap.DisplayMode() == EGray4); + // Resize the target bitmap if needed + if (aSrcBitmap.SizeInPixels() != aCombinedBitmap.SizeInPixels()) + { + aCombinedBitmap.Resize(aSrcBitmap.SizeInPixels()); + } + + // Alternative method to blend manually (SLOW!!): + // Apply the alpha mask. + TBitmapUtil color((CFbsBitmap*)&aSrcBitmap); + TBitmapUtil alpha((CFbsBitmap*)&aSrcMaskBitmap); + TBitmapUtil target((CFbsBitmap*)&aCombinedBitmap); + color.Begin(TPoint(0, 0)); + alpha.Begin(TPoint(0, 0)); + target.Begin(TPoint(0, 0)); + TSize size(aCombinedBitmap.SizeInPixels()); + for(TInt y = 0; y < size.iHeight; ++y) + { + alpha.SetPos(TPoint(0, y)); + color.SetPos(TPoint(0, y)); + target.SetPos(TPoint(0, y)); + for(TInt x = 0; x < size.iWidth; ++x) + { + target.SetPixel((color.GetPixel() & 0xffffff) + | ((alpha.GetPixel() & 0xff) << 24)); + target.IncXPos(); + color.IncXPos(); + alpha.IncXPos(); + } + } + target.End(); + color.End(); + alpha.End(); + + } + +EXPORT_C void AlfUtil::CropFbsBitmapL(const CFbsBitmap & aSrcBitmap, + CFbsBitmap & aCroppedBitmap, + TPoint aCropPosition) + { + CFbsDevice* targetdevice; + CFbsBitGc* gc; + // create device for drawing onto the target cropped bitmap area + targetdevice = CFbsBitmapDevice::NewL(&aCroppedBitmap); + CleanupStack::PushL(targetdevice); + // create graphics context for drawing + User::LeaveIfError(targetdevice->CreateContext(gc)); + // Perform cropping bitblit + gc->BitBlt(TPoint(0,0), &aSrcBitmap, + TRect(aCropPosition, aCroppedBitmap.SizeInPixels())); + delete gc; + CleanupStack::PopAndDestroy(targetdevice); + } + +EXPORT_C void AlfUtil::ScaleImage(TInt aComponents, + const TSize& aSrcSize, + const TUint8* aSrcBuffer, + const TSize& aDestSize, + TUint8* aDestBuffer) + { + // TODO: if there is actual use for this routine, + // there might be better minification filters than bilinear... + // anyway, now this routine produced acceptable results + // when magnifying also... + ASSERT (aDestBuffer && aSrcBuffer); + ASSERT (aSrcSize.iWidth > 0 && aSrcSize.iHeight > 0); + ASSERT (aDestSize.iWidth > 0 && aDestSize.iHeight > 0); + ASSERT (aComponents > 0 && aComponents < 5); + + TUint32 xScale = ((aSrcSize.iWidth-1) << 16) / aDestSize.iWidth; + TUint32 yScale = ((aSrcSize.iHeight-1) << 16) / aDestSize.iHeight; + TUint32 height = aDestSize.iHeight; + TUint8* srcptr = const_cast(aSrcBuffer); + TUint8* destPtrLimit = aDestBuffer+(aDestSize.iWidth*aComponents); + TUint32 y = yScale&0xffff; + do + { + TUint32 fV = y&0xffff; + TUint32 x = xScale&0xffff; + while(aDestBuffer < destPtrLimit) + { + + TUint32 fU = x&0xffff; + for (TInt components = 0; components < aComponents; components++) + { + TUint32 componenta = srcptr[((x>>16)*aComponents)+components]; + TUint32 componentb = srcptr[((x>>16)*aComponents)+aComponents+components]; + TUint32 componentc = srcptr[((x>>16)*aComponents)+(aSrcSize.iWidth*aComponents)+components]; + TUint32 componentd = srcptr[((x>>16)*aComponents)+(aSrcSize.iWidth*aComponents)+aComponents+components]; + + TUint32 componentf1 = (componenta+(((fU*((componentb-componenta)))>>16))) & 0xff; + TUint32 componentf2 = (componentc+(((fU*((componentd-componentc)))>>16))) & 0xff; + TUint32 finalcomponent = (componentf1+(((fV*((componentf2-componentf1)))>>16))) & 0xff; + *aDestBuffer++ = (TUint8)finalcomponent; + } + x+=xScale; + } + y+=yScale; + srcptr = const_cast(aSrcBuffer)+((y>>16)*(aSrcSize.iWidth*aComponents)); + destPtrLimit+=aDestSize.iWidth*aComponents; + } + while (--height); + } + +EXPORT_C void AlfUtil::CropImage(TInt aComponents, + const TSize& aSrcBufferSize, + const TUint8* aSrcBuffer, + const TPoint& aCropOffset, + const TSize& aCroppedSize, + TUint8* aDestBuffer) + { + ASSERT (aDestBuffer && aSrcBuffer); + ASSERT (aSrcBufferSize.iWidth > 0 && aSrcBufferSize.iHeight > 0); + ASSERT (aCroppedSize.iWidth > 0 && aCroppedSize.iHeight > 0); + ASSERT (aCropOffset.iX < aSrcBufferSize.iWidth); + ASSERT (aCropOffset.iY < aSrcBufferSize.iHeight); + ASSERT (aComponents > 0 && aComponents < 5); + + TInt targetlinesize = aCroppedSize.iWidth*aComponents; + TInt sourcelinesize = aSrcBufferSize.iWidth*aComponents; + for (TInt y=0; yCreate( aBitmap.SizeInPixels(), aDisplaymode ); + + // Create bitmap device for target rendering + CFbsBitmapDevice* targetDevice = CFbsBitmapDevice::NewL( targetBitmap ); + CleanupStack::PushL( targetDevice ); + + // Create bitmap graphics context + CFbsBitGc* bitgc = CFbsBitGc::NewL(); + CleanupStack::PushL( bitgc ); + bitgc->Activate( targetDevice ); + + // BitBlt the given bitmap to target device. + bitgc->BitBlt( TPoint( 0, 0 ), &aBitmap ); + + CleanupStack::PopAndDestroy( bitgc ); + CleanupStack::PopAndDestroy( targetDevice ); + + return targetBitmap; + } + + +EXPORT_C TBool AlfUtil::TagMatches(const TDesC8& aTagsColonSeparated, const TDesC8& aTag) + { + TPtrC8 region = aTagsColonSeparated; + TPtrC8 tag; + TInt index = 0; + + if(!aTag.Length()) + { + // No tag specified; doesn't match anything. + return EFalse; + } + + while(region.Length() > 0) + { + // Is there a colon in the region? + index = region.Locate(TChar(KTagSeparator)); + if(index != KErrNotFound) + { + // A separator exists in the region. + tag.Set(region.Left(index)); + region.Set(region.Right(region.Length() - index - 1)); + } + else + { + tag.Set(region); + region.Set(region.Right(0)); + } + + if(!tag.Compare(aTag)) + { + // Matches. + return ETrue; + } + } + + // No match could be found. + return EFalse; + } + + +void AlfUtil::Assert(TBool aCondition) + { + // Assert that the passed condition is true. + if (aCondition == EFalse) + { + // You can breakpoint here to trap asserts. + ASSERT(EFalse); + } + } + + +TInt AlfUtil::RoundFloatToInt(TReal32 aVal) + { + return (aVal < 0 ? (TInt)(aVal - 0.5f) : (TInt)(aVal + 0.5f)); + } + +// --------------------------------------------------------------------------- +// DEPRECATED: Gets the Avkon Skin TAknsItemID based on string version +// --------------------------------------------------------------------------- +// +EXPORT_C TAknsItemID AlfUtil::ThemeItemIdL( CAlfEnv& /*aEnv*/, const TDesC& /*aSkinId*/) + { + return KAknsIIDNone; + }