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

equal deleted inserted replaced

-:98ccebc37403
+:dc7c549001d5
 import org.eclipse.swt.events.*;
 import org.eclipse.swt.widgets.*;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.graphics.*;
 import org.eclipse.swt.internal.extension.CompositeExtension;
+import org.eclipse.swt.internal.qt.graphics.WindowSurface;
 /**
 * The abstract <code>Canvas</code> class is designed to handle low-level
 * graphical operations as well as low-level key and pointer events. Canvas is
 * derived from <code>Displayable</code> so the application can switch between
 new CanvasShellPaintListener();
 private CanvasShellMouseListener mouseListener =
 new CanvasShellMouseListener();
-// Canvas Graphics object passed to paint(Graphics g).
+// Canvas Graphics object passed to paint(Graphics g)
-// Graphics has its own back-buffer for double buffering.
 private Graphics canvasGraphics;
+// Graphics command buffer for this instance
+	CanvasBuffer graphicsBuffer;
 //On Screen Keypad
 //private Composite keypadComposite;
 private CanvasKeypad onScreenkeypad;
 private int oskHeight;
 // Vector of flags that a certain key was pressed but was not released.
 // Used to implement keyRepeated since eSWT does not support
 // key repeat events.
 private Vector keysPressed;
-// Canvas modes
-private static final int MODE_UNINITIALIZED = 0;
-private static final int MODE_NORMAL = 1;
-private static final int MODE_BUFFER_FLUSH = 2;
-private static final int MODE_GAME_BUFFER_FLUSH = 3;
-private int canvasMode = MODE_UNINITIALIZED;
 private boolean suppressGameKeys;
 private boolean suppressDragEvent;
 private boolean cleanupNeeded;
 private Object cleanupLock;
 private boolean noBackground;
 private int gameKeyState;
-private Graphics gameBufferGraphics;
-// lock created by graphics object for serializing
-// flushing against graphics buffer writing
-private Object flushLock;
 private Timer timer = new Timer();
 private CanvasTimerTask timerTask;
 private static final int DEFAULT_TIMEOUT = 500;
 private static final int DEFAULT_TWIPS = 200;
 {
 super(null);
 repaintLock = new Object();
 cleanupLock = new Object();
 construct();
-canvasGraphics = new Graphics();
-canvasMode = MODE_UNINITIALIZED;
 keysPressed = new Vector();
+graphicsBuffer = new CanvasBuffer(this, getContentComp());
 }
 /* (non-Javadoc)
 * @see Displayable#eswtConstructShell(int)
 */
 {
 this.suppressGameKeys = suppressKeys;
 }
 /**
-* Update game buffer graphics.
-*/
-final void eswtUpdateGameBufferGraphics()
-{
-if(gameBufferGraphics == null)
-{
-gameBufferGraphics = new Graphics();
-gameBufferGraphics.initBuffered(this, 0, 0, getWidth(), getHeight());
-flushLock = gameBufferGraphics.getLock();
-}
-}
-/**
 * Get game canvas frame buffer graphics.
 */
 final Graphics getGameBufferGraphics()
 {
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+return graphicsBuffer.getGraphics();
-{
-public void run()
-{
-eswtUpdateGameBufferGraphics();
-}
-});
-return gameBufferGraphics;
 }
 CanvasKeypad getCanvasKeypad()
 {
 return onScreenkeypad;
 * @param height
 */
 void flushGameBuffer(final int x, final int y, final int width,
 final int height)
 {
-synchronized(flushLock)
+synchronized(graphicsBuffer)
 {
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+flushGraphicsBuffer(x, y, width, height);
-{
-public void run()
-{
-canvasMode = MODE_GAME_BUFFER_FLUSH;
-((CompositeExtension)getContentComp()).redrawNow(x, y, width, height);
-gameBufferGraphics.resetCommandBuffer();
-canvasMode = MODE_NORMAL;
-}
-});
 }
 }
 /**
 * Called by ShellListener when shell gets activated.
 {
 super.handleShellActivatedEvent();
 // reset the game key state
 gameKeyState = 0;
-canvasMode = MODE_NORMAL;
 synchronized(cleanupLock)
 {
 cleanupNeeded = true;
 }
 * UI thread calls
 */
 void eswtHandleResizeEvent(int width, int height)
 {
 super.eswtHandleResizeEvent(width, height);
-canvasMode = MODE_NORMAL;
+// update new bounds to graphicsBuffer
+synchronized(graphicsBuffer)
+{
+graphicsBuffer.setControlBounds(getContentComp());
+}
 synchronized(cleanupLock)
 {
 cleanupNeeded = true;
 }
 }
 * UI thread calls
 */
 void eswtHandleEvent(Event e)
 {
 super.eswtHandleEvent(e);
 if(e.type == SWT.KeyDown)
 {
 doKeyPressed(e.keyCode);
 }
 else if(e.type == SWT.KeyUp)
 {
 doKeyReleased(e.keyCode);
 }
 }
 /*
 * UI thread calls. Paint listener of the eSWT widget.
 */
 class CanvasShellPaintListener implements PaintListener
 {
 public void paintControl(PaintEvent pe)
 {
-switch(canvasMode)
+// Native toolkit is requesting an update of an area that has
-{
+// become invalid. Can't do anything here because the contents
-case MODE_BUFFER_FLUSH:
+// need to be queried from the MIDlet in another thread by
-// Paint event initiated by us to paint the Canvas.
+// a paint callback. For this a paint callback event is posted.
-doBufferFlush(pe, canvasGraphics);
+// For a moment the native toolkit thinks that the area has
-break;
+// been validated when in truth it will be painted later after
-case MODE_GAME_BUFFER_FLUSH:
+// the paint callback has been executed.
-// Paint event initiated by us to paint the GameCanvas.
+EventDispatcher eventDispatcher = EventDispatcher.instance();
-doBufferFlush(pe, gameBufferGraphics);
+LCDUIEvent event = eventDispatcher.newEvent(
-break;
+LCDUIEvent.CANVAS_PAINT_NATIVE_REQUEST,
-case MODE_NORMAL:
+javax.microedition.lcdui.Canvas.this);
-// Native toolkit is requesting an update of an area that has
+event.x = pe.x;
-// become invalid. Can't do anything here because the contents
+event.y = pe.y;
-// need to be queried from the MIDlet in another thread by
+event.width = pe.width;
-// a paint callback. For this a paint callback event is posted.
+event.height = pe.height;
-// For a moment the native toolkit thinks that the area has
+event.widget = pe.widget;
-// been validated when in truth it will be painted later after
+eventDispatcher.postEvent(event);
-// the paint callback has been executed.
-EventDispatcher eventDispatcher = EventDispatcher.instance();
-LCDUIEvent event = eventDispatcher.newEvent(
-LCDUIEvent.CANVAS_PAINT_NATIVE_REQUEST,
-javax.microedition.lcdui.Canvas.this);
-event.x = pe.x;
-event.y = pe.y;
-event.width = pe.width;
-event.height = pe.height;
-event.widget = pe.widget;
-eventDispatcher.postEvent(event);
-break;
-}
 }
 }
 /*
 * Dispatcher thread or the serviceRepaints()-thread calls.
 {
 return;
 }
 }
-// Prepare the GC's buffer if not done yet
+// Create instance of Graphics if not created yet
-if(canvasGraphics.getCommandBuffer() == null)
+if(canvasGraphics == null)
 {
-canvasGraphics.initBuffered(this, event.x, event.y, event.width, event.height);
+canvasGraphics = graphicsBuffer.getGraphics();
 }
 // Clean the background if dirty, buffer the operations.
 synchronized(cleanupLock)
 {
 canvasGraphics.setClip(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
 // The callback
 paint(canvasGraphics);
-// Wait until the UI thread is available. Then in the UI thread
-// synchronously send a paint event.
+// Flush drawn graphics to display
+synchronized(graphicsBuffer)
+{
+flushGraphicsBuffer(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
+}
+}
+private void flushGraphicsBuffer(final int redrawNowX, final int redrawNowY, final int redrawNowW, final int redrawNowH)
+{
 ESWTUIThreadRunner.safeSyncExec(new Runnable()
 {
 public void run()
 {
-if(event.widget.isDisposed())
+graphicsBuffer.setupWindowSurface();
-{
+Rectangle rect = graphicsBuffer.toWindowCoordinates(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
-return;
+graphicsBuffer.windowSurface.beginPaint(rect.x, rect.y, rect.width, rect.height);
-}
+graphicsBuffer.sync();
+graphicsBuffer.windowSurface.endPaint();
-canvasMode = MODE_BUFFER_FLUSH;
+graphicsBuffer.windowSurface.flush();
-((CompositeExtension) event.widget)
-.redrawNow(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
-canvasGraphics.resetCommandBuffer();
-canvasMode = MODE_NORMAL;
 }
 });
 }
 /*
 * UI thread calls to flush the command buffer of a graphics context.
 */
 private final void doBufferFlush(PaintEvent event, Graphics graphics)
 {
-event.gc.getGCData().internalGc.render(graphics.getCommandBuffer());
+//  event.gc.getGCData().internalGc.render(graphics.getCommandBuffer());
 }
 /*
 * UI thread calls.
 */
 repaintY2 = repaintY2 < h ? repaintY2 : h;
 return valid;
 }
+/**
+* Disposes this instance
+* Called when finalizer is destroying this instance.
+*/
+void dispose()
+{
+super.dispose();
+ESWTUIThreadRunner.safeSyncExec(new Runnable()
+{
+public void run()
+{
+if(graphicsBuffer != null)
+{
+graphicsBuffer.dispose();
+graphicsBuffer = null;
+}
+}
+});
+}
 class CanvasTimerTask extends TimerTask
 {
 public void run()
 {

changeset 26	dc7c549001d5
parent 23	98ccebc37403
child 35	85266cc22c7f