--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/eswt_qt/org.eclipse.swt/Eclipse_SWT_PI/qt/library/graphics/graphics.h Tue Aug 31 15:09:22 2010 +0300
@@ -0,0 +1,1721 @@
+/*******************************************************************************
+ * Copyright (c) 2008 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 - initial API and implementation
+ *******************************************************************************/
+#ifndef GRAPHICS_H
+#define GRAPHICS_H
+
+#include <QImage>
+#include <QPixmap>
+#ifdef __SYMBIAN32__
+#include <EGL/egl.h>
+#endif
+
+class QFont;
+class QByteArray;
+
+namespace Java { namespace GFX {
+
+class Buffer;
+class GraphicsContext;
+class GraphicsFactory;
+class Image;
+class ImageLoader;
+class ImageDataWrapper;
+class PaletteDataWrapper;
+class WindowSurface;
+
+/**
+ * gfx errors
+ */
+enum TGfxError
+{
+ EGfxErrorNone = 0,
+ EGfxErrorNoMemory = 1,
+ EGfxErrorIO = 2,
+ EGfxErrorIllegalArgument = 4,
+ EGfxErrorIllegalState = 5,
+ EGfxErrorArrayIndexOutOfBounds = 6
+};
+
+/**
+ * Rendering target types
+ */
+enum TTargetType
+{
+ ETypeNone = 0,
+ ETypeWidget = 1,
+ ETypeImage = 2,
+ ETypeBuffer = 3,
+ ETypeWindowSurface = 4
+};
+
+/**
+ * Image pixel formats
+ */
+enum TImageFormat
+{
+ EFormatNone = 0,
+ EFormatRGB32 = 1,
+ EFormatARGB32 = 2,
+ EFormatARGB32Premultiplied = 3,
+ EFormatRGB16 = 4,
+ EFormatRGB555 = 5,
+ EFormatRGB444 = 6,
+ EFormatARGB4444Premultiplied = 7,
+ EFormatMONO = 8
+};
+
+/**
+ * Native image types
+ */
+enum TImageType
+{
+ ENone = -1,
+ EImage = 0,
+ EPixmap = 1
+};
+
+/**
+ * Image transforms
+ */
+enum TTransform
+{
+ ETransNone = 100,
+ ETransRot90 = 101,
+ ETransRot180 = 102,
+ ETransRot270 = 103,
+ ETransMirror = 104,
+ ETransMirrorRot90 = 105,
+ ETransMirrorRot180 = 106,
+ ETransMirrorRot270 = 107,
+ ETransFlipHorizontal = 108,
+ ETransFlipVertical = 109
+};
+
+/**
+ * Blending modes
+ */
+enum TBlendingMode
+{
+ ESrc = 10,
+ ESrcOver = 11,
+ EXor = 12
+};
+
+/**
+ * Stroke styles
+ */
+enum TStrokeStyle
+{
+ EStrokeNo = 0,
+ EStrokeSolid = 1,
+ EStrokeDot = 2,
+ EStrokeDash = 3,
+ EStrokeDashDot = 4,
+ EStrokeDashDotDot = 5
+};
+
+/**
+ * Indices for font metrics data
+ */
+enum TFontMetricsDataIndex
+{
+ EFmAscent = 0,
+ EFmAverageCharWidth = 1,
+ EFmDescent = 2,
+ EFmHeight = 3,
+ EFmLeading = 4
+};
+
+/**
+ * Common indexes for rectangle data arrays
+ */
+enum TRectIndex
+{
+ ERectX = 0,
+ ERectY = 1,
+ ERectWidth = 2,
+ ERectHeight = 3
+};
+
+/**
+ * Window surface types
+ *
+ */
+enum WindowSurfaceType
+{
+ WsTypeUnknown = 0x0000, // unknonwn or uninitialized type
+ WsTypeQtImage = 0x0001, // QImage
+ WsTypeQtPixmap = 0x0002, // QPixmap
+ WsTypeSymbianBitmap = 0x0004, // CFbsBitmap
+ WsTypeEglSurface = 0x0016 // EGL surface
+};
+
+
+/**
+ * Interface to Buffer.
+ */
+class Buffer
+{
+public:
+ /**
+ * Destructor
+ * Use dispose instead of delete
+ */
+ virtual ~Buffer() {}
+
+ /**
+ * Disposes this instance of buffer
+ */
+ virtual void dispose() = 0;
+
+ /**
+ * Retrieves bindable target of Buffer, i.e. QPaintDevice.
+ * @return bindable
+ */
+ virtual QPaintDevice* getBindable() = 0;
+
+ /**
+ * Gets the invalid rect, i.e. rectangle containing area where
+ * draw operations have affected.
+ *
+ * Values are stored in aRect array as follows:
+ * <ul>
+ * <li>aRect[ERectX] - the x coordinate of rect</li>
+ * <li>aRect[ERectY] - the y coordinate of rect</li>
+ * <li>aRect[ERectWidth] - the width of rect</li>
+ * <li>aRect[ERectHeight] - the height of rect</li>
+ * </ul>
+ *
+ * @param aRect Int array where rect data is populated
+ */
+ virtual void getInvalidRect(int aRect[]) = 0;
+
+ /**
+ * Retrieves wrapped buffer object
+ * @return QPicture
+ */
+ virtual QPicture* getPicture() = 0;
+
+};
+
+/**
+ * WindowSurface class wraps actual rendering surface for sharing it between java grapchics
+ * external renderers like m3g and m2g. It also perfroms needed blitting activations in case
+ * external renderer does not directly support current surface type.
+ *
+ * Example of using WindowSurface
+ * <code>
+ * // Set supported surface types of external renderer
+ * int caps = Java::GXF:SwImage | Java::GFX::PBuffer;
+ * // get surface
+ * QPaintDevice* surface = WindowSurface.bind(caps);
+ * // cast device to actual type
+ * switch (WindowSurface.getType)
+ * {
+ * case SwImage:
+ * surface = static_cast<QImage*>(surface);
+ * break;
+ * case PBuffer:
+ * surface = static_cast<QGLPixelBuffer*>(surface);
+ *
+ * </code>
+ *
+ * After using surface WindowSurface.release() must be called
+ */
+class WindowSurface
+{
+public:
+
+ /**
+ * Destructor
+ * @note use dispose method instead of delete
+ */
+ virtual ~WindowSurface() {}
+
+ /**
+ * Binds this surface for rendering outside GraphicsContext, e.g. rendering by m3g.
+ * When rendering has been finished by external renderer release() must be called on this instance.
+ *
+ * Surface type given to caller depends on the graphics hardware configuration, the
+ * graphics system used by QPainter and on the capabilites given on the aCapability parameter.
+ * Note that the minimun requirement is that SwImage (QImage) is supported.
+ *
+ * If caller is for instance capable for rendering on VgImage and QImage it should set value for
+ * aCapabilites as shown below. If in this case QPainter is operating in OpenVG (Hw) the returned surface is VgImage,
+ * if it is on turn operating on software based raster paintengine returned surface is SwImage (QImage).
+ *
+ * <code>
+ * int caps = Java::GFX::SwImage|Java::GFX::VgImage;
+ * </code>
+ *
+ * IMPORTANT: The caller must not delete QPaintDevice pointer returned from bind -method
+ *
+ * @param aCapabilies The hints of supported surface types, one or combination of surfacetypes
+ * defined in WindowSurfaceTypes, Default SwImage
+ * @return QPaintDevice to be used as rendering target
+ */
+ virtual void bind(int aCapabilies = WsTypeQtImage) = 0;
+
+ /**
+ * Prepares this window surface for painting. Must be called before painting starts.
+ * Should be called by UI toolkits, not by external renderers, like m3g.
+ * @param aX The x-coordinate of the paint area
+ * @param aY The y-coordinate of the paint area
+ * @param aWidth The width of the paint area
+ * @param aHeight The height of the paint area
+ */
+ virtual void beginPaint(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Ends painting intiated by call to beginPaint. Must be when painting has ended.
+ * Should be called by UI toolkits, not by external renderers, like m3g.
+ */
+ virtual void endPaint() = 0;
+
+ /**
+ * Flushes the contents of this window surface to the display. Should be called by
+ * UI toolkits.
+ */
+ virtual void flush() = 0;
+
+ /**
+ * Gets the type of the windowSurface
+ * @return One of types defined in WindowSurfaceType
+ */
+ virtual int getType() = 0;
+
+ /**
+ * Getter for the QPaintDevice of contained target. Primarily to be used
+ * when drawing to window surface target with QPainter
+ * @return The paintDevice of the target
+ */
+ virtual QPaintDevice* getDevice() = 0;
+
+#ifdef __SYMBIAN32__
+ /**
+ * Getter for egl surface.
+ * @return The egl draw surface id, or EGL_NO_SURFACE if the target is not egl type
+ */
+ virtual EGLSurface getEglSurface() = 0;
+
+ /**
+ * Getter for current the API that is currently bound to EGL.
+ * In order to get valid return value the type of this window surface
+ * must be WsTypeEglSurface.
+ * @return The API that's bound to EGL
+ */
+ virtual EGLenum getEglApi() = 0;
+#endif
+
+ /**
+ * Getter for QImage
+ * @return The target QImage, or NULL it is not the true type of target
+ */
+ virtual QImage* getQtImage() = 0;
+
+ /**
+ * Refreshes the window surface data. Refresh needs to be called
+ * e.g. when Qt has changed its window surface when switching from sw to hw
+ * rendering.
+ */
+ virtual void refresh() = 0;
+ /**
+ * Releases external renderer from this instance.
+ * Calling this method automatically blits all pixels rendered on the surface to
+ * actual target, i.e. to widget or offscreen image.
+ */
+ virtual void release() = 0;
+
+ /**
+ * Disposes this instance of windowsurface
+ */
+ virtual void dispose() = 0;
+
+ // Symbian specific methods
+
+#ifdef __SYMBIAN32__
+ /**
+ * Getter for symbian bitmap.
+ * @return The symbian bitmap if it is available, otherwise NULL
+ */
+ virtual CFbsBitmap* getSymbianBitmap() = 0;
+#endif
+
+ /**
+ * Switches to software rendering if the window goes invisible
+ * and back to hardware rendering when becoming visible.
+ */
+ virtual void handleSymbianWindowVisibilityChange(bool aVisible) = 0;
+};
+
+
+
+/**
+ * Interface to graphics context
+ */
+class GraphicsContext
+{
+public:
+ /**
+ * Destructor
+ * @note use dispose method instead of delete
+ */
+ virtual ~GraphicsContext() {}
+
+ /**
+ * Gets window surface for currrently bound target
+ */
+ virtual WindowSurface* getWindowSurface() = 0;
+
+ /**
+ * Disposes graphics context, i.e. frees all resources.
+ */
+ virtual void dispose() = 0;
+
+ /**
+ * Binds graphics context to given rendering target.
+ * @param aTarget The rendering target handle.
+ * @param aType The type of given rendering target.
+ * @param aBufferFlushTargetHandle The actual target where the buffer will be flushed to
+ * @exception GfxException
+ */
+ virtual void bindTarget(int aTarget, TTargetType aType, const int& aBufferFlushTargetHandle) = 0;
+
+ /**
+ * Renders draw commands stored in given buffer to currently bound target.
+ * @param aBuffer The rendering target handle.
+ * @exception GfxException
+ */
+ virtual void render(Buffer* aBuffer) = 0;
+
+ /**
+ * Releases current rendering target and frees resources.
+ * After calling release target no graphics operations are allowed
+ * as there's no target to render to. Note, there is no checking for
+ * existing target, so it fails on platform operations.
+ */
+ virtual void releaseTarget() = 0;
+
+ /**
+ * Copies rectangular area from currently bound target to given image target.
+ * The copy rectangle top left corned is defined by x and y and bottom right corner
+ * by image width and height.
+ *
+ * @param aImage The image to copy into
+ * @param aX The x coordinate of top left corner copy area
+ * @param aY The y coordinate of top left corner copy area
+ */
+ virtual void copyArea(Image* aImage, int aX, int aY) = 0;
+
+ /**
+ * Copies rectangular area within currently bound target from source
+ * location to destination location.
+ *
+ * @param aSrcX The top left x coordinate of source rectangle
+ * @param aSrcY The top left y coordinate of source rectangle
+ * @param aWidth The width of source rectangle
+ * @param aHeight The height of source rectangle
+ * @param aDestX The top left x coordinate for the copy
+ * @param aDestY The top left y coordinate for the copy
+ * @param aPaint If to generate paint events for the new and obscured areas
+ */
+ virtual void copyArea(int aSrcX, int aSrcY, int aWidth, int aHeight, int aDestX, int aDestY, bool aPaint) = 0;
+
+ /**
+ * Draws outline of elliptical arc within specified rectangle.
+ * Arc is drawn counterclockwise.
+ *
+ * @param aX The x coordinate of top left corner of arc rectangle
+ * @param aY The y coordinate of top left corner of arc rectangle
+ * @param aWidth The width of arc rectangle
+ * @param aHeight The height of arc rectangle
+ * @param aStartAngle The starting angle for arc
+ * @param aArcAngle The span angle for arc
+ */
+ virtual void drawArc(int aX, int aY, int aWidth, int aHeight, int aStartAngle, int aArcAngle) = 0;
+
+ /**
+ * Draws an ellipse specified by rectangle.
+ *
+ * @param aX The x coordinate of top left corner of ellipse rectangle
+ * @param aY The y coordinate of top left corner of ellipse rectangle
+ * @param aWidth The width of ellipse rectangle
+ * @param aHeight The height of ellipse rectangle
+ */
+ virtual void drawEllipse(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Draws a focus rectangle specified by the parameters.
+ *
+ * @param aX The x coordinate of top left corner of the rectangle
+ * @param aY The y coordinate of top left corner of the rectangle
+ * @param aWidth The width of the rectangle
+ * @param aHeight The height of the rectangle
+ */
+ virtual void drawFocus(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Draws an image at (x, y) by copying a part of image into the paint device.
+ * The default, (0, 0) (and negative) means all the way to the bottom-right of the image.
+ *
+ * @param aImage The source from where to draw
+ * @param aManipulation The transformation to be applied to the region before it is drawn
+ * @param aTx The top-left x coordinate in the paint device that is to be drawn onto
+ * @param aTy The top-left y coordinate in the paint device that is to be drawn onto
+ * @param aTw The width of the image that is to be drawn onto.
+ * @param aTh The heigth of the image that is to be drawn onto.
+ * @param aSx The top-left x coordinate in image that is to be drawn
+ * @param aSy The top-left y coordinate in image that is to be drawn
+ * @param aSw The width of the image that is to be drawn.
+ * @param aSh The heigth of the image that is to be drawn.
+ * @see QPainter::drawImage
+ */
+ virtual void drawImage(Image* aImage, int aManipulation, int aTx, int aTy, int aTw = -1, int aTh = -1,
+ int aSx = 0, int aSy = 0, int aSw = -1, int aSh = -1) = 0;
+
+ /**
+ * Draws image to specified cooridnates
+ *
+ * @param aImage The image that is to be drawn
+ * @param x The x-coordinate where to draw
+ * @param y The y-coordinate where to draw
+ */
+ virtual void drawImage(Image* aImage, int x, int y) = 0;
+
+ /**
+ * Draws a line between defined points.
+ *
+ * @param aX1 The x coordinate of staring point
+ * @param aY1 The y coordinate of staring point
+ * @param aX2 The x coordinate of ending point
+ * @param aY2 The y coordinate of ending point
+ */
+ virtual void drawLine(int aX1, int aY1, int aX2, int aY2) = 0;
+
+ /**
+ * Draws a point to specified location.
+ *
+ * @param aX The x coordinate to draw the point
+ * @param aY The y coordinate to draw the point
+ */
+ virtual void drawPoint(int aX, int aY) = 0;
+
+ /**
+ * Draws a closed polygon which is defined integer array of coorinates.
+ * Lines are drawn between each consecutive x,y pairs and between first and last point.
+ *
+ * @param aPointArray An array alternating x and y values which are the verices of the polygon
+ * @param aLength The number of point pairs in array
+ */
+ virtual void drawPolygon(int aPointArray[], int aLength) = 0;
+
+ /**
+ * Draws polyline which is defined integer array of coorinates.
+ * Lines are drawn between each consecutive x,y pairs, but not between first and last coordinate.
+ *
+ * @param pointArray An array alternating x and y values which are the corners of the polyline
+ * @param aLength The number of point pairs in array
+ */
+ virtual void drawPolyline(int aPointArray[],int aLength) = 0;
+
+ /**
+ * Draws outline rectangle specified by the arguments.
+ *
+ * @param aX The x coordinate of top left corner of rectangle
+ * @param aY The y coordinate of top left corner of rectangle
+ * @param aWidth The width of rectangle
+ * @param aHeight The height of rectangle
+ */
+ virtual void drawRect(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Draws a series of RGB+transparency values to specified region
+ *
+ * Scanlength can be negative which results in reading <code>aRgbData</code> array in reverse direction
+ *
+ * @param aRgbData an array or ARGB values in format #AARRGGBB
+ * @param aRgbDataLength The length of aRgbData array
+ * @param aOffset the array index of the first ARGB value
+ * @param aScanlenght the relative arra offset between consecutive rows in the <code>aRgbData</code> array
+ * @param aX the horizontal location of the region to be rendered
+ * @param aY the vertical location of the region to be rendered
+ * @param aWidth the width of the region to be rendered
+ * @param aHeight the height of the region to be rendered
+ * @param aProcessAlpha <code>true</code> if <code>rgbData</code> has an alpha channel, <code>false</code> if all pixels are fully opaque
+ * @param aManipulation an transformation made on the region before drawing it
+ * @throws GfxException
+ */
+ virtual void drawRGB(int aRgbData[], int aRgbDataLength, int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight, bool aProcessAlpha, int aManipulation) = 0;
+
+ /**
+ * Draws a series of RGB+transparency values to specified region
+ *
+ * Scanlength can be negative which results in reading <code>aRgbData</code> array in reverse direction
+ *
+ * @param aRgbData an array or RGB values in format 1 bit perpixel
+ * @param aTransparencyMask an array of mask values
+ * @param aRgbDataLength The length of aRgbData array
+ * @param aOffset the array index of the first RGB value
+ * @param aScanlenght the relative arra offset between consecutive rows in the <code>aRgbData</code> array
+ * @param aX the horizontal location of the region to be rendered
+ * @param aY the vertical location of the region to be rendered
+ * @param aWidth the width of the region to be rendered
+ * @param aHeight the height of the region to be rendered
+ * @param aManipulation an transformation made on the region before drawing it
+ * @param aFormat an image format in which <code>aRgbData</code> array is stored.
+ * @throws GfxException
+ */
+ virtual void drawRGB(char aRgbData[], char aTransparencyMask[], int aRgbDataLength, int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight, int aManipulation, int aFormat) = 0;
+
+ /**
+ * Draws a series of RGB+transparency values to specified region
+ *
+ * Scanlength can be negative which results in reading <code>aRgbData</code> array in reverse direction
+ *
+ * @param aRgbData an array or aRGB values in 16 bit per pixel
+ * @param aTransparencyMask an array of mask values
+ * @param aRgbDataLength The length of aRgbData array
+ * @param aOffset the array index of the first RGB value
+ * @param aScanlenght the relative arra offset between consecutive rows in the <code>aRgbData</code> array
+ * @param aX the horizontal location of the region to be rendered
+ * @param aY the vertical location of the region to be rendered
+ * @param aWidth the width of the region to be rendered
+ * @param aHeight the height of the region to be rendered
+ * @param aProcessAlpha <code>true</code> if <code>rgbData</code> has an alpha channel, <code>false</code> if all pixels are fully opaque
+ * @param aManipulation an transformation made on the region before drawing it
+ * @param aFormat an image format in which <code>aRgbData</code> array is stored.
+ * @throws GfxException
+ */
+ virtual void drawRGB(short aRgbData[], int aRgbDataLength, int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight, bool aProcessAlpha, int aManipulation, int aFormat) = 0;
+
+ /**
+ * Draws outline round-cornered rectangle specified by the arguments.
+ *
+ * @param aX The x coordinate of top left corner of rectangle
+ * @param aY The y coordinate of top left corner of rectangle
+ * @param aWidth The width of rectangle
+ * @param aHeight The height of rectangle
+ * @param aArcWidth The width of the rectangle corner arc
+ * @param aArcHeight The heiht of the rectangle corner arc
+ */
+ virtual void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) = 0;
+
+ /**
+ * Draws the given string, using the receiver's current font and foreground color.
+ * Test is drawn within the rectangle with origin (x, y), width and height.
+ * No tab expansion or carriage return processing will be performed.
+ * If isTransparent is true, then the background of the rectangular
+ * area where the string is being drawn will not be modified,
+ * otherwise it will be filled with the receiver's background color.
+ * Alignments and flags can be combined by using the bit-wise or operation.
+ *
+ * @param aText The string to be drawn
+ * @param aX The x coordinate of the top left corner of the rectangular area where the string is to be drawn
+ * @param aY The y coordinate of the top left corner of the rectangular area where the string is to be drawn
+ * @param aWidth The rectangular area width where the string is to be drawn.
+ * If -1 then the width is calculated based on the given <code>aText</code>, <code>aAlignments</code> and <code>aFlags</code>.
+ * @param aHeight The rectangular area height where the string is to be drawn.
+ * If -1 then the height is calculated based on the given <code>aText</code>, <code>aAlignments</code> and <code>aFlags</code>.
+ * @param aLength Length of the given text
+ * @param aAlingments Alignments @see Qt::AlignmentFlag
+ * @param aFlags Flags @see Qt::TextFlag
+ * @param aIsTransparent If true the background will be transparent,
+ * otherwise it will be opaque
+ */
+ virtual void drawString(
+ const unsigned short* aText, int aX, int aY, int aWidth, int aHeight,
+ int aLength, int aAlignments, int aFlags, bool aIsTransparent) = 0;
+
+ /**
+ * Draws given window surface to current target.
+ *
+ * @param aSurface The WindowSurface to draw
+ * @param aX The x-coordinate of the area to draw
+ * @param aY The y-coordinate of the area to draw
+ * @param aWidth The width of the area to draw
+ * @param aHeigth The height of the area to draw
+ */
+ virtual void drawWindowSurface(WindowSurface* aSurface, int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Fill interior of circular or elliptical arc within specified rectangular area.
+ *
+ * @param aX The x coordinate of top left corner of arc rectangle
+ * @param aY The y coordinate of top left corner of arc rectangle
+ * @param aWidth The width of arc rectangle
+ * @param aHeight The height of arc rectangle
+ * @param aStartAngle The starting angle for arc
+ * @param aArcAngle The span angle for arc
+ */
+ virtual void fillArc(int aX, int aY, int aWidth, int aHeight, int aStartAngle, int aArcAngle) = 0;
+
+ /**
+ * Fills interior of an ellipse/oval within specified rectangular area, using current color.
+ *
+ * @param aX The x coordinate of top left corner of ellipse rectangle
+ * @param aY The y coordinate of top left corner of ellipse rectangle
+ * @param aWidth The width of ellipse rectangle
+ * @param aHeight The height of ellipse rectangle
+ */
+ virtual void fillEllipse(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Fills interior of specified rectangle with a gradient sweeping from left to right or top to bottom
+ * from foregroundcolor to backgroundcolor or from backgroundcolor to foregroundcolor depending on swapColors.
+ *
+ * @param aX The x coordinate of top left corner of rectangle
+ * @param aY The y coordinate of top left corner of rectangle
+ * @param aWidth The width of rectangle
+ * @param aHeight The height of rectangle
+ * @param aVertical if true sweeps from top to bottom, else sweeps from left to right
+ * @param aSwapColors if true sweep is done from backgroundcolor to foregroundcolor, else from foregroundcolor to backgroundcolor
+ */
+ virtual void fillGradientRect(int aX, int aY, int aWidth, int aHeight, bool aVertical, bool aSwapColors) = 0;
+
+ /**
+ * Fills interior of closed polygon which is specified by array of integer coordinates,
+ * using current color. Lines are drawn between each consecutive x,y pairs and between first and last point.
+ *
+ * @param aPointArray An array alternating x and y values which are the verices of the polygon
+ * @param aLength The number of points in <code>aPointarray</code>
+ */
+ virtual void fillPolygon(int aPointArray[], int aLength) = 0;
+
+ /**
+ * Fills interior of the specified rectangle, using current color.
+ *
+ * @param aX The x coordinate of top left corner of rectangle
+ * @param aY The y coordinate of top left corner of rectangle
+ * @param aWidth The width of rectangle
+ * @param aHeight The height of rectangle
+ */
+ virtual void fillRect(int aX, int aY, int aWidth, int aHeight) = 0;
+
+ /**
+ * Fills interior of round-cornered rectangle, using current color.
+ *
+ * @param aX The x coordinate of top left corner of rectangle
+ * @param aY The y coordinate of top left corner of rectangle
+ * @param aWidth The width of rectangle
+ * @param aHeight The height of rectangle
+ * @param aArcWidth The width of the rectangle corner arc
+ * @param aArcHeight The heiht of the rectangle corner arc
+ */
+ virtual void fillRoundRect(int aX, int aY, int aWidth, int aHeight, int aArcWidth, int aArcHeight) = 0;
+
+ /**
+ * Get the width of the specified character in the font which is
+ * currently selected into the receiver.
+ * @param aCh The character to be measured
+ * @param aIsAdvanced If true advanced width of the given character is returned.
+ * @return If <code>aIsAdvanced</code> is false return width of the actual character,
+ * not including the leading and tailing whitespace or overhang.
+ */
+ virtual int getCharacterWidth(char aCh, bool aIsAdvanced) = 0;
+
+ /**
+ * Gets the <code>FontMetrics</code> data.
+ *
+ * Values are stored in the data array according to the
+ * <code>TFontMetricsDataIndex</code> enum.
+ *
+ * @param aData The integer array where to copy <code>FontMetrics</code> data.
+ * @param aFont If not null then Fontmetrics data will be based on it
+ * otherwise data is based on the font which is currently selected.
+ */
+
+ virtual void getFontMetricsData(int aData[], const QFont& aFont) = 0;
+ /**
+ * Gets the <code>FontMetrics</code> data that is
+ * on the font which is currently selected.
+ *
+ * Values are stored in the data array according to the
+ * <code>TFontMetricsDataIndex</code> enum.
+ *
+ * @param aData The integer array where to copy <code>FontMetrics</code> data.
+ */
+ virtual void getFontMetricsData(int aData[]) = 0;
+
+ /**
+ * Gets the alpha component of the background color.
+ *
+ * @return The alpha value (0-255)
+ */
+ virtual int getBackgroundAlpha() = 0;
+
+ /**
+ * Get the current background color
+ * The return value also holds a value for the alpha-channel.
+ *
+ * @return An ARGB quadruplet on the format #AARRGGBB, equivalent to an unsigned int.
+ */
+ virtual int getBackgroundColor() = 0;
+
+ /**
+ * Gets current blending mode.
+ * Default blending mode is SRC_OVER.
+ *
+ * @return one of TBlendingMode
+ */
+ virtual int getBlendingMode() = 0;
+
+ /**
+ * Gets the current clip rectangle. Retrieved clip is copied in given integer array which
+ * must have at least size of 4, in order to populate all clip values.
+ *
+ * Values are stored in clip array as follows:
+ * <ul>
+ * <li>aClipArray[ERectX] - the x coordinate of clip</li>
+ * <li>aClipArray[ERectY] - the y coordinate of clip
+ * <li>aClipArray[ERectWidth] - the width of clip
+ * <li>aClipArray[ERectHeight] - the height of clip
+ * </ul>
+ * @param clipArray The int array where to copy clip data
+ */
+ virtual void getClip(int aClipArray[]) = 0;
+
+ /**
+ * Gets the alpha component of the foreground color.
+ *
+ * @return The alpha value (0-255)
+ */
+ virtual int getForegroundAlpha() = 0;
+
+ /**
+ * Get the current foreground color
+ * The return value also holds a value for the alpha-channel.
+ *
+ * @return An ARGB quadruplet on the format #AARRGGBB, equivalent to an unsigned int.
+ */
+ virtual int getForegroundColor() = 0;
+
+ /**
+ * Returns a bounding box required by the given <code>string</code> when it is
+ * drawn inside the given rectangle (<code>rectX</code>, <code>rectY</code>,
+ * <code>rectWidth</code>, <code>rectHeight</code>) with the given <code>flags</code>
+ * and <code>alignments</code> using the currently set font.
+ * If the text does not fit within the given rectangle then the required bounding box
+ * is returned.
+ *
+ * @param aBoundingBox The integer array where to copy bounding box data.
+ * Result is stored in the array as follows:
+ * <ul>
+ * <li>aBoundingBox[ERectX] - top-left x of the text bounding box</li>
+ * <li>aBoundingBox[ERectY] - top-left y of the text bounding box</li>
+ * <li>aBoundingBox[ERectWidth] - the width of the text bounding box</li>
+ * <li>aBoundingBox[ERectHeight] - the height of the text bounding box</li>
+ * </ul>
+ * @param aText The string
+ * @param aTextLength Text length.
+ * @param aAlingments Alignments @see Qt::AlignmentFlag
+ * @param aFlags Flags @see Qt::TextFlag
+ * @param aRectX Drawing rectangle's top-left x coordinate.
+ * @param aRectY Drawing rectangle's top-left y coordinate.
+ * @param aRectWidth Drawing rectangle width.
+ * @param aRectHeight Drawing rectangle height.
+ */
+ virtual void getTextBoundingBox(
+ int aBoundingBox[], const unsigned short* aText, int aTextLength, int aAlignments,
+ int aFlags, int aRectX, int aRectY, int aRectWidth, int aRectHeight) = 0;
+
+ /**
+ * Gets the stroke width in pixels.
+ *
+ * @return stroke width in pixels
+ */
+ virtual int getStrokeWidth() = 0;
+
+ /**
+ * Gets the current pen/line style.
+ * @see Qt::PenStyle
+ * @return Style
+ */
+ virtual int getStrokeStyle() = 0;
+
+ /**
+ * Gets the x coorinate of translated origin
+ * @return the x coorinate of translated origin
+ */
+ virtual int getTranslateX() = 0;
+
+ /**
+ * Gets the y coorinate of translated origin
+ * @return the y coorinate of translated origin
+ */
+ virtual int getTranslateY() = 0;
+
+ /**
+ * Sets alpha component of background color.
+ *
+ * @param aAlpha The alpha value to be set in range 0-255
+ */
+ virtual void setBackgroundAlpha(int aAlpha) = 0;
+
+ /**
+ * Set the current background color
+ *
+ * @param aArgb An ARGB quadruplet on the format #AARRGGBB, equivalent to an unsigned int.
+ * @param aUpdateAlpha if true alpha values is also changed otherwise not
+ */
+ virtual void setBackgroundColor(int aArgb, bool aUpdateAlpha) = 0;
+
+ /**
+ * Sets blending mode. The blending mode dictates how rendered pixels are combined with the destination pixels.
+ * The default blending mode is ESrcOver, i.e. if not other mode is set using this method.
+ *
+ * If the bound target does not have and alpha channel the set mode has no effect.
+ *
+ * @param aMode The blending mode to be set
+ */
+ virtual void setBlendingMode(TBlendingMode aMode) = 0;
+
+ /**
+ * Returns if clipped or not.
+ * @return True if clipping region is set, and false otherwise
+ */
+ virtual bool hasClipping() = 0;
+
+ /**
+ * Reset clipping region
+ */
+ virtual void cancelClipping() = 0;
+
+ /**
+ * Sets the clip rectangle where draw operations will take affect.
+ * Rendering operations have no effect outside of the clipping area.
+ *
+ * If intersects is set as true then the clip area is set to area where the current and given
+ * clip rectangle intersect, i.e. where they overlap.
+ *
+ * @param aX The x coordinate for the clip area
+ * @param aY The y coordinate for the clip area
+ * @param aWidth The width of the clip area
+ * @param aHeight The height of the clip area
+ * @param aIntersects if true clip is set as interscetion of current and given clip rectangle,
+ * otherwise the clip is set as specified
+ */
+ virtual void setClip(int aX, int aY, int aWidth, int aHeight, bool aIntersects) = 0;
+
+ /**
+ * Sets font which is used in drawString.
+ *
+ * @param aFontHandle The handle of native QFont
+ */
+ virtual void setFont(int aFontHandle) = 0;
+
+ /**
+ * Sets alpha component of foreground color.
+ *
+ * @param aAlpha The alpha value to be set in range 0-255
+ */
+ virtual void setForegroundAlpha(int aAlpha) = 0;
+
+ /**
+ * Set the current foreground color
+ *
+ * @param aArgb An ARGB quadruplet on the format #AARRGGBB, equivalent to an unsigned int.
+ * @param aUpdateAlpha if true alpha values is also changed otherwise not
+ */
+ virtual void setForegroundColor(int aArgb, bool aUpdateAlpha) = 0;
+
+ /**
+ * Sets the stroke width in pixels.
+ *
+ * @param aWidth The stroke width in pixels
+ */
+ virtual void setStrokeWidth(int aWidth) = 0;
+
+ /**
+ * Sets the stroke style.
+ *
+ * @param aStyle The style to be set
+ */
+ virtual void setStrokeStyle(TStrokeStyle aStyle) = 0;
+
+ /**
+ * Translates the origin of this graphics context to point (x,y). All coordinates used in subsequet
+ * rendering operations are relative to this new origin.
+ *
+ * @param aX the x coordinate of new origin
+ * @param aY the y coordinate of new origin
+ */
+ virtual void translate(int aX, int aY) = 0;
+
+ /**
+ * Scales the coordinate system by (x, y). All coordinates used in subsequent
+ * rendering operations are scaled with these values.
+ *
+ * @param x the x scaling factor.
+ * @param y the y scaling factor
+ */
+ virtual void scale(int aX, int aY) = 0;
+
+ /**
+ * Resets any transformations that were made using translate(), scale().
+ */
+ virtual void resetTransform() = 0;
+
+ /**
+ * Saves all the painter settings.
+ */
+ virtual void saveSettings() = 0;
+
+ /**
+ * Restores all the painter settings.
+ */
+ virtual void restoreSettings() = 0;
+
+};
+
+class Image
+{
+public:
+ /**
+ * Destructor
+ * @note use dispose method instead of delete
+ */
+ virtual ~Image() {}
+
+ /**
+ * Creates new image with given size.
+ * @param aWidth The width of the image to be created.
+ * @param aHeight The height of the image to be created.
+ * @param aFillColor The initial color for the image in format #00RRGGBB
+ * where hight order byte, i.e. alpha is ingored
+ * @param aFormat The format for new image, this does not apply to all images.
+ * @exception GfxException
+ */
+ virtual void createBySize(int aWidth, int aHeight, int aFillColor, TImageFormat aFormat) = 0;
+
+ /**
+ * Creates new image from given existing image.
+ * If the given copy region is empty, the whole image is copied.
+ *
+ * @param aImage The image to create the copy from.
+ * @param aX The top-left x coordinate of the copy region.
+ * @param aY The top-left y coordinate of the copy region.
+ * @param aWidth The width of the copy region.
+ * @param aHeight The height of the copy region.
+ * @exception GfxException
+ */
+ virtual void createFromImage(
+ Image* aImage, int aX = 0, int aY = 0, int aWidth = 0, int aHeight = 0) = 0;
+
+ /**
+ * Creates new image from given image data.
+ *
+ * @param aData The image data to create from.
+ * @exception GfxException
+ */
+ virtual void createFromImageData(ImageDataWrapper* aData) = 0;
+
+ /**
+ * Creates new image from given <code>rgbData</code> array containing argb values.
+ *
+ * @param aRgbData a RGB data array where one pixel is specified as 0xAARRGGBB
+ * @param aWidth The width of the image
+ * @param aHeight The height of the image
+ * @param aHasAlpha If true the rgb data has also an alpha channel,
+ * otherwise all pixels are fully opaque, e.g. 0xFFRRGGBB.
+ */
+ virtual void createFromRGB(int* aRgbdata, int aWidth, int aHeight, bool aHasAlpha) = 0;
+
+ /**
+ * Disposes image, i.e. frees all related resources.
+ */
+ virtual void dispose() = 0;
+
+ /**
+ * Retrieves bindable target of image, i.e. QPaintDevice.
+ * @return bindable
+ */
+ virtual QPaintDevice* getBindable() = 0;
+
+ /**
+ * Gets the format of the image.
+ *
+ * @return a format in which image is represented.
+ */
+ virtual int getFormat() = 0;
+
+ /**
+ * Gets the height of the image.
+ * @return height
+ */
+ virtual int getHeight() = 0;
+
+ /**
+ * Returnes native QPixmap.
+ * If the image in guestion is not QPixmap, null is returned.
+ * Note that the caller of this method must not delete returned pixmap.
+ * @return native QPixmap or null if type is not QPixmap
+ */
+ virtual QPixmap* getPixmap() = 0;
+
+ /**
+ * Copies image rgb (32-bit) data of given region to given data array.
+ * @param aRgbdata The array to copy the data into.
+ * @param aOffset The offset of image data start in array to copy into.
+ * @param aScanlength The relative offset between corresponding pixels in consecutive rows of the region.
+ * @param aX The x-coordinate of top-left corner of area to be copied.
+ * @param aY The y-coordinate of top-left corner of area to be copied.
+ * @param aWidth The width of the area to be copied.
+ * @param aHeight The height of the area to be copied.
+ * @exception GfxException
+ */
+ virtual void getRgb(int* aRgbdata, int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight) = 0;
+
+
+ /**
+ * Copies image rgb (1-bit) data of given region to given data array.
+ * @param aRgbdata The array to copy the data into.
+ * @param aTransparencyMask The array to copy transparency values into
+ * @param aOffset The offset of image data start in array to copy into.
+ * @param aScanlength The relative offset between corresponding pixels in consecutive rows of the region.
+ * @param aX The x-coordinate of top-left corner of area to be copied.
+ * @param aY The y-coordinate of top-left corner of area to be copied.
+ * @param aWidth The width of the area to be copied.
+ * @param aHeight The height of the area to be copied.
+ * @param aFormat The format of an image data.
+ * @exception GfxException
+ */
+ virtual void getRgb(char* aRgbdata, char* aTransparencyMask ,int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight, int aFormat) = 0;
+
+ /**
+ * Copies image rgb (16-bit) data of given region to given data array.
+ * @param aRgbdata The array to copy the data into.
+ * @param aOffset The offset of image data start in array to copy into.
+ * @param aScanlength The relative offset between corresponding pixels in consecutive rows of the region.
+ * @param aX The x-coordinate of top-left corner of area to be copied.
+ * @param aY The y-coordinate of top-left corner of area to be copied.
+ * @param aWidth The width of the area to be copied.
+ * @param aHeight The height of the area to be copied.
+ * @param aFormat The format of an image data.
+ * @exception GfxException
+ */
+ virtual void getRgb(short* aRgbdata, int aOffset, int aScanlength, int aX, int aY, int aWidth, int aHeight, int aFormat) = 0;
+
+ /**
+ * Gets the width of the image.
+ * @return width
+ */
+ virtual int getWidth() = 0;
+
+ /**
+ * Converts this image to QImage for pixel access.
+ * If conversion fails a null image is returned.
+ * @return QImage instance created from wrapped Qt's image type.
+ */
+ virtual QImage toImage() = 0;
+
+ /**
+ * Transforms image with given transformation.
+ * @param aTransform The transform type
+ */
+ virtual void transform(TTransform aTransform) = 0;
+
+ /**
+ * Retrieves image's native type
+ * @return Image native type
+ */
+ virtual TImageType type() = 0;
+
+ /**
+ * Returns true if the image object has the alpha channel, otherwise returns false.
+ */
+ virtual bool hasAlphaChannel() = 0;
+
+ /**
+ * Returns the global alpha value for the image.
+ */
+ virtual int getAlpha() = 0;
+
+ /**
+ * Returns true if image has mask data set (instead of alpha channel).
+ */
+ virtual bool hasMask() = 0;
+};
+
+class ImageLoader
+{
+
+public:
+
+ /**
+ * Destructor
+ * @note use dispose method instead of delete
+ */
+ virtual ~ImageLoader() {}
+
+ /**
+ * Appends data to internal buffer.
+ * @param aData Data array containg data to be appended
+ * @param aLength Length of bytes to be appended
+ * @param aOffset Offset from beginning of data array from where to start append
+ * @exception GfxException
+ */
+ virtual void append(const char* aData, int aLength, int aOffset) = 0;
+
+ /**
+ * Creates internal buffer with given initial buffer size.
+ * @param aBufferSize Initial size for buffer to be created
+ * @exception GfxException
+ */
+ virtual void beginStream(int aBufferSize) = 0;
+
+ /**
+ * Ends data stream and creates image based on configuration.
+ * @return Interface for created image.
+ * @exception GfxException
+ */
+ virtual Image* endStream() = 0;
+
+ /**
+ * Disposes loader and releases all related resources.
+ */
+ virtual void dispose() = 0;
+
+ /**
+ * Loads image from file directly using the native APIs. Java security
+ * checks are bypassed.
+ * @param aFilename The filename to pass to the native APIs.
+ * @return Image The loaded image.
+ */
+ virtual Image* load(const QString& aFileName) = 0;
+
+ /**
+ * The image will be scaled to this size on load. Useful for SVG images.
+ * @param aWidth The width to scale to when the Image is loaded.
+ * @param aHeight The height to scale to when the Image is loaded.
+ */
+ virtual void setLoadSize(int aWidth, int aHeight) = 0;
+};
+
+/**
+ * Interface for wrapping SWT image data structure
+ */
+class ImageDataWrapper
+{
+// Definitios
+public:
+
+ /**
+ * SWT image types
+ */
+ typedef enum {
+ EUndefinedImage = -1, // unknown format image
+ EBmpImage = 0, // a Windows BMP format image
+ EBmpRleImage = 1, // a run-length encoded Windows BMP format image
+ EGifImage = 2, // a GIF format image
+ EIcoImage = 3, // a ICO format image
+ EJpegImage = 4, // a JPEG format image
+ EPngImage = 5 // a PNG format image
+ } TImageType;
+
+ /**
+ * Choices how to dispose the current GIF image
+ * before displaying the next one in SWT
+ */
+ typedef enum {
+ EDmUnspecified = 0, // disposal method is unspecified
+ EDmFillNone, // leave the previous image in place
+ EDmFillBackground,
+ EDmFillPrevious
+ } TDisposalMethod;
+
+ /**
+ * Data types
+ */
+ typedef enum {
+ EPixelData = 0,
+ EAlphaData,
+ EMaskData
+ } TDataType;
+
+// Methods
+public:
+ /**
+ * Dtor
+ */
+ virtual ~ImageDataWrapper() {}
+
+ /**
+ * Get image width , in pixels
+ * @return Width, in pixels
+ */
+ virtual int getWidth() = 0;
+
+ /**
+ * Get image height , in pixels
+ * @return Height, in pixels
+ */
+ virtual int getHeight() = 0;
+
+ /**
+ * Set image size, in pixels
+ * @param aWidth Width, in pixels
+ * @param aHeight, in pixels
+ */
+ virtual void setSize(int aWidth, int aHeight) = 0;
+
+ /**
+ * Get global alpha value to be used for every pixel.
+ * @return Alpha value
+ */
+ virtual int getAlpha() = 0;
+
+ /**
+ * Set global alpha value to be used for every pixel.
+ * @param aAlpha Global alpha
+ */
+ virtual void setAlpha(int aAlpha) = 0;
+
+ /**
+ * Get number of bytes per scanline.
+ * @return Number of bytes per scanline.
+ */
+ virtual int getBytesPerLine() = 0;
+
+ /**
+ * Set number of bytes per scanline.
+ * @param aBytesPerLine Number of bytes per scanline.
+ */
+ virtual void setBytesPerLine(int aBytesPerLine) = 0;
+
+ /**
+ * Get delay time before displaying the next image in an animation
+ * @return Delay time
+ */
+ virtual int getDelayTime() = 0;
+
+ /**
+ * Set time to delay before displaying the next image in an animation
+ * @param aDelayTime Delay time
+ */
+ virtual void setDelayTime(int aDelayTime) = 0;
+
+ /**
+ * Get color depth of the image, in bits per pixel.
+ * @return Color depth
+ */
+ virtual int getDepth() = 0;
+
+ /**
+ * Set color depth of the image, in bits per pixel.
+ * @param aDepth Color depth
+ */
+ virtual void setDepth(int aDepth) = 0;
+
+ /**
+ * Get number of the scanline pad.
+ * @return Scanline pad
+ */
+ virtual int getScanlinePad() = 0;
+
+ /**
+ * Set number of the scanline pad.
+ * @param aScanlinePad Scanline pad
+ */
+ virtual void setScanlinePad(int aScanlinePad) = 0;
+
+ /**
+ * Get number of the scanline pad of the mask.
+ * @return Mask's scanline pad
+ */
+ virtual int getMaskPad() = 0;
+
+ /**
+ * Set number of the scanline pad of the mask.
+ * @param aMaskPad Mask's scanline pad
+ */
+ virtual void setMaskPad(int aMaskPad) = 0;
+
+ /**
+ * Get transparent pixel.
+ * @return The transparent pixel
+ */
+ virtual int getTransparentPixel() = 0;
+
+ /**
+ * Set transparent pixel.
+ * @param aTransparentPixel Defines the transparent pixel
+ */
+ virtual void setTransparentPixel(int aTransparentPixel) = 0;
+
+ /**
+ * Get top-left x coordinate of the image within the logical screen.
+ * @return Top-left corner point.
+ */
+ virtual int getTopLeftX() = 0;
+
+ /**
+ * Get top-left y coordinate of the image within the logical screen.
+ * @return Top-left corner point.
+ */
+ virtual int getTopLeftY() = 0;
+
+ /**
+ * Set top-left corner of the image within the logical screen.
+ * @param aX Top-left x coordinate
+ * @param aY Top-left y coordinate
+ */
+ virtual void setTopLeftCorner(int aX, int aY) = 0;
+
+
+ /**
+ * Get how to dispose of image before displaying the next.
+ * @return Dispose method
+ */
+ virtual TDisposalMethod getDisposalMethod() = 0;
+
+ /**
+ * Set how to dispose of image before displaying the next.
+ * @param aDisposalMethod Disposal method
+ */
+ virtual void setDisposalMethod(int aDisposalMethod) = 0;
+
+ /**
+ * Get image type.
+ * @return Type
+ */
+ virtual TImageType getImageType() = 0;
+
+ /**
+ * Set image type
+ * @param aImageType Image type
+ */
+ virtual void setImageType(int aImageType) = 0;
+
+ /**
+ * Get data
+ * @param aType Data type.
+ * @return Data
+ */
+ virtual char* getData(TDataType aType) = 0;
+
+ /**
+ * Get data size
+ * @param aType Data type.
+ * @return Data size
+ */
+ virtual int getDataSize(TDataType aType) = 0;
+
+ /**
+ * Set data
+ * @param aSrc Source image
+ */
+ virtual void setData(Image* aSrc) = 0;
+
+ /**
+ * Set data size
+ * @param aType Data type.
+ * @param aData The QByteArray encapsulating the data
+ */
+ virtual void setData(ImageDataWrapper::TDataType aType, const QByteArray& aData) = 0;
+
+ /**
+ * Get palette data
+ * @return Palette data
+ */
+ virtual PaletteDataWrapper* getPaletteData() = 0;
+
+ /**
+ * Set palette data
+ * @param aPaletteData Palette data
+ */
+ virtual void setPaletteData(PaletteDataWrapper* aPaletteData) = 0;
+
+ /**
+ * For checking if image color mapping is indexed or direct.
+ * @return <code>true</code> if mapping is direct
+ */
+ virtual bool isDirect() = 0;
+
+};
+
+/**
+ * Interface for wrapping SWT palette structure
+ */
+class PaletteDataWrapper
+{
+// Data types
+public:
+ /**
+ * Data structure for direct palettes
+ *
+ * To extract a component from a colour: first apply the mask and then
+ * shift the result by the specified value.
+ *
+ * To combine components in order to build a colour, for each component:
+ * first shift by the opposite of the specified value and then apply the
+ * mask. Finally, combine all three components with a OR operator.
+ *
+ * In both cases, a positive value indicates a left shift whereas a
+ * negative one indicates a right shift.
+ */
+ struct TDirectData
+ {
+ /**
+ * Ctor
+ */
+ TDirectData(int aRMask = 0, int aGMask = 0, int aBMask = 0,
+ int aRShift = 0, int aGShift = 0, int aBShift = 0)
+ : mRedMask(aRMask), mGreenMask(aGMask), mBlueMask(aBMask),
+ mRedShift(aRShift), mGreenShift(aGShift), mBlueShift(aBShift) {}
+
+ /**
+ * Copy ctor
+ */
+ TDirectData(const TDirectData& aRhs)
+ {
+ *this = aRhs;
+ }
+
+ /**
+ * Asignment operator
+ */
+ TDirectData& operator=(const TDirectData& aRhs)
+ {
+ if(this != &aRhs)
+ {
+ mRedMask = aRhs.mRedMask;
+ mGreenMask = aRhs.mGreenMask;
+ mBlueMask = aRhs.mBlueMask;
+ mRedShift = aRhs.mRedShift;
+ mGreenShift = aRhs.mGreenShift;
+ mBlueShift = aRhs.mBlueShift;
+ }
+ return *this;
+ }
+
+ int mRedMask;
+ int mGreenMask;
+ int mBlueMask;
+ int mRedShift;
+ int mGreenShift;
+ int mBlueShift;
+
+ };
+
+ /**
+ * Indexed rgb data
+ */
+ struct TIndexedRgb
+ {
+ /**
+ * Ctor
+ */
+ TIndexedRgb(int aRed = -1, int aGreen = -1, int aBlue = -1)
+ : mRed(aRed), mGreen(aGreen), mBlue(aBlue) {}
+
+ /**
+ * Copy ctor
+ */
+ TIndexedRgb(const TIndexedRgb& aRhs)
+ {
+ *this = aRhs;
+ }
+
+ /**
+ * Asignment operator
+ */
+ TIndexedRgb& operator=(const TIndexedRgb& aRhs)
+ {
+ if(this != &aRhs)
+ {
+ mRed = aRhs.mRed;
+ mGreen = aRhs.mGreen;
+ mBlue = aRhs.mBlue;
+ }
+ return *this;
+ }
+
+ int mRed;
+ int mGreen;
+ int mBlue;
+ };
+
+// Methods
+public:
+ /**
+ * Dtor
+ */
+ virtual ~PaletteDataWrapper() {}
+
+ /**
+ * For checking if image color mapping is indexed or direct.
+ * @return <code>true</code> if mapping is direct
+ */
+ virtual bool isDirect() = 0;
+
+ /**
+ * Returns direct data.
+ * @return Direct data. Null if the palette data is indexed.
+ */
+ virtual TDirectData* getDirectData() = 0;
+
+ /**
+ * Returns number of the indexed data.
+ * @return Indexed data count. Zero if the palette data is direct.
+ */
+ virtual int getIndexedRgbCount() = 0;
+
+ /**
+ * Returns indexed data.
+ * @param aIndex Defains location of the wanted rgb data.
+ * @return Indexed rgb data. The returned structure contains invalid values if the
+ * palette is direct.
+ */
+ virtual TIndexedRgb getIndexedRgb(int aIndex) = 0;
+
+
+ virtual QVector<QRgb>* getIndexedPalette() = 0;
+};
+
+class Surface
+{
+public:
+ //virtual void* getTarget() = 0;
+ //virtual void setTarget(int aTarget, TTargetType aType) = 0;
+};
+
+/*
+ * Exception class for graphics.
+ *
+ * @param errorCode The graphics errorcode which maps to java exception
+ * @param msg The detailed description of exception occured
+ *
+ * @see jniutils resolveException for java exception mapping
+ */
+class GfxException {
+public:
+ GfxException(const int& aErrorCode, const QString aMsg) : mErrorCode(aErrorCode)
+ {
+ mMsg = new char[aMsg.size()+1];
+ strcpy(mMsg, aMsg.toAscii().data());
+ };
+ //~GfxException() { delete mMsg; };
+ int getErrorCode() { return mErrorCode; };
+ const char* getMsg() { return (const char*)mMsg; };
+private:
+ int mErrorCode;
+ char* mMsg;
+};
+
+/**
+ * Interface to graphics factory
+ */
+
+class GraphicsFactory
+{
+public:
+
+ /**
+ * Creates a WindowSurface instance for paint device.
+ * @param aSurface Target paint device for the window surface
+ * @param aType The type of paint device, one of defined types in WindowSurfaceType enum
+ */
+ static WindowSurface* createWindowSurface(QPaintDevice* aSurface, WindowSurfaceType aType);
+
+ /**
+ * Creates a WindowSurface instance for window owning widget.
+ * @param aWidget Window owning widget
+ * @param aAutoRefresh If true the Qt window surface pointer is updated each time
+ * the bind is called, otherwise not
+ */
+ static WindowSurface* createWindowSurface(QWidget* aWidget, bool aAutoRefresh);
+
+ /**
+ * Creates a Buffer instance.
+ */
+ static Buffer* createBuffer();
+
+ /**
+ * Creates a graphics context instance.
+ */
+ static GraphicsContext* createGraphicsContext();
+
+ /**
+ * Creates an image with given width, height and initial fillColor.
+ *
+ * @param aWidth Image width
+ * @param aHeight Image height
+ * @param aFillColor The initial color for the image in format #00RRGGBB
+ * where hight order byte, i.e. alpha is ingored
+ */
+ static Image* createImage(int aWidth, int aHeight, int aFillColor);
+
+ /**
+ * Create a copy based on the given image.
+ * If the given copy region is empty, the whole image is copied.
+ *
+ * @param aImage The source image
+ * @param aX The top-left x coordinate of the copy region.
+ * @param aY The top-left y coordinate of the copy region.
+ * @param aWidth The width of the copy region.
+ * @param aHeight The height of the copy region.
+ * @see Image::createImage
+ */
+ static Image* createImage(
+ Image* aImage, int aX = 0, int aY = 0, int aWidth = 0, int aHeight = 0);
+
+ /**
+ * Create image from a QImage
+ *
+ * @param aImage The source QImage
+ */
+ static Image* createImage(const QImage& aImage);
+
+ /**
+ * Create image from a QPixmap.
+ *
+ * @param aImage The source QPixmap
+ */
+ static Image* createImage(const QPixmap& aPixmap);
+
+ /**
+ * Creates an image based on the given ARGB data array.
+ * @param aRgbData ARGB data array. One pixel is specified as 0xAARRGGBB.
+ * @param aWidth Image width
+ * @param aHeight Image height
+ * @param aHasAlpha If true the rgb data has also an alpha channel,
+ * otherwise all pixels are fully opaque, e.g. 0xFFRRGGBB.
+ */
+ static Image* createImage(int* aRgbData, int aWidth, int aHeight, bool aHasAlpha);
+
+ /**
+ * Creates new imageloader instance
+ */
+ static ImageLoader* createImageLoader();
+
+ /**
+ * TODO
+ */
+ static Image* createImage(ImageDataWrapper* aImageDataPtr);
+
+ /**
+ * TODO
+ */
+ static ImageDataWrapper* createImageData(Image* aImage = NULL);
+
+ /**
+ * TODO
+ */
+ static PaletteDataWrapper* createPaletteData(PaletteDataWrapper::TDirectData& aDirectData);
+
+ /**
+ * TODO
+ */
+ static PaletteDataWrapper* createPaletteData(QVector<QRgb>& aIndexedData);
+};
+
+}}
+#endif //GRAPHICS_H