diff -r f5050f1da672 -r 04becd199f91 javauis/eswt_akn/org.eclipse.ercp.swt.s60/native/inc/swtimage.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javauis/eswt_akn/org.eclipse.ercp.swt.s60/native/inc/swtimage.h Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,498 @@ +/******************************************************************************* + * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Nokia Corporation - S60 implementation + *******************************************************************************/ +// SwtImage.h + + +#ifndef SWTIMAGE_H +#define SWTIMAGE_H + + +#include "eswtgraphics.h" + + +class CSwtGrPaletteData; + + +/** + * CSwtImage + * C++ implementation of org.eclipse.swt.graphics.Image. + * Due to lack of support for paletted modes in CFbsBitmap ( the API exists + * but is empty implemented ), colour images of bit depths 1, 2, 4 and 8 are + * converted to 24 bits per pixel. This, however, does not affect grayscale + * images. + * @lib eswt + */ +NONSHARABLE_CLASS(CSwtImage) + : public CBase + , public MSwtImage + , public MSwtResourceChangeObserver +{ +// Data types +private: + enum TMaskType + { + ENoMask = 0, // No transparency + EBinaryMask, // Binary transparency + EColorKey, // Colour key: a colour is considered transparent. + EDirtyColorKey, // Same as EColorKey but the mask needs to be regenerated + EAlphaMask // Alpha transparency + }; + +// Own methods +public: + /** + * Two phase constructor. + * @param aDevice graphic device + * @param aSize initial image dimensions + * @param aDisplay parent display + * @param aMode display mode + * @return pointer to blank image + */ + static CSwtImage* NewL(MSwtDevice& aDevice, const TSize& aSize, + MSwtDisplay& aDisplay, TDisplayMode aMode = ENone); + + /** + * Two phase constructor. + * @param aDevice graphic device + * @param aData image data + * @param aDisplay parent display + * @return pointer to image constructed from image data + */ + static CSwtImage* NewL(MSwtDevice* aDevice, const MSwtImageData& aData, + MSwtDisplay* aDisplay); + + /** + * Two phase constructor. + * @param aBitmap source bitmap + * @param aBitmap source mask + * @param aTopLeft initial position + * @param aDelayTime frame delay + * @param aDisposalMethod disposal method of previous frames + * @return pointer to image constructed bitmap + mask + */ + static CSwtImage* NewL(CFbsBitmap& aBitmap, CFbsBitmap* aMask, + const TPoint& aTopLeft, TInt aDelayTime, TSwtGifDisposal aDisposalMethod); + +private: + /** + * First phase constructor. + * @param aDevice graphic device + * @param aDisplay parent display + */ + inline CSwtImage(MSwtDevice* aDevice, MSwtDisplay* aDisplay); + + /** + * Destructor + */ + ~CSwtImage(); + + /** + * Second phase constructor. + * @param aSize initial image dimensions + * @param aMode display mode + */ + void ConstructL(const TSize& aSize, TDisplayMode aMode); + + /** + * Second phase constructor. + * @param aData image data + */ + void ConstructL(const MSwtImageData& aData); + + /** + * Second phase constructor. + * @param aBitmap source bitmap + * @param aBitmap source mask + * @param aTopLeft initial position + * @param aDelayTime frame delay + * @param aDisposalMethod disposal method of previous frames + */ + void ConstructL(CFbsBitmap& aBitmap, CFbsBitmap* aMask, const TPoint& aTopLeft, + TInt aDelayTime, TSwtGifDisposal aDisposalMethod); + + /** + * Color key setter. + * @param aData image data + */ + void SetColorKeyL(const MSwtImageData& aData); + + /** + * Ensures the mask is up to date. This method, although const, may actually + * modify the image's mask but this will only occur if the image's content + * has been modified and the mask wasn't updated at that moment. + */ + void EnsureMaskIsUpToDate() const; + + /** + * Computes the binary mask from the colour key. + */ + void ComputeColorKeyMask(); + + /** + * Tests whether the image is a grayscale one. + */ + TBool IsGrayscale() const; + + /** + * Creates a new palette data object for the image. + */ + CSwtGrPaletteData* GetPaletteDataL() const; + + /** + * Computes the gray mode for the provided palette. + * @return The gray mode suitable for the current palette or ENone if none + * has been found. + */ + static TDisplayMode PaletteGrayMode(TInt aDepth, const CPalette& aPalette); + + /** + * Computes the display mode of the provided data. + * @return The display mode, or ENone if no suitable mode could be found. + */ + static TDisplayMode DisplayMode(const MSwtImageData& aData); + + /** + * Returns the bit depth for the specified display mode. + */ + static TInt BitDepth(TDisplayMode aMode); + + /** + * Returns the image depth bpp according to the bitmap display type. + */ + TInt ImageDepth() const; + + /** + * Returns the scanline padding for the specified bit depth. + */ + static TInt ScanlinePadding(TInt aBitDepth); + + /** + * Computes the number of bytes needed in a line. + */ + static TInt BytesPerLine(TInt aPixelsPerLine, TInt aBitsPerPixel, + TInt aPadding); + + /** + * Fills the provided bitmap with the provided colour. + */ + static void FillBitmapL(CFbsBitmap& aBitmap, const TRgb& aColor, + const TRect& aRect); + + /** + * Bitblt the bitmap with another bitmap. + */ + void BitBltBitmapL(CFbsBitmapDevice& aDevice, const CFbsBitmap& aBitmap); + + + /** + * Fills the provided bitmap with the provided colour. + */ + static void FillBitmapL(CFbsBitmapDevice& aDevice, const TRgb& aColor, + const TRect& aRect); + + /** + * Creates a new palette object for a given gray mode. + */ + static CPalette* NewGrayPaletteL(TDisplayMode aMode); + + /** + * Shifts an integer by a certain number of bits. + * @param aValue The integer whose bits are to be shifted + * @param aShift The number of bits to shift by; a positive value shifts + * to the left, a negative value shifts to the right. + */ + static inline TUint BitShift(TUint aValue, TInt aShift); + + /** + * Extracts the red component of a pixel. The result is a value in [0;255]. + */ + static inline TUint GetRed(TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Extracts the green component of a pixel. The result is a value in [0;255]. + */ + static inline TUint GetGreen(TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Extracts the blue component of a pixel. The result is a value in [0;255]. + */ + static inline TUint GetBlue(TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Extracts the RGB components of a pixel. + */ + static inline TRgb GetRgb(TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Writes a 16-bit pixel in the Symbian format ( [rrrrrggg gggbbbbb] binary ). + * @param aPtr Where to write the pixel, the pointer is modified to point + * after the pixel upon return. + * @param aPixel The pixel to write + * @param aPalette Information about aPixel's format. + */ + static inline void WritePixel16(TUint8*& aPtr, TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Writes a True Color pixel in the Symbian format ( BGR ). + * @param aPtr Where to write the pixel, the pointer is modified to point + * after the pixel upon return. + * @param aPixel The pixel to write + * @param aPalette Information about aPixel's format. + * @param a24Bit Do the write in 24- or 32-bit format + */ + static inline void WritePixelTrueColor(TUint8*& aPtr, TUint aPixel, + const MSwtPaletteData::TDirectData& aPalette, TBool a24Bit); + + /** + * Writes a True Color pixel in the Symbian format ( BGR ). + * @param aPtr Where to write the pixel, the pointer is modified to point + * after the pixel upon return. + * @param aColor The colour to write at the specified location. + */ + static inline void WritePixelTrueColor(TUint8*& aPtr, const TRgb& aColor, + TBool a24Bit); + + /** + * Copies data from a buffer of bytes to a bitmap. + */ + static void CopyData(const CFbsBitmap& aBitmap, const TDesC8& aData, + TInt aLineCount, TInt aDepth, TInt aBytesPerLine, + const MSwtPaletteData* aPalette); + + /** + * Add mask bitmap's alpha channel. + */ + void AddMaskToAlphaChannel(const CFbsBitmap& aBitmap, const CFbsBitmap& aMask); + + /** + * Copies data between two buffers arranged in units of 1 bit. + * The bits of each byte are reversed on the fly. + */ + static void Copy1(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount); + + /** + * Copies data between two buffers arranged in units of 4 bits. + * The four quarters of each byte are reversed on the fly. + */ + static void Copy2(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount); + + /** + * Copies data between two buffers arranged in units of 4 bits. + * The two halves of each byte are swapped on the fly. + */ + static void Copy4(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount); + + /** + * Copies data between two buffers arranged in units of 8 bits. + */ + static void Copy8(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount); + + /** + * Copies data between two buffers arranged in units of 16 bits. + * The first and last bytes of each unit are swapped on the fly to account + * for the fact that Symbian's and SWT's red and blue channels are inverted. + */ + static void Copy16(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Copies data from a buffer of 1-bit paletted pixels to a buffer of + * 24/32-bit pixels. + */ + static void Copy1ToTrueColor(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const CPalette& aPalette, TBool a24Bit); + + /** + * Copies data from a buffer of 2-bit paletted pixels to a buffer of + * 24/32-bit pixels. + */ + static void Copy2ToTrueColor(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const CPalette& aPalette, TBool a24Bit); + + /** + * Copies data from a buffer of 4-bit paletted pixels to a buffer of + * 24/32-bit pixels + */ + static void Copy4ToTrueColor(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const CPalette& aPalette, TBool a24Bit); + + /** + * Copies data from a buffer of 8-bit paletted pixels to a buffer of + * 24/32-bit pixels + */ + static void Copy8ToTrueColor(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const CPalette& aPalette, TBool a24Bit); + + /** + * Copies data from a buffer of 8-bit pixels to a buffer of 24/32-bit pixels. + */ + static void Copy8ToTrueColor(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const MSwtPaletteData::TDirectData& aPalette, TBool a24Bit); + + /** + * Copies data between two buffers arranged in units of 24 bits. + */ + static void Copy24(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Copies data between two buffers arranged in units of 24 bits. + */ + static void Copy32(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, TInt aLineCount, + const MSwtPaletteData::TDirectData& aPalette); + + /** + * Returns a newly allocated buffer to the data of the specified bitmap. + */ + static HBufC8* GetPixelDataLC(const CFbsBitmap& aBitmap); + + /** + * ? + */ + static void GetPixels16(TUint8* aDest, TInt aBytesPerDestLine, + const TUint8* aSrce, TInt aBytesPerSrceLine, const TSize& aSize); + +// From MSwtBitmapDrawable +public: + MSwtGc* NewGcL(); + CBitmapDevice& GraphicsDevice(); + void HandleUpdate(); +private: + static void DestroyNativeGc(CBitmapContext* aGc); + +// From MSwtImage +protected: + CFbsBitmap& GetBitmap() const; + CFbsBitmap& GetSubBitmap(const TSize& aSize) const; + +// From MSwtImage +public: + void Dispose(); + const CFbsBitmap* MaskBitmap(TBool aInvertedIfMonochrome = EFalse) const; + const CFbsBitmap* SubMaskBitmap(const TSize& aSize, TBool aInvertedIfMonochrome = EFalse) const; + TRect GetBounds() const; + MSwtImageData* GetImageDataL() const; + TInt AddSubRef(const TSize& aSize) const; + TInt RemoveSubRef(const TSize& aSize) const; + TInt SubRefCount(const TSize& aSize) const; + CFbsBitmap* BitmapWithAlphaLC(); + +// From MSwtResourceChangeObserver +public: + void OfferResourceChangeL(TInt aType); + +// Data +private: + /** + * The device on which the image is created, may be NULL. + * Not own. + */ + MSwtDevice* iDevice; + + /** + * Colour data, may be owned, cannot be NULL. + * May be own or not own. + */ + CFbsBitmap* iBitmap; + + /** + * Device for drawing onto the bitmap, cannot be NULL. + * Own. + */ + CFbsBitmapDevice* iBitmapDevice; + + /** + * The type of mask we're dealing with + */ + TMaskType iMaskType; + + /** + * Transparency mask, binary ( 1 bit ) or alpha ( 8 bits ), may be NULL. + * May be own or not own. + */ + CFbsBitmap* iMask; + + /** + * Transparency mask inverted, binary ( 1 bit ) or alpha ( 8 bits ), may be NULL. + * Created only upon request. + * Own. + */ + mutable CFbsBitmap* iMaskInverted; + + /** + * The transparent colour, may be NULL. + * Own. + */ + TRgb* iColorKey; + + /** + * The coordinates the bitmap's origin is at within an animation. + */ + TPoint iOffset; + + /** + * The original image information + */ + MSwtImageData::TInfo iInfo; + + /** + * The iBitmap and iMask object have been created outside of the object. + * Do not delete them in the destructor. + */ + TBool iOwnExternally; + + /** + * The Display the image belongs to, may be NULL. + * Not own. + */ + MSwtDisplay* iDisplay; + + /** + * Array holding the reference count for scaled copies of the main bitmap. + */ + mutable RArray iScaledBitmapRefs; + + /** + * Array holding the scaled copies of the main bitmap. + */ + mutable RPointerArray iScaledBitmaps; + + /** + * Array holding the scaled copies of the main mask. + */ + mutable RPointerArray iScaledMasks; + + /** + * Array holding the scaled inverted copies of the main mask. + * Entries valid only if mask is monochrome, otherwise NULL. + */ + mutable RPointerArray iScaledMasksInverted; +}; + + +#endif // SWTIMAGE_H