diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/sbit/SCREENDV.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/bitgdi/sbit/SCREENDV.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,601 @@ +// 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 +#include +#include +#include +#include "BITPANIC.H" +#include +#include + + +#if defined(SYMBIAN_GRAPHICS_GCE) +#include +#endif + +/** +@param aScreenNo The screen number. If the device has a support for only one screen, its + number is 0. +*/ +CFbsScreenDevice::CFbsScreenDevice(TInt aScreenNo): + CFbsDevice(), + iScreenNo(aScreenNo) + { + } + + +/** Creates a new CFbsScreenDevice object. + +@param aLibname Not used. +@param aDispMode The display mode of the device. +@return The newly created FBSERV screen device. */ +EXPORT_C CFbsScreenDevice* CFbsScreenDevice::NewL(const TDesC& /*aLibname*/, + TDisplayMode aDispMode) + { + return CFbsScreenDevice::NewL(KDefaultScreenNo, aDispMode); + } + +/** Creates a new CFbsScreenDevice object. + +@param aLibname Not used. +@param aDispMode The display mode of the device. +@param aWhite Not used. +@return The newly created font and bitmap server screen device. +@deprecated Use two param version instead. */ +EXPORT_C CFbsScreenDevice* CFbsScreenDevice::NewL(const TDesC& /*aLibname*/, + TDisplayMode aDispMode, + TRgb /*aWhite*/) + { + return CFbsScreenDevice::NewL(KDefaultScreenNo, aDispMode); + } + +/** +Creates a new CFbsScreenDevice object. +@param aScreenNo The screen number. If the device has a support for only one screen, its + number is 0. +@param aDispMode The display mode of the device. +@return The newly created FBSERV screen device. +*/ +EXPORT_C CFbsScreenDevice* CFbsScreenDevice::NewL(TInt aScreenNo, TDisplayMode aDispMode) + { + CFbsScreenDevice* self = new (ELeave) CFbsScreenDevice(aScreenNo); + CleanupStack::PushL(self); + self->ConstructL(aScreenNo, aDispMode); + CleanupStack::Pop(); // self + return self; + } + +/** Frees all resources owned by the object prior to its destruction. */ +EXPORT_C CFbsScreenDevice::~CFbsScreenDevice() + { + } + +void CFbsScreenDevice::ConstructL(TInt aScreenNo, TDisplayMode aDispMode) + { + iDrawDevice = CFbsDrawDevice::NewScreenDeviceL(aScreenNo, aDispMode); + iScreenDevice = ETrue; + iTypefaceStore = CFbsTypefaceStore::NewL(this); + if(aDispMode != EGray4) // Flicker-free blitting not enabled under EGray4 because it messes up the EGray16-emulating dithering + { + TInt scanLineBytes = iDrawDevice->ScanLineBytes(); + const TSize screenSize = SizeInPixels(); + if(screenSize.iHeight > screenSize.iWidth) + { + scanLineBytes = scanLineBytes * screenSize.iHeight / screenSize.iWidth; + } + iBitBltMaskedBuffer = new(ELeave) TUint8[scanLineBytes * 2]; + } + } + + +/** Copies a scanline into a buffer. + +This implements the pure virtual function +CBitmapDevice::GetScanLine(). */ +EXPORT_C void CFbsScreenDevice::GetScanLine(TDes8& aBuf,const TPoint& aStartPixel, + TInt aLength,TDisplayMode aDispMode) const + { + if (!iDrawDevice) + return; + + ((CFbsScreenDevice*)this)->DoGetScanLine(aBuf,aStartPixel,aLength,aDispMode); + } + + +/** Gets the RGB colour of an individual pixel on a bitmapped graphics +device. + +This implements the pure virtual function +CBitmapDevice::GetPixel(). */ +EXPORT_C void CFbsScreenDevice::GetPixel(TRgb& aColor,const TPoint& aPoint) const + { + if (!iDrawDevice) + return; + + TRect deviceRect; + iDrawDevice->GetDrawRect(deviceRect); + if (!deviceRect.Contains(aPoint)) + return; + + aColor = iDrawDevice->ReadPixel(aPoint.iX,aPoint.iY); + } + + +/** Converts a horizontal dimension from pixels to twips. + +This implements the pure virtual function +MGraphicsDeviceMap::HorizontalPixelsToTwips(). */ +EXPORT_C TInt CFbsScreenDevice::HorizontalPixelsToTwips(TInt aPixels) const + { + TInt64 pixels=aPixels; + pixels=(iDrawDevice->HorzTwipsPerThousandPixels() * pixels + 500) / 1000; + return I64INT(pixels); + } + + +/** Converts a vertical dimension from pixels to twips. + +This implements the pure virtual function +MGraphicsDeviceMap::VerticalPixelsToTwips(). */ +EXPORT_C TInt CFbsScreenDevice::VerticalPixelsToTwips(TInt aPixels) const + { + TInt64 pixels=aPixels; + pixels=(iDrawDevice->VertTwipsPerThousandPixels() * pixels + 500) / 1000; + return I64INT(pixels); + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. +@deprecated +*/ +EXPORT_C void CFbsScreenDevice::DrawSpriteBegin() + { + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. +@deprecated +*/ +EXPORT_C void CFbsScreenDevice::DrawSpriteEnd() + { + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. + +@return NULL. +@deprecated +*/ +EXPORT_C TSpriteBase* CFbsScreenDevice::HideSprite() const + { + return NULL; + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. + +@param aRect Ignored. +@param aClippingRegion Ignored. +@return NULL. +@deprecated +*/ +EXPORT_C TSpriteBase* CFbsScreenDevice::HideSprite(const TRect& /*aRect*/, + const TRegion* /*aClippingRegion*/) const + { + return NULL; + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. + +@param aSprite Ignored. +@deprecated +*/ +EXPORT_C void CFbsScreenDevice::ShowSprite(TSpriteBase* /*aSprite*/) const + { + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. + +@param aSprite Ignored. +@param aRect Ignored. +@param aClippingRegion Ignored. +@deprecated +*/ +EXPORT_C void CFbsScreenDevice::ShowSprite(TSpriteBase* /*aSprite*/,const TRect& /*aRect*/, + const TRegion* /*aClippingRegion*/) const + { + } + + +/** Changes the screen device. + +@param aOldDevice A pointer to the old screen device. */ +EXPORT_C void CFbsScreenDevice::ChangeScreenDevice(CFbsScreenDevice* aOldDevice) + { + if (aOldDevice == NULL) + { + TInt ret = iDrawDevice->InitScreen(); + BG_ASSERT_ALWAYS(ret == KErrNone,EBitgdiPanicInvalidWindowHandle); + } + else + { + delete aOldDevice->iGraphicsAccelerator; + aOldDevice->iGraphicsAccelerator = NULL; + + if (aOldDevice != this) + { + iDrawDevice->SetDisplayMode(aOldDevice->iDrawDevice); + iOrientation = aOldDevice->iOrientation; + } + // else we're re-initialising the existing CFbsScreenDevice's graphics accelerator only + } + + //Check if the screen device is scaled or the origin is moved. + //If it is, then do not create graphics accelerator + //instance, because it does not have support for scaling&origin. + TBool scalingOff = ETrue; + TBool originZero = ETrue; + MScalingSettings* scalingSettings = NULL; + if(iDrawDevice->GetInterface(KScalingSettingsInterfaceID, + reinterpret_cast (scalingSettings)) == KErrNone) + { + BG_ASSERT_DEBUG_INVARIANT(scalingSettings); + scalingOff = scalingSettings->IsScalingOff(); + } + MDrawDeviceOrigin* originInterface = NULL; + if(iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, + reinterpret_cast (originInterface)) == KErrNone) + { + BG_ASSERT_DEBUG_INVARIANT(originInterface); + TPoint origin; + originInterface->Get(origin); + originZero = origin.iX == 0 && origin.iY == 0; + } + if(scalingOff && originZero) + { + RHardwareBitmap screen; + //Some explanations about "-1 - iScreenNo" expression. + //SetAsScreenReference() is a public, exported method with a default argument'value -1. + //In SetAsScreenReference()'s implementation before "Multiple screens" source code update, + //"-1" value meant - this is a screen hardware bitmap. Positive value meant - + //in-memory hardware bitmap. + //After "Multiple screens" update, the meaning of SetAsScreenReference()'s argument is: + // - Positive value - in-memory hardware bitmap; + // - Negative value - screen number: "-1" - screen 0, "-2" - screen 1, "-3" - screen 2, ...; + if(screen.SetAsScreenReference(-1 - iScreenNo)==KErrNone) + { + TRAP_IGNORE(iGraphicsAccelerator = CHardwareGraphicsAccelerator::NewL(screen)); + } + } + } + + +/** Gets the palette attributes of the device. + +@param aModifiable On return, holds information on whether or not the device +palette is modifiable (ETrue) or fixed (EFalse). +@param aNumEntries On return, holds the number of entries in the device +palette. */ +EXPORT_C void CFbsScreenDevice::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(). + +@param aPalette The new palette for the device. */ +EXPORT_C void CFbsScreenDevice::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(). + +@param aPalette On return, holds the devices current palette. +@return KErrNone, if successful; otherwise, another of the system-wide error +codes. */ +EXPORT_C TInt CFbsScreenDevice::GetPalette(CPalette*& aPalette) const + { + return iDrawDevice->GetCustomPalette(aPalette); + } + + +/** +This method has been deprecated. Sprites are no longer supported in BitGDI. +Calling this method has no effect. +@deprecated +*/ +EXPORT_C void CFbsScreenDevice::CancelSprite() const + { + } + + +/** Sets or unsets auto-update for the screen. + +@param aValue ETrue, if the screen is set to auto-update; EFalse, otherwise. */ +EXPORT_C void CFbsScreenDevice::SetAutoUpdate(TBool aValue) + { + iDrawDevice->SetAutoUpdate(aValue); + } + + +/** Forces any out of date region of the screen to update. */ +EXPORT_C void CFbsScreenDevice::Update() + { + iDrawDevice->Update(); + } + + +/** Forces any out of date region of the screen to update, +and additionally forces the specified region to update. + +@param aRegion The region of the screen to update, in addition +to any out of date region. */ +EXPORT_C void CFbsScreenDevice::Update(const TRegion& aRegion) + { + iDrawDevice->Update(aRegion); + } + + +/** Gets the size of the device area, in twips. + +This implements the pure virtual function CGraphicsDevice::SizeInTwips(). + +@see CGraphicsDevice::SizeInTwips() */ +EXPORT_C TSize CFbsScreenDevice::SizeInTwips() const + { + TSize twipssize; + twipssize.iWidth = HorizontalPixelsToTwips(iDrawDevice->SizeInPixels().iWidth); + twipssize.iHeight = VerticalPixelsToTwips(iDrawDevice->SizeInPixels().iHeight); + return twipssize; + } + + +/** Converts a horizontal dimension from twips to pixels. + +This implements the pure virtual function +MGraphicsDeviceMap::HorizontalTwipsToPixels(). */ +EXPORT_C TInt CFbsScreenDevice::HorizontalTwipsToPixels(TInt aTwips) const + { + const TInt htptp = iDrawDevice->HorzTwipsPerThousandPixels(); + TInt64 twips = aTwips; + twips = (1000 * twips + (htptp >> 1)) / htptp; + return I64INT(twips); + } + + +/** Converts a vertical dimension from twips to pixels. + +This implements the pure virtual function +MGraphicsDeviceMap::VerticalTwipsToPixels(). */ +EXPORT_C TInt CFbsScreenDevice::VerticalTwipsToPixels(TInt aTwips) const + { + const TInt vtptp = iDrawDevice->VertTwipsPerThousandPixels(); + TInt64 twips = aTwips; + twips = (1000 * twips + (vtptp >> 1)) / vtptp; + return I64INT(twips); + } + + +/** Creates and returns a hardware bitmap (a bitmap which can be drawn to by a +graphics accelerator whose operations may be implemented in hardware or software), +whose handle is to the screen. + +This allows the caller to draw to the screen like any other hardware bitmap. + +This function may not be supported on all hardware. If unsupported, it returns +an RHardwareBitmap with a handle of zero. + +The hardware bitmap can be used to draw directly to the screen. Use it to +create a TAcceleratedBitmapSpec object, which can either be used to get a +TAcceleratedBitmapInfo, or can be passed to a graphics operation (an instance +of a class derived from class TGraphicsOperation) e.g. a bitblt to copy one +part of the screen to another. + +Direct screen access must only be carried out in combination with the Window +Server's direct screen access classes; i.e. only use the hardware bitmap on +the CFbsScreenDevice which you get from CDirectScreenAccess, and not from +your own CFbsScreenDevice. + +@return A hardware bitmap whose handle is to the screen. +@see TAcceleratedBitmapSpec +@see TGraphicsOperation +@see CGraphicsAccelerator::Operation() +@see CDirectScreenAccess */ +EXPORT_C RHardwareBitmap CFbsScreenDevice::HardwareBitmap() + { + RHardwareBitmap hwb; + //Some explanations about "-1 - iScreenNo" expression. + //SetAsScreenReference() is a public, exported method with a default argument'value -1. + //In SetAsScreenReference()'s implementation before "Multiple screens" source code update, + //"-1" value meant - this is a screen hardware bitmap. Positive value meant - + //in-memory hardware bitmap. + //After "Multiple screens" update, the meaning of SetAsScreenReference()'s argument is: + // - Positive value - in-memory hardware bitmap; + // - Negative value - screen number: "-1" - screen 0, "-2" - screen 1, "-3" - screen 2, ...; + hwb.SetAsScreenReference(-1 - iScreenNo); + return hwb; + } + +/** Returns pointer to the location of first pixel in frame buffer. Not necessarily the same as pointer +to frame buffer. + +@return Pointer to the location of first pixel or NULL if it is not accessible. +@internalComponent +*/ +EXPORT_C const TUint32* CFbsScreenDevice::Bits() const + { + TAny* interface = NULL; + TInt ret = iDrawDevice->GetInterface(KFastBlit2InterfaceID, interface); + if (ret != KErrNone) + return NULL; + + return reinterpret_cast(interface)->Bits(); + } + +/** Returns frame buffer line pitch or stride. + +@return Frame buffer stride. +@internalComponent +*/ +EXPORT_C TInt CFbsScreenDevice::Stride() const + { + return iDrawDevice->ScanLineBytes(); + } + +/** Query the screen number to which the object refers. + +@return Screen number as passed in aScreenNo to NewL. +@publishedAll +@released +*/ +EXPORT_C TInt CFbsScreenDevice::ScreenNo() const + { + return iScreenNo; + } + +/** Get the surface identifier for the current device orientation of the screen. +If screen device doesn't support providing a surface, the caller is panicked. + +@param aSurface Set to the surface identifier for the screen buffer. +@internalTechnology +@prototype +*/ +EXPORT_C void CFbsScreenDevice::GetSurface(TSurfaceId& aSurface) const + { +#if defined(SYMBIAN_GRAPHICS_GCE) + TAny* interface = NULL; + TInt ret = iDrawDevice->GetInterface(KSurfaceInterfaceID, interface); + if (ret == KErrNone) + { + reinterpret_cast(interface)->GetSurface(aSurface); + return; + } +#endif + (void)aSurface; // Satisfies the compiler, if its a Non-GCE build. + Panic(EBitgdiPanicInvalidScreenDeviceLibrary); + } + +/** This function is used to request the device orientations supported by the +screen device. + +@return A bitwise combination of one or more TDeviceOrientation enumerated +values indicating the device orientations that are supported by this device. +@internalTechnology +@prototype +*/ +EXPORT_C TUint CFbsScreenDevice::DeviceOrientationsAvailable() const + { +#if defined(SYMBIAN_GRAPHICS_GCE) + TAny* interface = NULL; + TInt ret = iDrawDevice->GetInterface(KSurfaceInterfaceID, interface); + if (ret == KErrNone) + return reinterpret_cast(interface)->DeviceOrientationsAvailable(); +#endif + Panic(EBitgdiPanicInvalidScreenDeviceLibrary); + return 0; // Make the compiler happy. + } + +/** This function selects the surface and device buffer to use in the screen +driver for this screen. Normal and 180° rotations will generally use the same +surface, while 90° and 270° will use another. The surfaces may have different +width, height, stride and surface, so functions that make use of any of these +may be affected after a change in surface orientation, and the return value +should be checked for this reason. + +This call does not change the way rendering is performed, but may operate on +the underlying memory using a new shape. The call does not change the display +controller’s settings, as this is handled via the GCE. All this changes are the +internal attributes of the screen device and driver objects. A CFbsBitGc object +activated on the device should be reactivated, to update its own attributes, or +drawing may be corrupted. + +Note: while TDeviceOrientation values do not directly correspond to +CFbsBitGc::TGraphicsOrientation values, and cannot be used interchangeably, it +is simple to generate the former from the latter using the left-shift operator +(i.e. device == (1 << graphics)). In particular a device orientation of 90 +degrees clockwise is equivalent to a content orientation of 90 degrees anti- +clockwise, which is what TGraphicsOrientation refers to for the equivalent +setting. The letters "CW" in the TDeviceOrientation enumeration refer to a +clockwise device rotation, so EDeviceOrientation90CW is a 90 degree clockwise +rotation of the device. + +@param aOrientation The new device orientation, relative to the normal physical +screen orientation. +@return ETrue is returned if any of the surface, width, height or stride +attributes of the screen device have changed as a result of the call or EFalse +if none of the attributes have changed. +@internalTechnology +@prototype +*/ +EXPORT_C TBool CFbsScreenDevice::SetDeviceOrientation(TDeviceOrientation aOrientation) const + { +#if defined(SYMBIAN_GRAPHICS_GCE) + TAny* interface = NULL; + TInt ret = iDrawDevice->GetInterface(KSurfaceInterfaceID, interface); + if (ret == KErrNone) + return reinterpret_cast(interface)->SetDeviceOrientation(aOrientation); +#endif + (void)aOrientation; // Satisfies the compiler, if its a Non-GCE build. + Panic(EBitgdiPanicInvalidScreenDeviceLibrary); + return EFalse; // Make the compiler happy. + } + +/** This function is used to request the current device orientation. + +@return One of the TDeviceOrientation enumerated values. +@internalTechnology +@prototype +*/ +EXPORT_C TDeviceOrientation CFbsScreenDevice::DeviceOrientation() const + { +#if defined(SYMBIAN_GRAPHICS_GCE) + TAny* interface = NULL; + TInt ret = iDrawDevice->GetInterface(KSurfaceInterfaceID, interface); + if (ret == KErrNone) + return reinterpret_cast(interface)->DeviceOrientation(); +#endif + Panic(EBitgdiPanicInvalidScreenDeviceLibrary); + return EDeviceOrientationNormal; // Make the compiler happy. + } +