diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/sbit/BITMAPDV.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/bitgdi/sbit/BITMAPDV.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,392 @@ +// Copyright (c) 1997-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: +// + +#include +#include +#include +#include +#include "BITPANIC.H" + +const TInt KMaxPixelSize = KMaxTInt / 4; // Maximum pixel size to avoid some overflow problems + +CFbsBitmapDevice::CFbsBitmapDevice(): + CFbsDevice() + {} + + +/** Frees all resources owned by the object prior to its destruction. */ +EXPORT_C CFbsBitmapDevice::~CFbsBitmapDevice() + { + delete iFbsBmp; + } + + +/** Constructs the object from the specified Font and Bitmap server +managed bitmap. + +@param aFbsBitmap A pointer to a Font and Bitmap server managed bitmap. +@param aLibname Name of the library to create the low-level CFbsDrawDevice +object from. +@return A pointer to the newly constructed graphics device. */ +EXPORT_C CFbsBitmapDevice* CFbsBitmapDevice::NewL(CFbsBitmap* aFbsBitmap, + const TDesC& /*aLibname*/) + { + return CFbsBitmapDevice::NewL(aFbsBitmap); + } + +/** Allocates and constructs the device with the bitmap. Also creates a 2D graphics +accelerator which is owned and used by the device. + +@param aFbsBitmap A pointer to the font and bitmap server managed bitmap. +@leave KErrArgument The bitmap's handle is zero. +@leave KErrAccessDenied The bitmap is in the ROM. +@return A pointer to the newly constructed device. +@panic EBitgdiPanicInvalidBitmap aFbsBitmap is NULL. */ +EXPORT_C CFbsBitmapDevice* CFbsBitmapDevice::NewL(CFbsBitmap* aFbsBitmap) + { + BG_ASSERT_ALWAYS(aFbsBitmap != NULL,EBitgdiPanicInvalidBitmap); + + CFbsBitmapDevice* self = new(ELeave) CFbsBitmapDevice; + CleanupStack::PushL(self); + self->ConstructL(aFbsBitmap); + CleanupStack::Pop(); // self + return self; + } + +void CFbsBitmapDevice::ConstructL(CFbsBitmap* aFbsBitmap) + { + if(!aFbsBitmap->Handle()) + User::Leave(KErrArgument); + if(aFbsBitmap->IsRomBitmap()) + User::Leave(KErrAccessDenied); + + iTypefaceStore = CFbsTypefaceStore::NewL(this); + iFbsBmp = new(ELeave) CFbsBitGcBitmap; + User::LeaveIfError(iFbsBmp->Duplicate(aFbsBitmap->Handle())); + const TDisplayMode dispMode = iFbsBmp->DisplayMode(); + + iDrawDevice = CFbsDrawDevice::NewBitmapDeviceL(iFbsBmp->SizeInPixels(), dispMode, iFbsBmp->DataStride()); + + TInt hwHandle = aFbsBitmap->HardwareBitmapHandle(); + if(hwHandle) + { + TRAP_IGNORE(iGraphicsAccelerator = CHardwareGraphicsAccelerator::NewL(RHardwareBitmap(hwHandle))); + } + if (iGraphicsAccelerator==NULL) + { + TRAP_IGNORE(iGraphicsAccelerator = CSoftwareGraphicsAccelerator::NewL(iFbsBmp)); + } + } + +/** Resizes the device. + +@param aSize The new size in pixels. +@return KErrNone, if successful; otherwise another of the system-wide error +codes. */ +EXPORT_C TInt CFbsBitmapDevice::Resize(const TSize& aSize) + { + if(!iDrawDevice || !iFbsBmp) + return(KErrGeneral); + + if(aSize.iWidth < 0 || aSize.iHeight < 0) + return KErrArgument; + + if (aSize.iWidth > KMaxPixelSize || aSize.iHeight > KMaxPixelSize) + return KErrTooBig; + + if (iFbsBmp->HardwareBitmapHandle()) + { + return KErrNotSupported; + } + + const TDisplayMode dispMode = iFbsBmp->DisplayMode(); + CFbsDrawDevice* drawDevice = NULL; + TRAPD(err, drawDevice = CFbsDrawDevice::NewBitmapDeviceL(aSize, dispMode, CFbsBitmap::ScanLineLength(aSize.iWidth, dispMode))); + if (err != KErrNone) + return err; + + TInt ret = iFbsBmp->Resize(aSize); + if (ret != KErrNone) + { + delete drawDevice; + return ret; + } + + delete iDrawDevice; + drawDevice->SetBits(NULL); + iDrawDevice = drawDevice; + iOrientation = CFbsBitGc::EGraphicsOrientationNormal; + + // Now get a new GraphicsAccelerator but it doesn't matter if we fail, we can work without one + delete iGraphicsAccelerator; + iGraphicsAccelerator = NULL; + TRAP_IGNORE(iGraphicsAccelerator = CSoftwareGraphicsAccelerator::NewL(iFbsBmp)); + return KErrNone; + } + +/** +This method is called when you are about to start direct drawing to the bitmap memory. +Calls to DrawingBegin() must be paired with a subsequent call to DrawingEnd(). +Also, code must not leave between a DrawingBegin() - DrawingEnd() pair. +@param aAlways Not used. + +@see CFbsBitmapDevice::DrawingEnd() +*/ +EXPORT_C void CFbsBitmapDevice::DrawingBegin(TBool /*aAlways*/) + { + iFbsBmp->BeginDataAccess(); + SetBits(); + } + +/** +This method is called when you have finished direct drawing to the bitmap memory. +Calls to DrawingEnd() must correspond to a prior call to DrawingBegin(). +@param aAlways Not used. + +@see CFbsBitmapDevice::DrawingBegin() +*/ +EXPORT_C void CFbsBitmapDevice::DrawingEnd(TBool /*aAlways*/) + { + iDrawDevice->SetBits(NULL); + iFbsBmp->EndDataAccess(EFalse); + } + +void CFbsBitmapDevice::SetBits() + { +#ifdef _DEBUG + // Bitmap devices only support normal orientation + TInt devHeight = iDrawDevice->SizeInPixels().iHeight; + MScalingSettings* scaling; + if (iDrawDevice->GetInterface(KScalingSettingsInterfaceID, (TAny*&)scaling) == KErrNone) + { + TInt factorX, factorY, divisorX, divisorY; + scaling->Get(factorX, factorY, divisorX, divisorY); + // Both divisorX and divisorY should be 1 + if (factorY > 1) + { + devHeight = (devHeight - 1) * factorY + 1; + } + } +#endif + BG_ASSERT_DEBUG(iFbsBmp->DataStride() == iDrawDevice->ScanLineBytes(), EBitgdiPanicInvalidBitmap); + BG_ASSERT_DEBUG(iFbsBmp->SizeInPixels().iHeight >= devHeight, EBitgdiPanicInvalidBitmap); + TUint32* data = iFbsBmp->DataAddress(); + BG_ASSERT_ALWAYS(data, EBitgdiPanicInvalidBitmap); + iDrawDevice->SetBits(data); + } + + +/** Copies a scanline into a buffer. + +The function provides a concrete implementation of the pure virtual +function CBitmapDevice::GetScanLine(). */ +EXPORT_C void CFbsBitmapDevice::GetScanLine(TDes8& aBuf, + const TPoint& aPixel, + TInt aLength, + TDisplayMode aDispMode) const + { + iFbsBmp->BeginDataAccess(); + CONST_CAST(CFbsBitmapDevice*,this)->SetBits(); + CONST_CAST(CFbsBitmapDevice*,this)->DoGetScanLine(aBuf,aPixel,aLength,aDispMode); + iFbsBmp->EndDataAccess(ETrue); + } + +/** Gets the RGB colour of an individual pixel on a bitmapped graphics +device. + +The function provides a concrete implementation of the pure virtual +function CBitmapDevice::GetPixel(). */ +EXPORT_C void CFbsBitmapDevice::GetPixel(TRgb& aColor,const TPoint& aPoint) const + { + TRect deviceRect; + iDrawDevice->GetDrawRect(deviceRect); + if (!deviceRect.Contains(aPoint)) + return; + + iFbsBmp->BeginDataAccess(); + ((CFbsBitmapDevice*)this)->SetBits(); + aColor = iDrawDevice->ReadPixel(aPoint.iX,aPoint.iY); + iFbsBmp->EndDataAccess(ETrue); + } + + +/** Converts a horizontal dimension of a device in pixels to a horizontal +dimension in twips. + +The function provides a concrete implementation of the pure virtual +function MGraphicsDeviceMap::HorizontalPixelsToTwips(). */ +EXPORT_C TInt CFbsBitmapDevice::HorizontalPixelsToTwips(TInt aPixels) const + { + return iFbsBmp->HorizontalPixelsToTwips(aPixels); + } + + +/** Converts a vertical dimension of a device in pixels to a vertical +dimension in twips. + +The function provides a concrete implementation of the pure virtual +function MGraphicsDeviceMap::VerticalPixelsToTwips(). */ +EXPORT_C TInt CFbsBitmapDevice::VerticalPixelsToTwips(TInt aPixels) const + { + return iFbsBmp->VerticalPixelsToTwips(aPixels); + } + + +/** Gets the size of the device, in twips. + +@return The size of the device. */ +EXPORT_C TSize CFbsBitmapDevice::SizeInTwips() const + { + return iFbsBmp->SizeInTwips(); + } + +/** Converts a horizontal dimension of a device in twips to a horizontal +dimension in pixels. + +The function provides a concrete implementation of the pure virtual +function MGraphicsDeviceMap::HorizontalTwipsToPixels(). */ +EXPORT_C TInt CFbsBitmapDevice::HorizontalTwipsToPixels(TInt aTwips) const + { + return iFbsBmp->HorizontalTwipsToPixels(aTwips); + } + + +/** Converts a vertical dimension of a device in twips to a vertical +dimension in pixels. + +The function provides a concrete implementation of the pure virtual +function MGraphicsDeviceMap::VerticalTwipsToPixels(). */ +EXPORT_C TInt CFbsBitmapDevice::VerticalTwipsToPixels(TInt aTwips) const + { + return iFbsBmp->VerticalTwipsToPixels(aTwips); + } + + +/** Gets the palette attributes of the device. + +The function provides a concrete implementation of the pure virtual +function CGraphicsDevice::PaletteAttributes(). */ +EXPORT_C void CFbsBitmapDevice::PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const + { + aModifiable = (iDrawDevice->DisplayMode() == EColor256); + aNumEntries = TDisplayModeUtils::NumDisplayModeColors(iDrawDevice->DisplayMode()); + } + +/** Sets the device's palette to the specified palette. + +Setting the palette is only possible if the device has a modifiable palette, +which can be determined by calling PaletteAttributes(). + +The function provides a concrete implementation of the pure virtual +function CGraphicsDevice::SetPalette(). */ +EXPORT_C void CFbsBitmapDevice::SetPalette(CPalette* aPalette) + { + SetCustomPalette(aPalette); // Have to ignore error for compatibility + } + + +/** Gets the device's current palette. + +This function is only supported if the device has a modifiable palette, +which can be determined by calling PaletteAttributes(). + +The function provides a concrete implementation of the pure virtual +function CGraphicsDevice::GetPalette(). */ +EXPORT_C TInt CFbsBitmapDevice::GetPalette(CPalette*& aPalette) const + { + return iDrawDevice->GetCustomPalette(aPalette); + } + +/** +The method swaps bitmap device's width and height. +For example: if the size is (40, 20), the swapped size will be (20, 40). +The device's content is not preserved. +The method leaves CFbsBitmapDevice object in a consistent state - +scaling settings will be set with their default values (the scaling is switched off), +the device's dither origin will be set to (0,0), scaling origin to (0,0). + +Note: If the device was scaled or its dither origin was set with a non-default value, +it has to be rescaled again, respectivelly the dither origin has to be set again. + +Note: All graphics contexts, already created by the device, should be +re-activated calling CFbsBitGc::Activate(). + +Note: Do not call SwapWidthAndHeight() between DrawingBegin() and DrawingEnd() calls! + +@return KErrNone The call was successfull. +@return KErrAccessDenied ROM bitmap size can't be swapped. +@return KErrNotSupported Hardware bitmap size can't be swapped. +@return KErrGeneral iDrawDevice or iFbsBmp is NULL. +*/ +EXPORT_C TInt CFbsBitmapDevice::SwapWidthAndHeight() + { + if(!iDrawDevice || !iFbsBmp) + { + return KErrGeneral; + } + TInt err = iFbsBmp->SwapWidthAndHeight(); + if(err == KErrNone) + { + iDrawDevice->SwapWidthAndHeight(); + } + return err; + } + + +/** + Required to ensure BC between NGage and 7.0S platforms. + Functions are exported at ordinal corresponding to where NGage platform + has extended this library and must not be moved. + */ +EXPORT_C void DummyReserved1() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved2() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved3() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved4() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved5() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved6() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved7() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved8() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved9() + { + User::Panic(_L("Dummy Function"), 0); + } +EXPORT_C void DummyReserved10() + { + User::Panic(_L("Dummy Function"), 0); + }