--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tdynamicres/src/surfaceutility.cpp Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1544 @@
+// Copyright (c) 2007-2009 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:
+//
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <imageconversion.h>
+#include "surfaceutility.h"
+
+CSurfaceUtility::CSurfaceUtility(CSurfaceUtility* aClone/*=NULL*/)
+ : iSurfaces(aClone?&(aClone->iSurfaces):NULL)
+ {
+ }
+
+CSurfaceUtility* CSurfaceUtility::NewL(CSurfaceUtility* aClone/*=NULL*/)
+ {
+ CSurfaceUtility* utility = new (ELeave)CSurfaceUtility(aClone);
+ CleanupStack::PushL(utility);
+ utility->ConstructL();
+ CleanupStack::Pop(utility);
+ return utility;
+ }
+
+void CSurfaceUtility::ConstructL()
+ {
+ TInt r = iManager.Open();
+ if (r != KErrNone)
+ {
+ LOG(("Surface manager failed to open: %d", r));
+ User::Leave(r);
+ }
+
+ r = iSurfaceUpdateSession.Connect();
+ if (r != KErrNone)
+ {
+ LOG(("Failed to connect to update server: %d", r));
+ User::Leave(r);
+ }
+ }
+
+CSurfaceUtility::~CSurfaceUtility()
+ {
+ DestroyAll();
+
+ iSurfaces.Close();
+
+ iManager.Close();
+
+ iSurfaceUpdateSession.Close();
+ }
+
+TBool CSurfaceUtility::DestroyAll()
+ {
+ TInt err = KErrNone;
+ TInt jj = iSurfaces.Count() - 1;
+ if (jj<0)
+ return EFalse;
+ for (; jj >= 0; jj--)
+ {
+ err = iManager.CloseSurface(iSurfaces[jj]);
+ if (err!=KErrNone)
+ {
+ LOG(("Error closing surface: 0x%X\n", err));
+ }
+ }
+ iSurfaces.Reset();
+ return ETrue;
+ }
+
+/***************************************
+ * The aim of the THeapSurfaceArray is to locally switch in the specified heap for any array operation
+ ***************************************/
+
+CSurfaceUtility::RHeapSurfaceArray::RHeapSurfaceArray(RHeapSurfaceArray* aUseExternalArray)
+ : iUseArray(aUseExternalArray?aUseExternalArray->iUseArray:&this->iLocalArray),
+ iExternalHeapRef(aUseExternalArray?aUseExternalArray->iExternalHeapRef:User::Heap())
+ {
+
+ }
+/************************************
+ * The following methods have been used by the surfaceutility... some require the heap wrapping, and some don't
+ * I actually need three different startegies (count em) for 7 methods...
+ * Some methods only read the existing objects, so don't need a heap swap at all
+ * Leaving methods have to use PopAndDestroy strategy to restore the heap on leaving or success
+ * Non-leaving methods must not call PushL, so directly make SwitchHeap calls!
+ ************************************/
+
+// PopAndDestroy method to restore the heap
+/*static*/ void CSurfaceUtility::RHeapSurfaceArray::PopHeap(void* aHeapPtr)
+ {
+ RHeap* heapPtr=(RHeap*)aHeapPtr;
+ User::SwitchHeap(heapPtr);
+ }
+
+// Switches and pushes the previous heap so it can be restored with PopAndDestroy
+/*static*/ void CSurfaceUtility::RHeapSurfaceArray::SwitchHeapLC(RHeap* aNewHeap)
+ {
+ CleanupStack::PushL(TCleanupItem(PopHeap,NULL));
+ CleanupStack::PushL(TCleanupItem(PopHeap,NULL));
+ CleanupStack::PushL(TCleanupItem(PopHeap,NULL));
+ CleanupStack::Pop(3);
+ RHeap* oldHeap=User::SwitchHeap(aNewHeap);
+ delete new char;
+ CleanupStack::PushL(TCleanupItem(PopHeap,oldHeap));
+ }
+
+
+TSurfaceId& CSurfaceUtility::RHeapSurfaceArray::operator[](TUint aIndex)
+ {
+ return iUseArray->operator[](aIndex);
+ }
+// Close only closes the local array, while Reset resets the active array (may be external)
+void CSurfaceUtility::RHeapSurfaceArray::Close()
+ {
+ RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);
+ iLocalArray.Close();
+ User::SwitchHeap(oldHeap);
+ }
+TInt CSurfaceUtility::RHeapSurfaceArray::Count() const
+ {
+ return iUseArray->Count();
+ }
+// Close only closes the local array, while Reset resets the active array (may be external)
+inline void CSurfaceUtility::RHeapSurfaceArray::Reset()
+ {
+ RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);
+ iUseArray->Reset();
+ User::SwitchHeap(oldHeap);
+ }
+void CSurfaceUtility::RHeapSurfaceArray::AppendL(const TSurfaceId &anEntry)
+ {
+ SwitchHeapLC(&iExternalHeapRef);
+ iUseArray->AppendL(anEntry);
+ CleanupStack::PopAndDestroy();
+ }
+TInt CSurfaceUtility::RHeapSurfaceArray::Find(const TSurfaceId &anEntry) const
+ {
+ return iUseArray->Find(anEntry);
+ }
+void CSurfaceUtility::RHeapSurfaceArray::Remove(TInt anIndex)
+ {
+ RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);
+ iUseArray->Remove(anIndex);
+ User::SwitchHeap(oldHeap);
+ }
+
+
+
+
+/**
+Cleanup stack helper object, holding references to both utility and surface, so
+that the standard Close() semantics can be used.
+*/
+class TSurfaceCleanup
+ {
+public:
+ TSurfaceCleanup(CSurfaceUtility& aUtility, TSurfaceId& aSurface)
+ : iUtility(aUtility), iSurface(aSurface)
+ {}
+ void Close()
+ {
+ // Removes the surface from the list of surfaces to clean up, and closes
+ // the surface reference.
+ iUtility.DestroySurface(iSurface);
+ }
+private:
+ CSurfaceUtility& iUtility;
+ TSurfaceId& iSurface;
+ };
+
+/**
+Read the given image file into a new surface.
+
+@param aFileName The name of the image file.
+@param aSurface Filled with the surface ID for the surface containing the pixels.
+*/
+void CSurfaceUtility::CreateSurfaceFromFileL(const TDesC& aFileName, TSurfaceId& aSurface)
+ {
+ RFs fs;
+
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ CImageDecoder* decoder = CImageDecoder::FileNewL(fs, aFileName, CImageDecoder::EOptionAlwaysThread);
+ CleanupStack::PushL(decoder);
+
+ const TFrameInfo& info = decoder->FrameInfo();
+
+ TSize size = info.iOverallSizeInPixels;
+ TInt stride = size.iWidth << 2; // Default to four bytes per pixel
+ TDisplayMode bmpFormat = info.iFrameDisplayMode;
+ TUidPixelFormat pixelFormat = EUidPixelFormatUnknown;
+
+ switch (bmpFormat)
+ {
+ case EGray2:
+ case EGray4:
+ case EGray16:
+ case EGray256:
+ case EColor16:
+ case EColor256:
+ case EColor16M:
+ case EColor16MU:
+ {
+ bmpFormat = EColor16MU;
+ pixelFormat = EUidPixelFormatXRGB_8888;
+ break;
+ }
+ case EColor4K:
+ {
+ stride = size.iWidth << 1;
+ pixelFormat = EUidPixelFormatXRGB_4444;
+ break;
+ }
+ case EColor64K:
+ {
+ stride = size.iWidth << 1;
+ pixelFormat = EUidPixelFormatRGB_565;
+ break;
+ }
+ case EColor16MA:
+ {
+ pixelFormat = EUidPixelFormatARGB_8888;
+ break;
+ }
+ case EColor16MAP:
+ {
+ pixelFormat = EUidPixelFormatARGB_8888_PRE;
+ break;
+ }
+ default:
+ {
+ LOG(("Unsupported display mode: %d", bmpFormat));
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+ // Create an intermediary bitmap for decoding into
+ CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(bitmap);
+ User::LeaveIfError(bitmap->Create(size, info.iFrameDisplayMode));
+
+ // Create the final surface.
+ aSurface = CreateSurfaceL(size, pixelFormat, stride);
+ TSurfaceCleanup surfaceCleanup(*this, aSurface);
+ CleanupClosePushL(surfaceCleanup);
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ // Convert the image file into a Symbian bitmap
+ TRequestStatus status;
+ decoder->Convert(&status, *bitmap);
+ User::WaitForRequest(status);
+ User::LeaveIfError(status.Int());
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+
+ // Copy the data from the bitmap into the surface.
+ TPoint start;
+ TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
+ for (start.iY = 0; start.iY < size.iHeight; start.iY++)
+ {
+ // Set up a descriptor for the current line in the surface and get pixels.
+ TPtr8 ptr(pSurfStart + start.iY * stride, stride);
+ bitmap->GetScanLine(ptr, start, size.iWidth, bmpFormat);
+ }
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ CleanupStack::Pop(/* surfaceCleanup */);
+ CleanupStack::PopAndDestroy(bitmap);
+ CleanupStack::PopAndDestroy(decoder);
+ CleanupStack::PopAndDestroy(/* fs */);
+ }
+
+void CSurfaceUtility::CopyBitmapSurfaceL(const CFbsBitmap* aBitmap, TSurfaceId& aSurface)
+ {
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+ TSize bitmapSize = aBitmap->SizeInPixels();
+ TSize size = SurfaceSize(aSurface);
+ TInt stride = size.iWidth*4; // Default to four bytes per pixel
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+
+ // Copy the data from the bitmap into the surface.
+ TPoint start;
+ TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
+ for (start.iY = 0; start.iY < bitmapSize.iHeight; start.iY++)
+ {
+ // Set up a descriptor for the current line in the surface and get pixels.
+ TPtr8 ptr(pSurfStart + start.iY * stride, stride);
+ aBitmap->GetScanLine(ptr, start, bitmapSize.iWidth, EColor16MU);
+ }
+ CleanupStack::PopAndDestroy(/* chunk */);
+
+ }
+/**
+Copy the bitmap from a file to a surface.
+
+@param aFileName The name of the image file.
+@param aSurface Filled with the surface ID for the surface containing the pixels.
+*/
+void CSurfaceUtility::CopyBitmapFromFileToSurfaceL(const TDesC& aFileName, TSurfaceId& aSurface)
+ {
+ RFs fs;
+
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ CImageDecoder* decoder = CImageDecoder::FileNewL(fs, aFileName, CImageDecoder::EOptionAlwaysThread);
+ CleanupStack::PushL(decoder);
+
+ const TFrameInfo& info = decoder->FrameInfo();
+
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& infoSurf = infoBuf();
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+
+ TSize size = infoSurf.iSize;
+ TDisplayMode bmpFormat = info.iFrameDisplayMode;
+ TInt stride = size.iWidth << 2; // Default to four bytes per pixel
+
+ // Create an intermediary bitmap for decoding into
+ CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(bitmap);
+ User::LeaveIfError(bitmap->Create(size, info.iFrameDisplayMode));
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ // Convert the image file into a Symbian bitmap
+ TRequestStatus status;
+ decoder->Convert(&status, *bitmap);
+ User::WaitForRequest(status);
+ User::LeaveIfError(status.Int());
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+
+ // Copy the data from the bitmap into the surface.
+ TPoint start;
+ TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
+ for (start.iY = 0; start.iY < size.iHeight; start.iY++)
+ {
+ // Set up a descriptor for the current line in the surface and get pixels.
+ TPtr8 ptr(pSurfStart + start.iY * stride, stride);
+ bitmap->GetScanLine(ptr, start, size.iWidth, bmpFormat);
+ }
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ CleanupStack::PopAndDestroy(bitmap);
+ CleanupStack::PopAndDestroy(decoder);
+ CleanupStack::PopAndDestroy(/* fs */);
+ }
+/**
+Get the size of a surface.
+
+@param aSurface The surface to get the size for.
+@return The size in pixels, or empty on failure.
+*/
+TSize CSurfaceUtility::SurfaceSize(const TSurfaceId& aSurface)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ if (iManager.SurfaceInfo(aSurface, infoBuf) == KErrNone)
+ {
+ return info.iSize;
+ }
+
+ return TSize();
+ }
+
+
+/**
+Create a surface using the surface manager.
+
+Stores the ID for tear down, as well as returning it.
+
+@param aSize Dimensions of the surface.
+@param aPixelFormat UID of the pixel format.
+@param aStride Stride value for the surface (usually bytes per pixel * width)
+@leave May leave due to lack of memory.
+@return New surface's ID.
+*/
+TSurfaceId CSurfaceUtility::CreateSurfaceL(const TSize& aSize, TUidPixelFormat aPixelFormat, TInt aStride, TInt aBuffers)
+ {
+ RSurfaceManager::TSurfaceCreationAttributesBuf bf;
+ RSurfaceManager::TSurfaceCreationAttributes& b = bf();
+
+ b.iSize.iWidth = aSize.iWidth;
+ b.iSize.iHeight = aSize.iHeight;
+ b.iBuffers = aBuffers; // number of buffers in the surface
+ b.iPixelFormat = aPixelFormat;
+ b.iStride = aStride; // Number of bytes between start of one line and start of next
+ b.iOffsetToFirstBuffer = 0; // way of reserving space before the surface pixel data
+ b.iAlignment = 4; // alignment, 1,2,4,8 byte aligned
+ b.iContiguous = EFalse;
+ b.iMappable = ETrue;
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+
+ User::LeaveIfError(iManager.CreateSurface(bf, surface));
+ iSurfaces.AppendL(surface);
+ return surface;
+ }
+
+/**
+A helper function that returns the bytes per pixel for a given pixel format uid
+
+@param aPixelFormat Pixel format UID to convert
+@return The bytes per pixel
+*/
+TInt CSurfaceUtility::BytesPerPixelL(TUidPixelFormat aPixelFormat)
+ {
+ TInt bytesPerPixel = 0;
+ switch (aPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ case EUidPixelFormatARGB_8888:
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ bytesPerPixel = 4;
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ case EUidPixelFormatRGB_565:
+ {
+ bytesPerPixel = 2;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+ return bytesPerPixel;
+ }
+
+/**
+Fill the given surface with a color.
+
+@param aSurface The surface to be filled.
+@param aColor The color to fill it with.
+*/
+void CSurfaceUtility::FillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 color = 0;
+ TBool use16 = EFalse;
+
+ if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)
+ {
+ User::Leave(KErrNotReady);
+ }
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ color = aColor.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ color |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ color = aColor.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ color = aColor.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ color = aColor.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ color = aColor.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+ TUint8* linePtr = surfacePtr;
+
+ if (use16)
+ {
+ if ( info.iSize.iWidth*2>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);
+
+ // Fill first line
+ for (TInt xx = 0; xx < info.iSize.iWidth; xx++)
+ {
+ ptr[xx] = (TUint16)color;
+ }
+ }
+ else
+ {
+ if ( info.iSize.iWidth*4>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);
+
+ // Fill first line
+ for (TInt xx = 0; xx < info.iSize.iWidth; xx++)
+ {
+ ptr[xx] = color;
+ }
+ }
+
+ // Now copy that to the other lines
+ for (TInt yy = 1; yy < info.iSize.iHeight; yy++)
+ {
+ linePtr += info.iStride;
+ Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
+ }
+
+ TInt err = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+ if (err!=KErrNone)
+ LOG(("Error submitting update: 0x%X\n", err));
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ }
+
+/**
+Fill the given memory chunk with a color.
+
+@param aSurface The surface to be filled.
+@param aChunk The surface to be filled.
+@param aColor The color to fill it with.
+*/
+void CSurfaceUtility::FillChunkL(TSurfaceId& aSurface, RChunk& aChunk, const TRgb& aColor, TInt aBufferNumber)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 color = 0;
+ TBool use16 = EFalse;
+
+ if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)
+ {
+ User::Leave(KErrNotReady);
+ }
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ color = aColor.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ color |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ color = aColor.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ color = aColor.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ color = aColor.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ color = aColor.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+ User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TInt offsetToBufferNumber;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBufferNumber, offsetToBufferNumber));
+
+ TUint8* chunkPtr = aChunk.Base() + offsetToFirstBuffer;
+ TUint8* linePtr = aChunk.Base() + offsetToBufferNumber;
+ TUint8* surfPlanePtr = linePtr;
+
+ if (use16)
+ {
+ if ( info.iSize.iWidth*2>info.iStride)
+ {
+ aChunk.Close();
+ User::Leave(KErrOverflow);
+ }
+ TUint16* ptr = reinterpret_cast<TUint16*>(surfPlanePtr);
+
+ // Fill first line
+ for (TInt xx = 0; xx < info.iSize.iWidth; xx++)
+ {
+ ptr[xx] = (TUint16)color;
+ }
+ }
+ else
+ {
+ if ( info.iSize.iWidth*4>info.iStride)
+ {
+ aChunk.Close();
+ User::Leave(KErrOverflow);
+ }
+ TUint32* ptr = reinterpret_cast<TUint32*>(surfPlanePtr);
+
+ // Fill first line
+ for (TInt xx = 0; xx < info.iSize.iWidth; xx++)
+ {
+ ptr[xx] = color;
+ }
+ }
+
+ // Now copy that to the other lines
+ for (TInt yy = 1; yy < info.iSize.iHeight; yy++)
+ {
+ linePtr += info.iStride;
+ Mem::Copy(linePtr, surfPlanePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
+ }
+
+ aChunk.Close();
+ }
+
+/**
+Fill a rectangle on the given surface.
+
+@param aSurface The surface to be filled.
+@param aStartPos Where to place the rectangle.
+@param aSize Size of the rectangle.
+@param aColor The colour to fill it with.
+*/
+void CSurfaceUtility::FillRectangleL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)
+ {
+ FillRectangleNoUpdateL(aSurface, aStartPos, aSize, aColor);
+
+ TInt err = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+ if (err!=KErrNone)
+ LOG(("Error submitting update: 0x%X\n", err));
+ }
+
+/**
+Fill a rectangle on the given surface - does not submit update.
+
+@param aSurface The surface to be filled.
+@param aStartPos Where to place the rectangle.
+@param aSize Size of the rectangle.
+@param aColor The colour to fill it with.
+*/
+void CSurfaceUtility::FillRectangleNoUpdateL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 color = 0;
+ TBool use16 = EFalse;
+
+ if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)
+ {
+ User::Leave(KErrNotReady);
+ }
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ color = aColor.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ color |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ color = aColor.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ color = aColor.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ color = aColor.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ color = aColor.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+
+ // Check for out of bounds
+ TBool validRect = ETrue;
+ TInt surfaceWidth = info.iSize.iWidth;
+ TInt surfaceHeight = info.iSize.iHeight;
+
+ // Width and Height
+ if ((aStartPos.iX + aSize.iWidth) > surfaceWidth)
+ validRect = EFalse;
+
+ if ((aStartPos.iY + aSize.iHeight) > surfaceHeight)
+ validRect = EFalse;
+
+ // Starting position
+ if ((aStartPos.iX < 0) || (aStartPos.iY < 0))
+ validRect = EFalse;
+
+ if (!validRect)
+ User::Leave(KErrOverflow);
+
+ if (use16)
+ {
+ if ( info.iSize.iWidth*2>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+
+ TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);
+
+ // Fill the rectangle
+ TInt yPos = aStartPos.iY;
+ TInt xPos = aStartPos.iX;
+ for (TInt yy = 0; yy < aSize.iHeight; ++yy)
+ {
+ ptr = reinterpret_cast<TUint16*>(surfacePtr+(yPos*info.iStride));
+ for (TInt xx = 0; xx < aSize.iWidth; ++xx)
+ {
+ ptr[xPos] = color;
+ xPos++;
+ }
+ xPos = aStartPos.iX;
+ yPos++;
+ }
+ }
+ else
+ {
+ if ( info.iSize.iWidth*4>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+
+ TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);
+
+ // Fill the rectangle
+ TInt yPos = aStartPos.iY;
+ TInt xPos = aStartPos.iX;
+ for (TInt yy = 0; yy < aSize.iHeight; ++yy)
+ {
+ ptr = reinterpret_cast<TUint32*>(surfacePtr+(yPos*info.iStride));
+ for (TInt xx = 0; xx < aSize.iWidth; ++xx)
+ {
+ ptr[xPos] = color;
+ xPos++;
+ }
+ xPos = aStartPos.iX;
+ yPos++;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ }
+
+/**
+Fill the given surface with a grid over a solid color.
+
+Similar to FillSurfaceL(), but with a grid overlayed. The pitch of the grid is
+eight pixels.
+
+@param aSurface The surface to be filled.
+@param aColor The color to fill it with.
+@param aLines The color of the grid lines.
+*/
+void CSurfaceUtility::GridFillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor, const TRgb& aLines)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 color = 0;
+ TUint32 lines = 0;
+ TBool use16 = EFalse;
+
+ if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)
+ {
+ User::Leave(KErrNotReady);
+ }
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ color = aColor.Color16MU();
+ lines = aLines.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ color |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+ lines |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ color = aColor.Color16MA();
+ lines = aLines.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ color = aColor.Color16MAP();
+ lines = aLines.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ color = aColor.Color4K();
+ lines = aLines.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ color = aColor.Color64K();
+ lines = aLines.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+ TUint8* linePtr = surfacePtr;
+
+ if (use16)
+ {
+ if ( info.iSize.iWidth*2>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);
+
+ // Fill first line
+ for (TInt xx1 = 0; xx1 < info.iSize.iWidth; xx1++)
+ {
+ ptr[xx1] = (TUint16)lines;
+ }
+
+ // Fill second line
+ ptr = reinterpret_cast<TUint16*>(surfacePtr + info.iStride);
+ for (TInt xx2 = 0; xx2 < info.iSize.iWidth; xx2++)
+ {
+ // Vertical line every 8 pixels across
+ ptr[xx2] = (TUint16)((xx2 & 7) ? color : lines);
+ }
+ }
+ else
+ {
+ if ( info.iSize.iWidth*4>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);
+
+ // Fill first line
+ for (TInt xx3 = 0; xx3 < info.iSize.iWidth; xx3++)
+ {
+ ptr[xx3] = lines;
+ }
+
+ // Fill second line
+ ptr = reinterpret_cast<TUint32*>(surfacePtr + info.iStride);
+ for (TInt xx4 = 0; xx4 < info.iSize.iWidth; xx4++)
+ {
+ // Vertical line every 8 pixels across
+ ptr[xx4] = (xx4 & 7) ? color : lines;
+ }
+ }
+ linePtr += info.iStride;
+
+ // Now copy that to the other lines
+ for (TInt yy = 2; yy < info.iSize.iHeight; yy++)
+ {
+ linePtr += info.iStride;
+ if (yy & 7)
+ {
+ // Copy second line
+ Mem::Copy(linePtr, surfacePtr + info.iStride, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
+ }
+ else
+ {
+ // Copy first line
+ Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
+ }
+ }
+
+ TInt err =iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+ if (err!=KErrNone)
+ LOG(("Error submitting update: 0x%X\n", err));
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ }
+
+
+/**
+Fill the given surface with a pattern suitable for automated testing.
+
+@param aSurface The surface to be filled.
+*/
+void CSurfaceUtility::PatternFillSurfaceL(TSurfaceId& aSurface)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+
+ // Fill the background
+ FillSurfaceL(aSurface, TRgb(0x00000000));
+
+ TInt surfaceWidth = info.iSize.iWidth;
+ TInt surfaceHeight = info.iSize.iHeight;
+
+ // Create the 4 rectangles in the corners
+ TPoint startPos(0,0);
+ TSize size(15,15);
+ TInt rectWidth = size.iWidth;
+ TInt rectHeight = size.iHeight;
+ // Top left
+ FillRectangleL(aSurface, startPos, size, TRgb(0x0000ff));
+
+ // Top right
+ startPos.iX = surfaceWidth - rectWidth;
+ startPos.iY = 0;
+ FillRectangleL(aSurface, startPos, size, TRgb(0x00ff00));
+
+ // Bottom left
+ startPos.iX = 0;
+ startPos.iY = surfaceHeight - rectHeight;
+ FillRectangleL(aSurface, startPos, size, TRgb(0x00ffff));
+
+ // Bottom right
+ startPos.iX = surfaceWidth - rectWidth;
+ startPos.iY = surfaceHeight - rectHeight;
+ FillRectangleL(aSurface, startPos, size, TRgb(0xffffff));
+
+ // Create the 4 side bars
+ startPos.iX = 0;
+ startPos.iY = 6;
+ size.iWidth = 5;
+ size.iHeight = surfaceHeight - 12;
+ // Left
+ FillRectangleL(aSurface, startPos, size, TRgb(0x808000));
+
+ startPos.iX = surfaceWidth - size.iWidth;
+ startPos.iY = 6;
+ // Right
+ FillRectangleL(aSurface, startPos, size, TRgb(0xff00ff));
+
+ startPos.iX = 6;
+ startPos.iY = surfaceHeight - size.iWidth;
+ size.iWidth = surfaceWidth - 12;
+ size.iHeight = 5;
+ // Top
+ FillRectangleL(aSurface, startPos, size, TRgb(0xaaaaaa));
+
+ startPos.iX = 6;
+ startPos.iY = 0;
+ // Bottom
+ FillRectangleL(aSurface, startPos, size, TRgb(0x000080));
+ }
+
+
+template <class TIntType> void
+DdaLine(TUint aX1, TUint aY1,TUint aX2,TUint aY2, TUint aPixPerScan, TIntType* aBuffer, TIntType aColor)
+ {
+ TInt dx=aX2-aX1;
+ TInt dy=aY2-aY1;
+ TInt adx=dx,sdx=1;
+ if (adx<0)
+ { adx=-adx; sdx=-1; }
+ TInt ady=dy,sdy=aPixPerScan;
+ if (ady<0)
+ { ady=-ady; sdy=-aPixPerScan; }
+ //This is simplistic integert DDA.
+ //The vertical cases are handled by this 1/2 accumulator:
+ // If adx is zero then we step in sdy indefinitely
+ // If ady is zero then we step in sdx indefinitely
+ TInt accum=adx/2;
+
+ TIntType* bufferend=aBuffer+aX2+aY2*aPixPerScan;
+ aBuffer+=aX1+aY1*aPixPerScan;
+ *aBuffer=aColor;
+ while (aBuffer!=bufferend)
+ {
+ if (accum>0)
+ {
+ accum-=ady;
+ aBuffer+=sdx;
+ }
+ else
+ {
+ accum+=adx;
+ aBuffer+=sdy;
+ }
+ *aBuffer=aColor;
+ }
+
+
+ }
+template <class TIntType> void
+FanFill(const TPoint& aInnerXY,TUint aPixPerScan, TIntType* aSurfacePtr, TIntType aLinesTL,
+ TIntType aLinesBR, TIntType aLinesTR, TIntType aLinesBL)
+ {
+
+ DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*180/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*372/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*591/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*859/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
+
+ DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesTR);
+ DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesTR);
+
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX*180/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX*372/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX*591/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX*859/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
+
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesBL);
+ DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesBL);
+
+ DdaLine(0,0,aInnerXY.iX*180/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX*372/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX*591/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX*859/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
+
+ DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesTL);
+ DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesTL);
+
+ DdaLine(0,aInnerXY.iY-aInnerXY.iY*180/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(0,aInnerXY.iY-aInnerXY.iY*372/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(0,aInnerXY.iY-aInnerXY.iY*591/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(0,aInnerXY.iY-aInnerXY.iY*859/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+
+ DdaLine(aInnerXY.iX-aInnerXY.iX*180/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(aInnerXY.iX-aInnerXY.iX*372/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(aInnerXY.iX-aInnerXY.iX*591/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+ DdaLine(aInnerXY.iX-aInnerXY.iX*859/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
+
+ }
+/**
+Fill the given surface with a fan of lines over a solid color.
+
+Similar to FillSurfaceL(), but with a fan of lines overlayed.
+One fan is drawn about the top-left, and second fan at bottom-right.
+The fan contains 8 segments.
+
+@param aSurface The surface to be filled.
+@param aColor The color to fill it with.
+@param aLines The color of the grid lines.
+*/
+void CSurfaceUtility::FanFillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor, const TRgb& aLinesTL, const TRgb& aLinesBR)
+ {
+ FillSurfaceL(aSurface,aColor);
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 linesTL = 0;
+ TUint32 linesBR = 0;
+ TUint32 linesTR = 0;
+ TUint32 linesBL = 0;
+ TBool use16 = EFalse;
+ TRgb rgbLinesTR(0,0,0);
+ TRgb rgbLinesBL(255,255,255);
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ linesBR = aLinesBR.Color16MU();
+ linesTL = aLinesTL.Color16MU();
+ linesTR = rgbLinesTR.Color16MU();
+ linesBL = rgbLinesBL.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ linesBR |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+ linesTL |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+ linesTR |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+ linesBL |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ linesBR = aLinesBR.Color16MA();
+ linesTL = aLinesTL.Color16MA();
+ linesTR = rgbLinesTR.Color16MA();
+ linesBL = rgbLinesBL.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ linesBR = aLinesBR.Color16MAP();
+ linesTL = aLinesTL.Color16MAP();
+ linesTR = rgbLinesTR.Color16MAP();
+ linesBL = rgbLinesBL.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ linesBR = aLinesBR.Color4K();
+ linesTL = aLinesTL.Color4K();
+ linesTR = rgbLinesTR.Color4K();
+ linesBL = rgbLinesBL.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ linesBR = aLinesBR.Color64K();
+ linesTL = aLinesTL.Color64K();
+ linesTR = rgbLinesTR.Color64K();
+ linesBL = rgbLinesBL.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+ if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)
+ {
+ User::Leave(KErrNotReady);
+ }
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+ TPoint innerXY(info.iSize.iWidth-1,info.iSize.iHeight-1);
+ if (use16)
+ {
+ if ( info.iSize.iWidth*2>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ FanFill<TUint16>(innerXY,info.iStride/2,(TUint16*)surfacePtr,linesTL,linesBR,linesBL,linesTR);
+ }
+ else
+ {
+ if ( info.iSize.iWidth*4>info.iStride)
+ {
+ User::Leave(KErrOverflow);
+ }
+ FanFill<TUint>(innerXY,info.iStride/4,(TUint*)surfacePtr,linesTL,linesBR,linesBL,linesTR);
+ }
+
+ iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ }
+/**
+Fill the given surface with vertical line at the given position
+
+Similar to FillSurfaceL(), but with a vertical line overlayed.
+The position along the surface is given as a percentage from the left
+
+@param aSurface The surface to be filled.
+@param aColor The color to fill it with.
+@param aLine The color of the line.
+@param aPosition Position of the vertical line given as a percentage across the surface from the left edge
+*/
+void CSurfaceUtility::LineFillSurfaceL(TSurfaceId& aSurface, const TRgb& aBackColor, const TRgb& aLineColor, TInt aPosition)
+ {
+ if (aPosition<0 || aPosition>100)
+ {
+ aPosition=0;
+ }
+ FillSurfaceL(aSurface,aBackColor);
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TUint32 lineColor = 0;
+ TBool use16 = EFalse;
+
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ lineColor = aLineColor.Color16MU();
+#ifdef ALPHA_FIX_24BIT
+ lineColor |= ((ALPHA_FIX_24BIT)&0xff)<<24;
+#endif
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ lineColor = aLineColor.Color16MA();
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ lineColor = aLineColor.Color16MAP();
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ lineColor = aLineColor.Color4K();
+ use16 = ETrue;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ lineColor = aLineColor.Color64K();
+ use16 = ETrue;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+ if (use16)
+ {
+ DdaLine<TUint16>((info.iSize.iWidth*aPosition)/100,0,(info.iSize.iWidth*aPosition)/100,
+ info.iSize.iHeight-1,info.iStride/2,(TUint16*)surfacePtr,lineColor);
+ }
+ else
+ {
+ DdaLine<TUint>((info.iSize.iWidth*aPosition)/100,0,(info.iSize.iWidth*aPosition)/100,
+ info.iSize.iHeight-1,info.iStride/4,(TUint*)surfacePtr,lineColor);
+ }
+
+ chunk.Close();
+
+ iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+ }
+/**
+ * Generates a bitmap equivalent to the surface.
+ * Can reuse an existing bitmap or create a new bitmap.
+ * The existing bitmap must be an exact match (eg previously generated by this method)
+ **/
+CFbsBitmap* CSurfaceUtility::EquivalentBitmapL(TSurfaceId& aSurface,CFbsBitmap* aCopyToMayBeNull)
+ {
+ RSurfaceManager::TInfoBuf infoBuf;
+ RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
+
+ User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
+ TInt bytesPerPixel=0;
+ TDisplayMode bitmapMode = ENone;
+ switch (info.iPixelFormat)
+ {
+ case EUidPixelFormatXRGB_8888:
+ {
+ bitmapMode = EColor16MU;
+ bytesPerPixel = 4;
+ break;
+ }
+ case EUidPixelFormatARGB_8888:
+ {
+ bitmapMode=EColor16MA;
+ bytesPerPixel = 4;
+ break;
+ }
+ case EUidPixelFormatARGB_8888_PRE:
+ {
+ bitmapMode=EColor16MAP;
+ bytesPerPixel = 4;
+ break;
+ }
+ case EUidPixelFormatXRGB_4444:
+ case EUidPixelFormatARGB_4444:
+ {
+ bitmapMode=EColor4K;
+ bytesPerPixel = 2;
+ break;
+ }
+ case EUidPixelFormatRGB_565:
+ {
+ bitmapMode=EColor64K;
+ bytesPerPixel = 2;
+ break;
+ }
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+ CFbsBitmap* retVal=NULL;
+ if (aCopyToMayBeNull)
+ {
+ retVal=aCopyToMayBeNull;
+ if (retVal->SizeInPixels()!=info.iSize)
+ User::Leave(KErrCorrupt);
+ if (retVal->DisplayMode()!=bitmapMode)
+ User::Leave(KErrCorrupt);
+ }
+ else
+ {
+ retVal=new CFbsBitmap;
+ CleanupStack::PushL(retVal);
+ User::LeaveIfError(retVal->Create(info.iSize,bitmapMode));
+ }
+ RChunk chunk;
+ CleanupClosePushL(chunk);
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+ TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
+ TUint8* bitmapPtr = (TUint8*)retVal->DataAddress();
+ TInt copyBytes=info.iSize.iWidth*bytesPerPixel;
+ for (TInt y=0;y<info.iSize.iHeight;y++)
+ {
+ Mem::Copy(bitmapPtr,surfacePtr,copyBytes);
+ surfacePtr+=info.iStride;
+ bitmapPtr+=retVal->DataStride();
+ }
+ CleanupStack::PopAndDestroy(&chunk);
+ if (!aCopyToMayBeNull)
+ CleanupStack::Pop(retVal);
+ return retVal;
+ }
+
+/**
+Destroy a surface.
+
+As well as destroying the surface, it is removed from the set held for
+destruction during tear down.
+
+@param aSurface The surface to be destroyed.
+*/
+void CSurfaceUtility::DestroySurface(TSurfaceId& aSurface)
+ {
+ TInt index = iSurfaces.Find(aSurface);
+
+ if (index != KErrNotFound)
+ {
+ iSurfaces.Remove(index);
+ }
+
+ TInt err = iManager.CloseSurface(aSurface);
+ if (err!=KErrNone)
+ LOG(("Error closing surfaces: 0x%X\n", err));
+ }
+
+
+/**
+Submit an update to a surface to the update server.
+
+@param aScreenNumber The screen to be updated where the surface is shown.
+@param aSurface The surface which has been updated.
+@param aRegion The area of the surface affected, or NULL for all of it.*/
+void CSurfaceUtility::SubmitUpdate(TInt aScreenNumber, const TSurfaceId& aSurface, const TRegion* aRegion,TInt aBufferNumber)
+ {
+ TInt err =iSurfaceUpdateSession.SubmitUpdate(aScreenNumber, aSurface, aBufferNumber, aRegion);
+ if (err!=KErrNone)
+ LOG(("Error submitting update: 0x%X\n", err));
+ }
+
+/**
+Map and submit an update to a surface to the update server.
+
+@param aChunk The chunk of memory to be mapped
+@param aScreenNumber The screen to be updated where the surface is shown.
+@param aSurface The surface which has been updated.
+@param aRegion The area of the surface affected, or NULL for all of it.*/
+void CSurfaceUtility::MapAndSubmitUpdateL(RChunk& aChunk,
+ TInt aScreenNumber,
+ const TSurfaceId& aSurface,
+ const TRegion* aRegion)
+ {
+ User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
+ aChunk.Close();
+ TInt err =iSurfaceUpdateSession.SubmitUpdate(aScreenNumber, aSurface, 0, aRegion);
+ if (err!=KErrNone)
+ LOG(("Error submitting update: 0x%X\n", err));
+ }
+
+void CSurfaceUtility::MapSurfaceL(const TSurfaceId& aSurface, RChunk& aChunk)
+ {
+ User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
+ }
+
+void CSurfaceUtility::CopyBitmapToSurfaceL(TSurfaceId& aSurface, const CFbsBitmap& aBitmap)
+ {
+ TSize size = SurfaceSize(aSurface);
+
+ TDisplayMode bmpFormat = aBitmap.DisplayMode();
+ TInt stride = size.iWidth * 4; // Default to four bytes per pixel
+
+ RChunk chunk;
+ User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
+ CleanupClosePushL(chunk);
+
+ TInt offsetToFirstBuffer;
+ User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
+
+ // Copy the data from the bitmap into the surface.
+ TPoint start;
+ TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
+ for (start.iY = 0; start.iY < size.iHeight; start.iY++)
+ {
+ // Set up a descriptor for the current line in the surface and get pixels.
+ TPtr8 ptr(pSurfStart + start.iY * stride, stride);
+ aBitmap.GetScanLine(ptr, start, size.iWidth, bmpFormat);
+ }
+
+ TInt err =iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
+ if (err!=KErrNone)
+ {
+ LOG(("Error submitting update: 0x%X\n", err));
+ }
+
+ CleanupStack::PopAndDestroy(/* chunk */);
+ }