FCL/sf/app/jrt: comparison javauis/lcdui_qt/src/javax/microedition/lcdui/Graphics.java

equal deleted inserted replaced

-:98ccebc37403
+:dc7c549001d5
 * Description:
 *
 */
 package javax.microedition.lcdui;
-import org.eclipse.swt.graphics.GC;
 import org.eclipse.swt.graphics.Internal_GfxPackageSupport;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.internal.qt.graphics.GraphicsContext;
-import org.eclipse.swt.internal.qt.graphics.JavaCommandBuffer;
 import org.eclipse.swt.internal.qt.graphics.FontUtils;
 import com.nokia.mid.ui.DirectGraphics;
 /**
 /**
 * Constant for dotted stroke style.
 */
 public static final int DOTTED = 1;
+static final int INVALID_STROKE_STYLE = -1;
 static final int RGB_MASK = 0x00FFFFFF;
+static final int OPAQUE_ALPHA = 0xff000000;
 static final int COMPONENT_MASK = 0xFF;
 private DirectGraphics directGraphics;
+private Buffer graphicsBuffer;
-// Graphics rectangle (off-screen buffer rectangle).
-// private Rectangle graphicsClientArea;
-// Graphics context for drawing to off-screen buffer.
-private GraphicsContext gc;
 // Off-screen buffer.
 //private org.eclipse.swt.internal.qt.graphics.Image frameBuffer;
 // Current font for rendering texts.
-private Font currentFont;
+Font currentFont;
-private int currentColor;
+int currentColor;
-private int translateX;
+int translateX;
-private int translateY;
+int translateY;
-private int[] currentClip = new int[4];
+int[] currentClip = new int[4];
-private int currentStrokeSyle;
+int currentStrokeSyle;
-// Image owning the Graphics if the Graphics object belongs to an Image.
-private Image parentImage;
-// Flag indicating that we are in Canvas.paint() callback,
-// thus inside UI thread
-private boolean paintCallBack;
-private boolean buffered;
-private JavaCommandBuffer cmdBuffer;
 private com.nokia.mj.impl.rt.support.Finalizer finalizer;
 // serialization lock for command buffering and flush
 private final Object flushLock = new Object();
 private Canvas canvasParent;
 private CustomItem customItemParent;
 //Constructor
-Graphics()
+Graphics(Buffer buffer)
 {
 finalizer = ((finalizer != null) ? finalizer
 : new com.nokia.mj.impl.rt.support.Finalizer()
 {
 public void finalizeImpl()
 }
 }
 }
 });
