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

equal deleted inserted replaced

-:85266cc22c7f
+:f40128debb5d
 final static int HOST_TYPE_IMAGE = 1;
 final static int HOST_TYPE_CANVAS = 2;
 final static int HOST_TYPE_CUSTOMITEM = 3;
 // Flags for raising settings validation
-private final static int NONE            = 0;
+// FORCE_SETTINGS Forces settings to validated also in case
-private final static int COLOR           = 1;
+// there's only one Graphics instance as client, normally
-private final static int CLIP            = 2;
+// settings are not checked in such case
-private final static int FONT            = 4;
+final static int NONE            = 0;
-private final static int STROKESTYLE     = 8;
+final static int COLOR           = 1;
-private final static int COORS_TRANSLATION = 16;
+final static int CLIP            = 2;
+final static int FONT            = 4;
+final static int STROKESTYLE     = 8;
+final static int COORDS_TRANSLATION = 16;
+final static int FORCE_SETTINGS    = 32;
 // Graphics settings active in buffer
 // all values are comparable to those
 // in Graphics except font which is stored
 // as handle instead of LCDUI Font
 * @param control The eSWT control associated with the target, or null if the host is Image
 * @return New buffer instance
 */
 static Buffer createInstance(Object host, Control control)
 {
-	if(host instanceof Canvas)
+if(host instanceof Canvas)
-	{
+{
-		if(OS.windowServer == OS.WS_SYMBIAN_S60)
+if(OS.windowServer == OS.WS_SYMBIAN_S60)
-		{
+{
-		    return new CanvasBufferSymbian((Canvas) host, control);
+return new CanvasBufferSymbian((Canvas) host, control);
-		}
+}
-		else if(OS.windowServer == OS.WS_X11)
+else if(OS.windowServer == OS.WS_X11)
-		{
+{
-			return new CanvasBufferLinux((Canvas) host, control);
+return new CanvasBufferLinux((Canvas) host, control);
-		}
+}
-			return null;
+return null;
-	}
+}
-	else if(host instanceof CustomItem)
+else if(host instanceof CustomItem)
-	{
+{
-		if(OS.windowServer == OS.WS_SYMBIAN_S60)
+if(OS.windowServer == OS.WS_SYMBIAN_S60)
-		{
+{
-		    return new CustomItemBufferSymbian((CustomItem) host, control);
+return new CustomItemBufferSymbian((CustomItem) host, control);
-		}
+}
-		else if(OS.windowServer == OS.WS_X11)
+else if(OS.windowServer == OS.WS_X11)
-		{
+{
-			return new CustomItemBufferLinux((CustomItem) host, control);
+return new CustomItemBufferLinux((CustomItem) host, control);
-		}
+}
-			return null;
+return null;
-	}
+}
-	else if(host instanceof Image)
+else if(host instanceof Image)
-	{
+{
-	    return new ImageBuffer((Image) host);
+return new ImageBuffer((Image) host);
-	}
+}
-	return null;
+return null;
 }
 /**
 * Initializes data, called once
 */
 }
 /**
 * Defines the bounds of the host.
 * Bounds are used for restricting the rendering in
-* the area of the control that is being updated. With Images
+* the area of the control that is being updated.
-* the bounds are not used.
 *
 * @param crtl The Control of the host
 * @param clienArea The area of the control which can be drawn by Graphics
 */
 void setControlBounds(final Control control)
 hostBounds.width = control.getBounds().width;
 hostBounds.height = control.getBounds().height;
 }
 /**
+* Defines the bounds of the host.
+*
+* @param crtl The Control of the host
+* @param clienArea The area of the control which can be drawn by Graphics
+*/
+void setImageBounds(int width, int height)
+{
+hostBounds.x = 0;
+hostBounds.y = 0;
+hostBounds.width = width;
+hostBounds.height = height;
+}
+/**
 * Prepares surface for a new frame and starts paint session.
 * Must be called in UI thread (sync calls this automatically)
 * and at the start of new frame. The rectangle provided as
 * arguments are in control coordinates.
 *
 * @param w The width of the area to be painted
 * @param h The height of the area to be painted
 */
 void startFrame(int x, int y, int w, int h)
 {
-	if(!isSurfaceSessionOpen)
+if(!isSurfaceSessionOpen)
-	{
+{
-	    beginPaint(x, y, w, h);
+beginPaint(x, y, w, h);
-	    isSurfaceSessionOpen = true;
+isSurfaceSessionOpen = true;
-	}
+}
 }
 /**
 * Ends frame painting session. Must be called in UI thread and
 * at the end of the frame. BlitToDisplay calls this automatically.
 */
 void endFrame()
 {
-	if(isSurfaceSessionOpen)
+if(isSurfaceSessionOpen)
-	{
+{
-		endPaint();
+endPaint();
-	    isSurfaceSessionOpen = false;
+isSurfaceSessionOpen = false;
-	}
+}
 }
 /**
 * Transfers the result of rendering to display.
 * @param gc The graphics context used for blit, may be null in some cases
 * @param widget The widget that is the target
 */
 void blitToDisplay(GraphicsContext gc, Widget widget)
 {
-	    endFrame();
+endFrame();
-	blit(gc, widget);
+blit(gc, widget);
 }
 /**
 * Prepares surface for painting, implemented by
 * child implementation.
 clientCount++;
 // In case this is the first Graphics instance
 // write the default values to the buffer
 if(clientCount == 1)
 {
 writeDefaultValuesToBuffer();
 }
 return new Graphics(this, hostBounds );
 }
 /**
 * are created, sync has no effect. This variant always closes
 * the surface session unconditionally
 */
 void sync()
 {
-	sync(true);
+sync(true);
 }
 /**
 * Synchronizes this buffer with the actual target
 * must be called in UI thread. If no Graphics instances
 {
 return;
 }
 // Start surface session if not started yet
-	startFrame(hostBounds.x, hostBounds.y , hostBounds.width , hostBounds.height);
+startFrame(hostBounds.x, hostBounds.y , hostBounds.width , hostBounds.height);
 doRelease();
 bindToHost(gc);
 gc.render(commandBuffer);
 doRelease();
 /**
 * Disposes this instance
 */
 void dispose()
 {
-	if(gc != null)
+if(gc != null)
-	{
+{
 doRelease();
 gc.dispose();
 gc = null;
-	}
+}
 commandBuffer = null;
 }
 void copyArea(int x1, int y1, int width, int height, int x2, int y2, Graphics client)
 {
 gc.copyArea(x1, y1, width, height, x2, y2);
 }
 void fillRect(int x, int y, int w, int h, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION), client);
 gc.fillRect(x, y, w, h);
 }
 void fillRoundRect(int x, int y, int w, int h, int arcW, int arcH, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION), client);
 gc.fillRoundRect(x, y, w, h, arcW, arcH);
 }
 void fillArc(int x, int y, int w, int h, int startAngle, int arcAngle, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION), client);
 gc.fillArc(x, y, w, h, startAngle, arcAngle);
 }
 void fillTriangle(int[] points, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION), client);
 gc.fillPolygon(points);
 }
 void setClip(int x, int y, int w, int h, Graphics client)
 {
-validateAndApplySettings(COORS_TRANSLATION, client);
+validateAndApplySettings(COORDS_TRANSLATION, client);
 // check if given clip is already active in buffer
 if((bufferClip.x == x) && (bufferClip.y == y) &&
 (bufferClip.width == w) && (bufferClip.height== h))
 {
 return;
 gc.setClip(x, y, w, h, false);
 return;
 }
 // translate clip to display coordinates and apply
-Rectangle rect = clipToDisplayCoords(x, y, w, h);
+Rectangle rect = clipToWindowCoords(x, y, w, h);
 if(rect.isEmpty())
 {
 // check is buffer clip is already up to date
 if(bufferClip.isEmpty())
 {
 bufferClip.height = h;
 }
 gc.setClip(rect.x, rect.y, rect.width, rect.height, false);
 }
+void setGraphicsDefaults(Graphics client)
+{
+	validateAndApplySettings((FONT|COLOR|STROKESTYLE|COORDS_TRANSLATION|FORCE_SETTINGS), client);
+}
 void setColor(int r, int g, int b, Graphics client)
 {
 // check if given color is already active in buffer
 if(bufferColor == (Graphics.OPAQUE_ALPHA | (r << 16) | (g << 8) | b))
 {
 bufferTranslateY += yDelta;
 }
 void drawLine(int xStart, int yStart, int xEnd, int yEnd, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|STROKESTYLE), client);
 gc.drawLine(xStart, yStart, xEnd, yEnd);
 }
 void drawRect(int x, int y, int w, int h, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|STROKESTYLE), client);
 gc.drawRect(x, y, w, h);
 }
 void drawRoundRect(int x, int y, int w, int h, int arcW, int arcH, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|STROKESTYLE), client);
 gc.drawRoundRect(x, y, w, h, arcW, arcH);
 }
 void drawArc(int x, int y, int w, int h, int startAngle, int arcAngle, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|STROKESTYLE), client);
 gc.drawArc(x, y, w, h, startAngle, arcAngle);
 }
 void drawString(String string, int x, int y, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|FONT), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|FONT), client);
 gc.drawString(string, x, y, true);
 }
 void drawImage(org.eclipse.swt.internal.qt.graphics.Image image, int x,int y, Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawImage(image, x, y);
 }
 void drawImage(org.eclipse.swt.internal.qt.graphics.Image image, int xDst, int yDst,
 int wDst, int hDst, int xSrc, int ySrc, int wSrc, int hSrc,
 int transform, Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawImage(image, xDst, yDst, wDst, hDst, xSrc, ySrc, wSrc, hSrc, transform);
 }
 void drawRGB(int[] rgb,
 int offset,
 int w,
 int h,
 boolean alpha,
 Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawRGB(rgb, offset, scanlength, x, y, w, h, alpha);
 }
 void drawRGB(int[] rgb,
 int offset,
 int h,
 boolean alpha,
 int manipulation,
 Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawRGB(rgb, offset, scanlength, x, y, w, h, alpha, manipulation);
 }
 void drawRGB(byte[] rgb,
 byte[] transparencyMask,
 int h,
 int manipulation,
 int format,
 Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawRGB(rgb, transparencyMask, offset, scanlength, x, y, w, h, manipulation, format);
 }
 void drawRGB(short[] rgb,
 int offset,
 boolean alpha,
 int manipulation,
 int format,
 Graphics client)
 {
-validateAndApplySettings((CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((CLIP|COORDS_TRANSLATION), client);
 gc.drawRGB(rgb, offset, scanlength, x, y, w, h, alpha, manipulation, format);
 }
 void drawPolygon(int[] points, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION|STROKESTYLE), client);
 gc.drawPolygon(points);
 }
 void fillPolygon(int[] points, Graphics client)
 {
-validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);
+validateAndApplySettings((COLOR|CLIP|COORDS_TRANSLATION), client);
 gc.fillPolygon(points);
 }
 void setARGBColor(int argb, Graphics client)
 {
 WindowSurface getWindowSurface()
 {
 return null;
 }
-/**
+boolean containsDrawnPrimitives() {
-* Translates given rectangle to display/window surface coordinates
+boolean result = false;
+if(commandBuffer != null) {
+result = commandBuffer.containsDrawnPrimitives();
+}
+return result;
+}
+/**
+* Translates given rectangle to window surface coordinates
 * and outlines the clip inside the control bounds.
 *
 * @param x The x-coordinate of the rectangle
 * @param y The y-coordinate of the rectangle
 * @param w The width of the rectangle
 * @param h The height of the rectangle
 *
 */
-private Rectangle clipToDisplayCoords(int x, int y, int w, int h)
+private Rectangle clipToWindowCoords(int x, int y, int w, int h)
 {
 // Bottom-right corner of control bounds in window coordinates
 final int hostX2 = hostBounds.x + hostBounds.width;
 final int hostY2 = hostBounds.y + hostBounds.height;
 // clip in window coordinates
 clipX2 = clipX2Dpy < hostBounds.x ? (clipX2 + (hostBounds.x - clipX1Dpy)) : clipX2;
 clipX2 = clipX2Dpy > hostX2 ? (clipX2 - (clipX1Dpy - hostX2)) : clipX2;
 clipY2 = clipY2Dpy < hostBounds.y ? (clipY2 + (hostBounds.y - clipY1Dpy)) : clipY2;
 clipY2 = clipY2Dpy > hostY2 ? (clipY2 - (clipY1Dpy - hostY2)) : clipY2;
-return new Rectangle(clipX1, clipY1, (clipX2 - clipX1) , (clipY1 - clipY2));
+return new Rectangle(clipX1, clipY1, (clipX2 - clipX1) , (clipY2 - clipY1));
 }
 /**
 * Validates the current settings active in buffer against
 * caller settings and updated needed settings in buffer when
 * @param flags The settings that need to be checked
 * @param client The Graphics instance that made the call
 */
 private void validateAndApplySettings(int flags, Graphics client)
 {
-if(!clientChanged(client))
+if(!clientChanged(client) && (FORCE_SETTINGS & flags) == 0)
 {
 return;
 }
 if((COLOR & flags) != 0)
 {
 client.currentClip[1] != bufferClip.y &&
 client.currentClip[2] != bufferClip.width &&
 client.currentClip[3] != bufferClip.height)
 {
-Rectangle rect = clipToDisplayCoords(client.currentClip[0], client.currentClip[1],
+Rectangle rect = clipToWindowCoords(client.currentClip[0], client.currentClip[1],
 client.currentClip[2], client.currentClip[3]);
 gc.setClip(rect.x, rect.y, rect.width, rect.height, false);
 bufferClip.x = client.currentClip[0];
 bufferClip.y = client.currentClip[1];
 bufferClip.width = client.currentClip[2];
 bufferClip.height = client.currentClip[3];
 }
 }
-if((COORS_TRANSLATION & flags) != 0)
+if((COORDS_TRANSLATION & flags) != 0)
 {
 if((bufferTranslateX != client.translateX) && (bufferTranslateY != client.translateY))
 {
 gc.translate((client.translateX - bufferTranslateX), (client.translateY - bufferTranslateY));
 bufferTranslateX = client.translateX;
 }
 }
 /**
 * Writes Graphics default values to buffer
+* @param force If true defaults are written unconditionally to buffer,
+*              otherwise only values that different than the ones in buffer
+*              are written
 */
 private void writeDefaultValuesToBuffer()
 {
 int handle = Font.getESWTFont(defaultFont).handle;
 gc.setFont(handle);

changeset 47	f40128debb5d
parent 35	85266cc22c7f
child 78	71ad690e91f5