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

equal deleted inserted replaced

-:dc7c549001d5
+:85266cc22c7f
 new CanvasShellMouseListener();
 // Canvas Graphics object passed to paint(Graphics g)
 private Graphics canvasGraphics;
+// Graphics object for transferring return values
+// from UI thread
+private Graphics tempGraphics;
 // Graphics command buffer for this instance
-	CanvasBuffer graphicsBuffer;
+	Buffer graphicsBuffer;
 //On Screen Keypad
 //private Composite keypadComposite;
 private CanvasKeypad onScreenkeypad;
 private int oskHeight;
 super(null);
 repaintLock = new Object();
 cleanupLock = new Object();
 construct();
 keysPressed = new Vector();
-graphicsBuffer = new CanvasBuffer(this, getContentComp());
 }
 /* (non-Javadoc)
 * @see Displayable#eswtConstructShell(int)
 */
 // On screen keypad is required, On devices without keyboard it can
 // be either navigation keys or navigation and game keys
 onScreenkeypad = new CanvasKeypad(this, canvasComp, oskAttr);
 }
+// create graphics buffer
+graphicsBuffer = Buffer.createInstance(this, canvasComp);
 return canvasComp;
 }
 /* (non-Javadoc)
 /**
 * Get game canvas frame buffer graphics.
 */
 final Graphics getGameBufferGraphics()
 {
-return graphicsBuffer.getGraphics();
+	tempGraphics = null;
+		ESWTUIThreadRunner.safeSyncExec(new Runnable()
+		{
+			public void run()
+			{
+				tempGraphics =  graphicsBuffer.getGraphics();
+			}
+		});
+	return tempGraphics;
 }
 CanvasKeypad getCanvasKeypad()
 {
 return onScreenkeypad;
 * @param height
 */
 void flushGameBuffer(final int x, final int y, final int width,
 final int height)
 {
-synchronized(graphicsBuffer)
+	synchronized(graphicsBuffer)
 {
-flushGraphicsBuffer(x, y, width, height);
+		ESWTUIThreadRunner.safeSyncExec(new Runnable()
-}
+			{
-}
+				public void run()
+				{
+					graphicsBuffer.sync();
+					graphicsBuffer.blitToDisplay(null, getContentComp());
+				}
+});
+}
+}
 /**
 * Called by ShellListener when shell gets activated.
 */
 void handleShellActivatedEvent()
 */
 void eswtHandleResizeEvent(int width, int height)
 {
 super.eswtHandleResizeEvent(width, height);
 // update new bounds to graphicsBuffer
-synchronized(graphicsBuffer)
+// this call must not be synchronized as we
-{
+// cannot use locking in UI thread
 graphicsBuffer.setControlBounds(getContentComp());
-}
 synchronized(cleanupLock)
 {
 cleanupNeeded = true;
 }
 }
 /*
 * UI thread calls. Paint listener of the eSWT widget.
 */
 class CanvasShellPaintListener implements PaintListener
 {
 public void paintControl(PaintEvent pe)
 {
-// Native toolkit is requesting an update of an area that has
+// Check if we got here from buffer flush
-// become invalid. Can't do anything here because the contents
+	if(graphicsBuffer.isPaintingActive())
-// need to be queried from the MIDlet in another thread by
+	{
-// a paint callback. For this a paint callback event is posted.
+	    graphicsBuffer.blitToDisplay(pe.gc.getGCData().internalGc, null);
-// For a moment the native toolkit thinks that the area has
+	}
-// been validated when in truth it will be painted later after
+	else
-// the paint callback has been executed.
+	{
-EventDispatcher eventDispatcher = EventDispatcher.instance();
+// Native toolkit is requesting an update of an area that has
-LCDUIEvent event = eventDispatcher.newEvent(
+// become invalid. Can't do anything here because the contents
-LCDUIEvent.CANVAS_PAINT_NATIVE_REQUEST,
+// need to be queried from the MIDlet in another thread by
-javax.microedition.lcdui.Canvas.this);
+// a paint callback. For this a paint callback event is posted.
-event.x = pe.x;
+// For a moment the native toolkit thinks that the area has
-event.y = pe.y;
+// been validated when in truth it will be painted later after
-event.width = pe.width;
+// the paint callback has been executed.
-event.height = pe.height;
+EventDispatcher eventDispatcher = EventDispatcher.instance();
-event.widget = pe.widget;
+LCDUIEvent event = eventDispatcher.newEvent(
-eventDispatcher.postEvent(event);
+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);
+	}
 }
 }
 /*
 * Dispatcher thread or the serviceRepaints()-thread calls.
 }
 // Create instance of Graphics if not created yet
 if(canvasGraphics == null)
 {
-canvasGraphics = graphicsBuffer.getGraphics();
+	 ESWTUIThreadRunner.safeSyncExec(new Runnable()
+{
+	    public void run()
+	    {
+canvasGraphics = graphicsBuffer.getGraphics();
+canvasGraphics.setSyncStrategy(Graphics.SYNC_LEAVE_SURFACE_SESSION_OPEN);
+	    }
+});
 }
 // Clean the background if dirty, buffer the operations.
 synchronized(cleanupLock)
 {
 canvasGraphics.setClip(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
 // The callback
 paint(canvasGraphics);
+// Blit frame to display
-// Flush drawn graphics to display
+synchronized(graphicsBuffer)
-synchronized(graphicsBuffer)
+{
-{
+ESWTUIThreadRunner.safeSyncExec(new Runnable()
-flushGraphicsBuffer(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
+{
-}
+	    public void run()
-}
+	    {
+		    if(event.widget.isDisposed())
-private void flushGraphicsBuffer(final int redrawNowX, final int redrawNowY, final int redrawNowW, final int redrawNowH)
+		    {
-{
+			    return;
-ESWTUIThreadRunner.safeSyncExec(new Runnable()
+		    }
-{
+		    graphicsBuffer.sync();
-public void run()
+		    graphicsBuffer.blitToDisplay(null, event.widget);
-{
+}
-graphicsBuffer.setupWindowSurface();
+});
-Rectangle rect = graphicsBuffer.toWindowCoordinates(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
+}
-graphicsBuffer.windowSurface.beginPaint(rect.x, rect.y, rect.width, rect.height);
-graphicsBuffer.sync();
-graphicsBuffer.windowSurface.endPaint();
-graphicsBuffer.windowSurface.flush();
-}
-});
 }
 /*
 * UI thread calls to flush the command buffer of a graphics context.
 */

changeset 35	85266cc22c7f
parent 26	dc7c549001d5
child 47	f40128debb5d
child 49	35baca0e7a2e