-}
+graphicsBuffer = buffer;
-/**
-* Set the parent image of this Graphics.
-*
-* @param image an image
-*/
-void eswtSetParentImage(final Image image)
-{
-if(buffered)
-{
-return;
-}
-if(parentImage != image)
-{
-parentImage = image;
-if(gc == null)
-{
-gc = new GraphicsContext();
-}
-else
-{
-gc.releaseTarget();
-}
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-org.eclipse.swt.graphics.Image eswtImage = Image.getESWTImage(image);
-if(eswtImage != null)
-{
-gc.bindTarget(Internal_GfxPackageSupport.getImage(eswtImage));
-Rectangle clipRect = eswtImage.getBounds();
-setClip(0, 0, clipRect.width, clipRect.height);
-}
-reset();
-}
-});
-}
-}
-/**
-* Initializes this instance of Graphics to use command buffer.
-*
-* Can be called in a non-UI thread. Not thread-safe.
-*
-* @param x The x-coordinate of clip
-* @param y The y-coordinate of clip
-* @param width The width of clip
-* @param height The height of clip
-*/
-void initBuffered(final Canvas parent, final int x, final int y, final int width, final int height)
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-cmdBuffer = new JavaCommandBuffer();
-if(gc == null)
-{
-gc = new GraphicsContext();
-}
-gc.bindTarget(cmdBuffer);
-setClip(x, y, width, height);
-reset();
-buffered = true;
-javax.microedition.lcdui.Graphics.this.canvasParent = parent;
-}
-});
-}
-/**
-* Initializes this instance of Graphics to use command buffer.
-*
-* Can be called in a non-UI thread. Not thread-safe.
-*
-* @param x The x-coordinate of clip
-* @param y The y-coordinate of clip
-* @param width The width of clip
-* @param height The height of clip
-*/
-void initBuffered(CustomItem parent, int x, int y, int width, int height)
-{
-cmdBuffer = new JavaCommandBuffer();
-if(gc == null)
-{
-gc = new GraphicsContext();
-}
-gc.bindTarget(cmdBuffer);
-setClip(x, y, width, height);
 reset();
-buffered = true;
+}
-this.customItemParent = parent;
-}
 /**
-* Resets the command buffer contents.
+* Disposes objects with native counterparts
-*
-* This is safe to call only in the UI thread.
-*/
-void resetCommandBuffer()
-{
-gc.releaseTarget();
-cmdBuffer.reset();
-gc.bindTarget(cmdBuffer);
-// write settings which were active before flush
-// if they are not the same as defaults
-gc.setFont(Font.getESWTFont(currentFont).handle);
-gc.setBackgroundColor(currentColor, false);
-gc.setForegroundColor(currentColor, false);
-if((translateX != 0) || (translateY != 0))
-{
-gc.translate(translateX, translateY);
-}
-// Note that if called in a non-UI thread then the size of the
-// Canvas or CustomItem can change between getting the height and
-// getting the width. Those are modified by the UI thread and there
-// is no synchronization.
-int w = 0;
-int h = 0;
-if(canvasParent != null)
-{
-w = canvasParent.getWidth();
-h = canvasParent.getHeight();
-}
-else
-{
-w = customItemParent.getContentWidth();
-h = customItemParent.getContentHeight();
-}
-if((currentClip[0] != 0) && (currentClip[1] != 0) &&
-(currentClip[2] != w) && (currentClip[2] != h))
-{
-gc.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], false);
-}
-if(currentStrokeSyle != SOLID)
-{
-gc.setStrokeStyle(GraphicsContext.STROKE_DOT);
-}
-}
-/**
-* Returns the current command buffer or null.
-*
-* This method is thread-safe.
-*/
-JavaCommandBuffer getCommandBuffer()
-{
-return cmdBuffer;
-}
-/**
-* Get the parent image of this Graphics.
-*/
-Image getParentImage()
-{
-return parentImage;
-}
-/**
-* Set Graphics context to a target - the GC is coming from paint event.
-*
-* @param eswtGC
-*/
-void eswtSetGC(final GC eswtGC)
-{
-if(buffered)
-{
-return;
-}
-gc = eswtGC.getGCData().internalGc;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-Rectangle clipRect = eswtGC.getClipping();
-setClip(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
-reset();
-}
-});
-}
-/**
-* Disposes Graphics context resources.
 */
 void dispose()
 {
-if(parentImage != null)
+synchronized(graphicsBuffer)
 {
-parentImage = null;
+graphicsBuffer.removeRef();
-}
-if(gc != null)
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.dispose();
-}
-});
-gc = null;
-}
-if(cmdBuffer != null)
-{
-cmdBuffer = null;
 }
 }
 /**
 * Resets Graphics state to initial.
 setColor(255, 255, 255);
 fillRect(x, y, w, h);
 setColor(savedColor);
 }
-/**
-* Sets flag indicating that we are in Canvas.paint() callback
-*/
-void beginPaint()
-{
-paintCallBack = true;
-}
-/**
-* Sets flag indicating that we are exiting Canvas.paint() callback
-*/
-void endPaint()
-{
-paintCallBack = false;
-}
-/**
-* Provides the serialization lock for buffer writing and flushing
-* @return lock used for synchronizing command buffer access
-*/
-Object getLock()
-{
-return flushLock;
-}
 /**
 * Sets coordinate translation. Translations are cumulative.
 *
 * @param xDelta x-shift for coordinates.
 * @param yDelta y-shift for coordinates.
 */
 public void translate(int xDelta, int yDelta)
 {
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.translate(xDelta, yDelta, this);
-{
+translateX += xDelta;
-final int xDelta_ = xDelta;
+translateY += yDelta;
-final int yDelta_ = yDelta;
+}
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.translate(xDelta_, yDelta_);
-}
-});
-}
-else
-{
-gc.translate(xDelta, yDelta);
-}
-}
-translateX += xDelta;
-translateY += yDelta;
 }
 /**
 * Returns current X-shift of coordinate translation.
 *
 * @return Current X-shift of coordinate translation.
 */
 public int getTranslateX()
 {
-return translateX;
+synchronized(graphicsBuffer)
+{
+return translateX;
+}
 }
 /**
 * Returns current Y-shift of coordinate translation.
 *
 * @return current Y-shift of coordinate translation.
 */
 public int getTranslateY()
 {
-return translateY;
+synchronized(graphicsBuffer)
+{
+return translateY;
+}
 }
 /**
 * Returns current color in 0x00RRGGBB format.
 *
 * @return Current color in 0x00RRGGBB format.
 */
 public int getColor()
 {
-return currentColor;
+synchronized(graphicsBuffer)
+{
+return (currentColor & RGB_MASK);
+}
 }
 /**
 * Returns red component of current color.
 *
 * @return Red component of current color in the range of 0-255.
 */
 public int getRedComponent()
 {
-return currentColor >> 16;
+synchronized(graphicsBuffer)
+{
+return currentColor >> 16;
+}
 }
 /**
 * Returns green component of current color.
 *
 * @return Green component of current color in the range of 0-255.
 */
 public int getGreenComponent()
 {
-return (currentColor >> 8) & COMPONENT_MASK;
+synchronized(graphicsBuffer)
+{
+return (currentColor >> 8) & COMPONENT_MASK;
+}
 }
 /**
 * Returns blue component of current color.
 *
 * @return Blue component of current color in the range of 0-255.
 */
 public int getBlueComponent()
 {
-return currentColor & COMPONENT_MASK;
+synchronized(graphicsBuffer)
+{
+return currentColor & COMPONENT_MASK;
+}
 }
 /**
 * Returns current grayscale color.
 *
 * @return Returns current grayscale color in the range 0-255.
 */
 public int getGrayScale()
 {
-return (getRedComponent() + getGreenComponent() + getBlueComponent()) / 3;
+synchronized(graphicsBuffer)
+{
+return (getRedComponent() + getGreenComponent() + getBlueComponent()) / 3;
+}
 }
 /**
 * Sets the current color by color components for red, green and blue.
 *
 g < 0 || g > 255 ||
 b < 0 || b > 255)
 {
 throw new IllegalArgumentException();
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.setColor(r, g, b, this);
-{
+currentColor = (OPAQUE_ALPHA | (r << 16) | (g << 8) | b);
-final int r_ = r;
+}
-final int g_ = g;
-final int b_ = b;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.setForegroundColor(r_, g_, b_);
-gc.setBackgroundColor(r_, g_, b_);
-}
-});
-}
-else
-{
-gc.setForegroundColor(r, g, b);
-gc.setBackgroundColor(r, g, b);
-}
-}
-currentColor = ((r << 16) | (g << 8) | b) & RGB_MASK;
 }
 /**
 * Sets the current color.
 *
 {
 int maskedRGB = RGB & RGB_MASK;
 final int r = maskedRGB >> 16;
 final int g = (maskedRGB >> 8) & COMPONENT_MASK;
 final int b = maskedRGB & COMPONENT_MASK;
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.setColor(r, g, b, this);
-{
+currentColor = (OPAQUE_ALPHA | maskedRGB);
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+}
-{
-public void run()
-{
-gc.setForegroundColor(r, g, b);
-gc.setBackgroundColor(r, g, b);
-}
-});
-}
-else
-{
-gc.setForegroundColor(r, g, b);
-gc.setBackgroundColor(r, g, b);
-}
-}
-currentColor = maskedRGB;
 }
 /**
 * Sets gray-scale color.
 *
 if((val < 0) || (val > 255))
 {
 throw new IllegalArgumentException();
 }
 final int col = val & COMPONENT_MASK;
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.setColor(col, col, col, this);
-{
+currentColor = (OPAQUE_ALPHA | (col << 16) | (col << 8) | col);
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+}
-{
-public void run()
-{
-gc.setForegroundColor(col, col, col);
-gc.setBackgroundColor(col, col, col);
-}
-});
-}
-else
-{
-gc.setForegroundColor(col, col, col);
-gc.setBackgroundColor(col, col, col);
-}
-}
-currentColor = ((col << 16) | (col << 8) | col) & RGB_MASK;
 }
 /**
 * Returns the current font.
 *
 * @return Current font.
 */
 public Font getFont()
 {
-return currentFont;
+synchronized(graphicsBuffer)
+{
+return currentFont;
+}
 }
 /**
 * Sets the font to be used for string rendering.
 *
 * @param newFont - the font to be used for string rendering.
 */
 public void setFont(Font newFont)
 {
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+if(newFont == null)
 {
-final Font newFont_ = newFont;
+newFont = Font.getDefaultFont();
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+}
-{
+graphicsBuffer.setFont(Font.getESWTFont(newFont).handle, this);
-public void run()
+currentFont = newFont;
-{
+}
-gc.setFont(Font.getESWTFont(newFont_).handle);
-}
-});
-}
-else
-{
-gc.setFont(Font.getESWTFont(newFont).handle);
-}
-}
-currentFont = newFont;
 }
 /**
 * Returns left bound of clip rectangle.
 *
 * @return Left bound of clip rectangle.
 */
 public int getClipX()
 {
-return currentClip[0];
+synchronized(graphicsBuffer)
+{
+return currentClip[0];
+}
 }
 /**
 * Returns top bound of clip rectangle.
 *
 * @return Top bound of clip rectangle.
 */
 public int getClipY()
 {
-return currentClip[1];
+synchronized(graphicsBuffer)
+{
+return currentClip[1];
+}
 }
 /**
 * Returns width of clip rectangle.
 *
 * @return Width of clip rectangle.
 */
 public int getClipWidth()
 {
-return currentClip[2];
+synchronized(graphicsBuffer)
+{
+return currentClip[2];
+}
 }
 /**
 * Returns height of clip rectangle.
 *
 * @return Height of clip rectangle.
 */
 public int getClipHeight()
 {
-return currentClip[3];
+synchronized(graphicsBuffer)
+{
+return currentClip[3];
+}
 }
 /**
 * Intersects current clip rectangle with the specified one.
 *
 * @param h - height of the clip rectangle to intersect with the current
 *            one.
 */
 public void clipRect(int x, int y, int w, int h)
 {
-final int cx2 = Math.min(currentClip[0] + currentClip[2], x + w);
+synchronized(graphicsBuffer)
-final int cy2 = Math.min(currentClip[1] + currentClip[3], y + h);
+{
-// setting of clip to Java Graphics
+final int cx2 = Math.min(currentClip[0] + currentClip[2], x + w);
-currentClip[0] = Math.max(x, currentClip[0]);
+final int cy2 = Math.min(currentClip[1] + currentClip[3], y + h);
-currentClip[1] = Math.max(y, currentClip[1]);
+// setting of clip to Java Graphics
-currentClip[2] = cx2 - currentClip[0];
+currentClip[0] = Math.max(x, currentClip[0]);
-currentClip[3] = cy2 - currentClip[1];
+currentClip[1] = Math.max(y, currentClip[1]);
-synchronized(flushLock)
+currentClip[2] = cx2 - currentClip[0];
-{
+currentClip[3] = cy2 - currentClip[1];
-if(!buffered)
+graphicsBuffer.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], this);
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], false);
-}
-});
-}
-else
-{
-gc.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], false);
-}
 }
 }
 /**
 * Sets the clip rectangle.
 * @param w - width of the new clip rectangle.
 * @param h - height of the new clip rectangle.
 */
 public void setClip(int x, int y, int w, int h)
 {
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+currentClip[0] = x;
-{
+currentClip[1] = y;
-final int x_ = x;
+currentClip[2] = w;
-final int y_ = y;
+currentClip[3] = h;
-final int w_ = w;
+graphicsBuffer.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], this);
-final int h_ = h;
+}
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.setClip(x_, y_, w_, h_, false);
-}
-});
-}
-else
-{
-gc.setClip(x, y, w, h, false);
-}
-}
-currentClip[0] = x;
-currentClip[1] = y;
-currentClip[2] = w;
-currentClip[3] = h;
 }
 /**
 * Draws a line with current color and current stroke style.
 *
 * @param xEnd - X-coordinate of line end point.
 * @param yEnd - Y-coordinate of line end point.
 */
 public void drawLine(int xStart, int yStart, int xEnd, int yEnd)
 {
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.drawLine(xStart, yStart, xEnd, yEnd, this);
-{
-final int xs_ = xStart;
-final int ys_ = yStart;
-final int xe_ = xEnd;
-final int ye_ = yEnd;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawLine(xs_, ys_, xe_, ye_);
-}
-});
-}
-else
-{
-gc.drawLine(xStart, yStart, xEnd, yEnd);
-}
 }
 }
 /**
 * Fills a rectangle with current color.
 {
 if((w < 0) || (h < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.fillRect(x, y, w, h, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.fillRect(x_, y_, w_, h_);
-}
-});
-}
-else
-{
-gc.fillRect(x, y, w, h);
-}
 }
 }
 /**
 * Draws a rectangle with specified color and stroke style.
 {
 if((w < 0) || (h < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.drawRect(x, y, w, h, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawRect(x_, y_, w_, h_);
-}
-});
-}
-else
-{
-gc.drawRect(x, y, w, h);
-}
 }
 }
 /**
 * Draws a rounded rectangle with specified color and stroke style.
 {
 if((w < 0) || (h < 0) || (arcW < 0) || (arcH < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.drawRoundRect(x, y, w, h, arcW, arcH, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-final int arcW_ = arcW;
-final int arcH_ = arcH;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawRoundRect(x_, y_, w_, h_, arcW_, arcH_);
-}
-});
-}
-else
-{
-gc.drawRoundRect(x, y, w, h, arcW, arcH);
-}
 }
 }
 /**
 * Fills a rounded rectangle with specified color.
 {
 if((w < 0) || (h < 0) || (arcW < 0) || (arcH < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.fillRoundRect(x, y, w, h, arcW, arcH, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-final int arcW_ = arcW;
-final int arcH_ = arcH;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.fillRoundRect(x_, y_, w_, h_, arcW_, arcH_);
-}
-});
-}
-else
-{
-gc.fillRoundRect(x, y, w, h, arcW, arcH);
-}
 }
 }
 /**
 * Fills an arc with specified color.
 {
 if((w < 0) || (h < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.fillArc(x, y, w, h, startAngle, arcAngle, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-final int startAngle_ = startAngle;
-final int arcAngle_ = arcAngle;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.fillArc(x_, y_, w_, h_, startAngle_, arcAngle_);
-}
-});
-}
-else
-{
-gc.fillArc(x, y, w, h, startAngle, arcAngle);
-}
 }
 }
 /**
 * Draws an arc with specified color and stroke style.
 {
 if((w < 0) || (h < 0))
 {
 return;
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.drawArc(x, y, w, h, startAngle, arcAngle, this);
-{
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-final int startAngle_ = startAngle;
-final int arcAngle_ = arcAngle;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawArc(x_, y_, w_, h_, startAngle_, arcAngle_);
-}
-});
-}
-else
-{
-gc.drawArc(x, y, w, h, startAngle, arcAngle);
-}
 }
 }
 /**
 * Draws a string with specified color and font.
 {
 throw new IllegalArgumentException(
 MsgRepository.GRAPHICS_EXCEPTION_INVALID_ANCHOR);
 }
-final int alignments = GraphicsContext.ALIGNMENT_TOP | GraphicsContext.ALIGNMENT_LEFT;
+synchronized(graphicsBuffer)
-final int[] boundingBox = new int[4];
+{
-final String localStr = string;
+final int alignments = GraphicsContext.ALIGNMENT_TOP | GraphicsContext.ALIGNMENT_LEFT;
+final int[] boundingBox = new int[4];
-if(paintCallBack)
+final String localStr = string;
-{
-gc.getTextBoundingBox(boundingBox, string, alignments, 0);
-}
-else
-{
 ESWTUIThreadRunner.safeSyncExec(new Runnable()
 {
 public void run()
 {
 FontUtils fu = new FontUtils(Font.getESWTFont(currentFont).handle);
 fu.getBoundingRect(boundingBox, localStr);
 }
 });
-}
-// boundingBox[RECT_X] - top-left x of the text bounding box
+// Arrange vertical alignments
-// boundingBox[RECT_Y] - top-left y of the text bounding box
+int y = yPos;
-// boundingBox[RECT_WIDTH] - the width of the text bounding box
+if(isFlag(anch, Graphics.BOTTOM))
-// boundingBox[RECT_HEIGHT] - the height of the text bounding box
+{
+y = yPos - boundingBox[GraphicsContext.RECT_HEIGHT];
-// Arrange vertical alignments
+}
-int y = yPos;
+if(isFlag(anch, Graphics.BASELINE))
-if(isFlag(anch, Graphics.BOTTOM))
+{
-{
+y = yPos - currentFont.getBaselinePosition();
-y = yPos - boundingBox[GraphicsContext.RECT_HEIGHT];
+}
-}
+// Arrange horizontal alignments
-if(isFlag(anch, Graphics.BASELINE))
+int x = xPos;
-{
+if(isFlag(anch, Graphics.RIGHT))
-y = yPos - currentFont.getBaselinePosition();
+{
-}
+x = xPos - boundingBox[GraphicsContext.RECT_WIDTH];
+}
-// Arrange horizontal alignments
+if(isFlag(anch, Graphics.HCENTER))
-int x = xPos;
+{
-if(isFlag(anch, Graphics.RIGHT))
+x = xPos - boundingBox[GraphicsContext.RECT_WIDTH] / 2;
-{
+}
-x = xPos - boundingBox[GraphicsContext.RECT_WIDTH];
-}
+graphicsBuffer.drawString(localStr, x, y, this);
-if(isFlag(anch, Graphics.HCENTER))
-{
-x = xPos - boundingBox[GraphicsContext.RECT_WIDTH] / 2;
-}
-synchronized(flushLock)
-{
-if(!buffered)
-{
-final int x_ = x;
-final int y_ = y;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawString(localStr, x_, y_, true);
-}
-});
-}
-else
-{
-gc.drawString(localStr, x, y, true);
-}
 }
 }
 private static boolean isFlag(int anchor, int flag)
 {
 if(!checkImageAnchors(anch))
 {
 throw new IllegalArgumentException(
 MsgRepository.GRAPHICS_EXCEPTION_INVALID_ANCHOR);
 }
+synchronized(graphicsBuffer)
-int y = yPos;
+{
-if(isFlag(anch, Graphics.VCENTER))
+int y = yPos;
-{
+if(isFlag(anch, Graphics.VCENTER))
-y = yPos - image.getHeight() / 2;
+{
-}
+y = yPos - image.getHeight() / 2;
-if(isFlag(anch, Graphics.BOTTOM))
+}
-{
+if(isFlag(anch, Graphics.BOTTOM))
-y = yPos - image.getHeight();
+{
-}
+y = yPos - image.getHeight();
+}
-int x = xPos;
-if(isFlag(anch, Graphics.HCENTER))
+int x = xPos;
-{
+if(isFlag(anch, Graphics.HCENTER))
-x = xPos - image.getWidth() / 2;
+{
-}
+x = xPos - image.getWidth() / 2;
-if(isFlag(anch, Graphics.RIGHT))
+}
-{
+if(isFlag(anch, Graphics.RIGHT))
-x = xPos - image.getWidth();
+{
-}
+x = xPos - image.getWidth();
+}
-synchronized(flushLock)
-{
+synchronized(image.graphicsBuffer)
-if(!buffered)
+{
-{
+image.sync();
-final int x_ = x;
+graphicsBuffer.drawImage(Internal_GfxPackageSupport.getImage(Image.getESWTImage(image)), x, y, this);
-final int y_ = y;
-final org.eclipse.swt.internal.qt.graphics.Image image_ =
-Internal_GfxPackageSupport.getImage(Image.getESWTImage(image));
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawImage(image_, x_, y_);
-}
-});
-}
-else
-{
-gc.drawImage(Internal_GfxPackageSupport.getImage(Image.getESWTImage(image)), x, y);
 }
 }
 }
 /**
 {
 if(newStyle == currentStrokeSyle)
 {
 return;
 }
-if(newStyle == SOLID)
+synchronized(graphicsBuffer)
 {
-synchronized(flushLock)
+int styleToApply = mapStrokeStyle(newStyle);
-{
+if(styleToApply == INVALID_STROKE_STYLE)
-if(!buffered)
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.setStrokeStyle(GraphicsContext.STROKE_SOLID);
-}
-});
-}
-else
-{
-gc.setStrokeStyle(GraphicsContext.STROKE_SOLID);
-}
-}
-}
-else
-{
-if(newStyle == DOTTED)
-{
-synchronized(flushLock)
-{
-if(!buffered)
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.setStrokeStyle(GraphicsContext.STROKE_DOT);
-}
-});
-}
-else
-{
-gc.setStrokeStyle(GraphicsContext.STROKE_DOT);
-}
-}
-}
-else
 {
 throw new IllegalArgumentException(
 MsgRepository.GRAPHICS_EXCEPTION_ILLEGAL_STROKE_STYLE);
 }
-}
+graphicsBuffer.setStrokeStyle(styleToApply, newStyle, this);
 currentStrokeSyle = newStyle;
+}
 }
 /**
 * Returns current stroke style.
 *
 * @return Current stroke style.
 */
 public int getStrokeStyle()
 {
-return currentStrokeSyle;
+synchronized(graphicsBuffer)
+{
+return currentStrokeSyle;
+}
 }
 /**
 * Returns the color that will be used if the specified color is requested.
 *
 if(rgb == null)
 {
 throw new NullPointerException(
 MsgRepository.IMAGE_EXCEPTION_DATA_IS_NULL);
 }
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-if(!buffered)
+graphicsBuffer.drawRGB(rgb, offset, scanlength, x, y, w, h, alpha, this);
-{
-final int[] rgb_ = rgb;
-final int offset_ = offset;
-final int scanlength_ = scanlength;
-final int x_ = x;
-final int y_ = y;
-final int w_ = w;
-final int h_ = h;
-final boolean alpha_ = alpha;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawRGB(rgb_, offset_, scanlength_, x_, y_, w_, h_, alpha_);
-}
-});
-}
-else
-{
-gc.drawRGB(rgb, offset, scanlength, x, y, w, h, alpha);
-}
 }
 }
 /**
 * Fills the specified triangle with current color.
 int xPos2,
 int yPos2,
 int xPos3,
 int yPos3)
 {
-final int[] points = {xPos1, yPos1, xPos2, yPos2, xPos3, yPos3};
+synchronized(graphicsBuffer)
-synchronized(flushLock)
+{
-{
+final int[] points = {xPos1, yPos1, xPos2, yPos2, xPos3, yPos3};
-if(!buffered)
+graphicsBuffer.fillTriangle(points, this);
-{
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.fillPolygon(points);
-}
-});
-}
-else
-{
-gc.fillPolygon(points);
-}
 }
 }
 /**
 * Copies the specified area.
 int xTo,
 int yTo,
 int anch)
 {
-if(this.parentImage == null)
+if(graphicsBuffer.getHostType() != Buffer.HOST_TYPE_IMAGE)
 {
 // this Graphics belongs to a screen device.
 throw new IllegalStateException(
 MsgRepository.GRAPHICS_EXCEPTION_DESTINATION_IS_SCREEN);
 }
+synchronized(graphicsBuffer)
-if(!javax.microedition.lcdui.Image.validateRegion(parentImage
+{
-.getWidth(), parentImage.getHeight(), xFrom, yFrom, w, h))
+Image image = (Image)graphicsBuffer.getHost();
-{
+if(!javax.microedition.lcdui.Image.validateRegion(image
-throw new IllegalArgumentException(
+.getWidth(), image.getHeight(), xFrom, yFrom, w, h))
-MsgRepository.IMAGE_EXCEPTION_INVALID_REGION);
+{
-}
+throw new IllegalArgumentException(
+MsgRepository.IMAGE_EXCEPTION_INVALID_REGION);
-// Arrange vertical alignments
+}
-int destY = yTo;
-if(isFlag(anch, Graphics.BOTTOM))
+// Arrange vertical alignments
-{
+int destY = yTo;
-destY = yTo - h;
+if(isFlag(anch, Graphics.BOTTOM))
-}
+{
-if(isFlag(anch, Graphics.VCENTER))
+destY = yTo - h;
-{
+}
-destY = yTo - h / 2;
+if(isFlag(anch, Graphics.VCENTER))
-}
+{
+destY = yTo - h / 2;
-// Arrange horizontal alignments
+}
-int destX = xTo;
-if(isFlag(anch, Graphics.RIGHT))
+// Arrange horizontal alignments
-{
+int destX = xTo;
-destX = xTo - w;
+if(isFlag(anch, Graphics.RIGHT))
-}
+{
-if(isFlag(anch, Graphics.HCENTER))
+destX = xTo - w;
-{
+}
-destX = xTo - w / 2;
+if(isFlag(anch, Graphics.HCENTER))
-}
+{
+destX = xTo - w / 2;
-synchronized(flushLock)
+}
-{
+graphicsBuffer.copyArea(xFrom, yFrom, w, h, destX, destY, this);
-if(!buffered)
-{
-final int x1 = xFrom;
-final int y1 = yFrom;
-final int width = w;
-final int height = h;
-final int x2 = destX;
-final int y2 = destY;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.copyArea(x1, y1, width, height, x2, y2);
-}
-});
-}
-else
-{
-gc.copyArea(xFrom, yFrom, w, h, destX, destY);
-}
 }
 }
 /**
 * Renders a portion of source image with possible transforms.
 if(srcImage == null)
 {
 throw new NullPointerException(
 MsgRepository.IMAGE_EXCEPTION_IS_NULL);
 }
-if(srcImage == parentImage)
+if(srcImage == graphicsBuffer.getHost())
 {
 throw new IllegalArgumentException(
 MsgRepository.GRAPHICS_EXCEPTION_SAME_SOURCE_AND_DESTINATION);
 }
 if(!javax.microedition.lcdui.Image.validateTransform(transform))
 srcImage.getHeight(), xSrc, ySrc, width, height))
 {
 throw new IllegalArgumentException(
 MsgRepository.IMAGE_EXCEPTION_INVALID_REGION);
 }
+synchronized(graphicsBuffer)
-// Arrange vertical alignments
+{
-int y = yDst;
+// Arrange vertical alignments
-if(isFlag(anch, Graphics.VCENTER))
+int y = yDst;
-{
+if(isFlag(anch, Graphics.VCENTER))
-y = yDst - srcImage.getHeight() / 2;
+{
-}
+y = yDst - srcImage.getHeight() / 2;
-if(isFlag(anch, Graphics.BOTTOM))
+}
-{
+if(isFlag(anch, Graphics.BOTTOM))
-y = yDst - srcImage.getHeight();
+{
-}
+y = yDst - srcImage.getHeight();
+}
-// Arrange horizontal alignments
-int x = xDst;
+// Arrange horizontal alignments
-if(isFlag(anch, Graphics.HCENTER))
+int x = xDst;
-{
+if(isFlag(anch, Graphics.HCENTER))
-x = xDst - srcImage.getWidth() / 2;
+{
-}
+x = xDst - srcImage.getWidth() / 2;
-if(isFlag(anch, Graphics.RIGHT))
+}
-{
+if(isFlag(anch, Graphics.RIGHT))
-x = xDst - srcImage.getWidth();
+{
-}
+x = xDst - srcImage.getWidth();
+}
 final int gcTransform = Image.getCgTransformValue(transform);
-synchronized(flushLock)
+synchronized(srcImage.graphicsBuffer)
 {
-if(!buffered)
+srcImage.sync();
-{
+graphicsBuffer.drawImage(Internal_GfxPackageSupport.getImage(Image.getESWTImage(srcImage)),
-final int localXDst = x;
+x, y, width, height, xSrc, ySrc, width, height, gcTransform, this);
-final int localYDst = y;
-final int localW = width;
-final int localH = height;
-final int localXSrc = xSrc;
-final int localYSrc = ySrc;
-final org.eclipse.swt.internal.qt.graphics.Image localImage =
-Internal_GfxPackageSupport.getImage(Image.getESWTImage(srcImage));
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
-{
-public void run()
-{
-gc.drawImage(localImage, localXDst, localYDst, localW, localH, localXSrc, localYSrc, localW, localH, gcTransform);
-}
-});
-}
-else
-{
-gc.drawImage(Internal_GfxPackageSupport.getImage(Image.getESWTImage(srcImage)),
-x, y, width, height, xSrc, ySrc, width, height, gcTransform);
 }
 }
 }
 /**
 }
 return directGraphics;
 }
 /**
-* Return native graphic context.
+* Maps stroke style constant from values used by
-*/
+* Graphics to values defined in GraphicsContext
-GraphicsContext getGc()
+*/
-{
+static int mapStrokeStyle(int strokeStyle)
-return gc;
+{
+if(strokeStyle == SOLID)
+{
+return GraphicsContext.STROKE_SOLID;
+}
+else if(strokeStyle == DOTTED)
+{
+return GraphicsContext.STROKE_DOT;
+}
+return INVALID_STROKE_STYLE;
+}
+//
+// Nokia UI API support
+//
+void drawRGB(int[] rgb, int offset, int scanlength, int x, int y, int w,
+int h, boolean processAlpha, int manipulation)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.drawRGB(rgb, offset, scanlength, x, y, w, h, processAlpha, manipulation, this);
+}
+}
+void drawRGB(byte[] rgb, byte[] transparencyMask, int offset, int scanlength, int x, int y, int w,
+int h, int manipulation, int format)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.drawRGB(rgb, transparencyMask, offset, scanlength, x, y, w, h, manipulation, format, this);
+}
+}
+void drawRGB(short[] rgb, int offset, int scanlength, int x, int y, int w,
+int h, boolean processAlpha, int manipulation, int format)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.drawRGB(rgb, offset, scanlength, x, y, w, h, processAlpha, manipulation, format, this);
+}
+}
+void drawPolygon(int[] points)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.drawPolygon(points, this);
+}
+}
+void fillPolygon(int[] points)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.fillPolygon(points, this);
+}
+}
+void setARGBColor(int argb)
+{
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.setARGBColor(argb, this);
+currentColor = argb;
+}
 }
 }

changeset 26	dc7c549001d5
parent 23	98ccebc37403
child 35	85266cc22c7f