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

equal deleted inserted replaced

-:f40128debb5d
+:e0d6e9bd3ca7
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 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;
+import org.eclipse.swt.internal.extension.MobileShellExtension;
+import org.eclipse.swt.internal.qt.SymbianWindowVisibilityListener;
 /**
 * 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
 new CanvasShellPaintListener();
 private CanvasShellMouseListener mouseListener =
 new CanvasShellMouseListener();
+private CanvasShellVisibilityListener shellVisibilityListener =
+new CanvasShellVisibilityListener();
 // 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
 Buffer graphicsBuffer;
 //On Screen Keypad
 //private Composite keypadComposite;
 private CanvasKeypad onScreenkeypad;
 private static CanvasKeypad sharedKeypad;
 private int oskHeight;
 setMode(GAME_CANVAS, this instanceof GameCanvas);
 construct();
 keysPressed = new Vector();
 }
 /**
 * Disposes this instance
 * Called when finalizer is destroying this instance.
 */
 void dispose()
 }
 synchronized(this)
 {
 objectCount--;
 if((objectCount == 0) || isMode(GAME_CANVAS))
 {
 mShell.dispose();
 sharedShell = null;
 sharedKeypad = null;
 }
 }
 });
 }
 /* (non-Javadoc)
 * @see Displayable#eswtConstructShell(int)
 */
 Shell eswtConstructShell(int style)
 {
 // Make the Shell maximized. On Symbian it's automatically maximized
 // so this has no effect but on other platforms explicit maximizing
 // might be needed.
 mShell.setMaximized(true);
 return mShell;
 }
 /**
 * Sets ticker. If ticker is added already to other canvas(es),
 setDefaultTapValues();
 }
 canvasComp = super.eswtConstructContent(style);
 canvasComp.setVisible(false);
 createOnScreenKeypad();
-return canvasComp;
-}
-void eswtInitGraphics() {
 // create graphics buffer
 graphicsBuffer = Buffer.createInstance(this, canvasComp);
-}
+return canvasComp;
-/**
+}
-* Creates OSK(OnScreenKeypad), shared Keypad will be created for Canvas,
+/**
+* Creates OSK(OnScreenKeypad), shared Keypad will be created for Canvas,
 * seperate OSK will be created for each GameCanvas.
 */
 CanvasKeypad createOnScreenKeypad()
 {
 // Read the on screen keypad settings from the jad attribute
 }
 return null;
 }
 Rectangle eswtLayoutShellContent()
 {
 Rectangle shellArea = mShell.getClientArea();
 int oskHeight = (onScreenkeypad != null ? onScreenkeypad.getHeight() : 0);
 int tickerHeight = (tickerLabel != null ? tickerLabel.getBounds().height : 0);
 shellArea.width, shellArea.height - tickerHeight - oskHeight);
 canvasComp.setFocus();
 return canvasComp.getClientArea();
 }
 /* (non-Javadoc)
 * @see Displayable#eswtHandleShowCurrentEvent()
 */
 void eswtHandleShowCurrentEvent()
 addCommands();
 super.eswtHandleShowCurrentEvent();
 getContentComp().addPaintListener(paintListener);
 getContentComp().addMouseListener(mouseListener);
 getContentComp().addMouseMoveListener(mouseListener);
+((MobileShellExtension)getShell()).addSymbianWindowVisibilityListener(shellVisibilityListener);
 }
 /* (non-Javadoc)
 * @see Displayable#eswtHandleHideCurrentEvent()
 */
 removeCommands();
 super.eswtHandleHideCurrentEvent();
 getContentComp().removePaintListener(paintListener);
 getContentComp().removeMouseListener(mouseListener);
 getContentComp().removeMouseMoveListener(mouseListener);
+((MobileShellExtension)getShell()).removeSymbianWindowVisibilityListener(shellVisibilityListener);
 }
 /**
 * eSWT callback to add a Command.
 */
 {
 tickerLabel.pack();
 tickerLabel.setLocation(Integer.MIN_VALUE, 0);
 }
-					if(isMode(CURRENTLY_VISIBLE))
+if(isMode(CURRENTLY_VISIBLE))
-					{
+{
-	                    tickerLabel.setVisible(!isMode(FULLSCREEN_MODE));
+tickerLabel.setVisible(!isMode(FULLSCREEN_MODE));
-					}
+}
 }
 if(isMode(CURRENTLY_VISIBLE))
 {
 ((MobileShell)mShell).setFullScreenMode(isMode(FULLSCREEN_MODE));
 }
 });
 return (super.getHeight() - oskHeight);
 }
 /**
 * Callback to be implemented by the application to render the
 * <code>Canvas</code>. The clip region of <code>Graphics</code> object
 * specifies the area that needs to be updated. All the region has to be
 final void initGameCanvas(boolean suppressKeys)
 {
 setMode(SUPPRESS_GAMEKEYS, suppressKeys);
 }
 /**
 * Gets composite that contains Canvas content.
 *
 * @return Composite.
 */
 Composite getContentComp()
 {
 return canvasComp;
 }
 /**
 * Get game canvas frame buffer graphics.
 */
 final Graphics getGameBufferGraphics()
 {
 tempGraphics = null;
 ESWTUIThreadRunner.safeSyncExec(new Runnable()
 {
 public void run()
 {
 tempGraphics =  graphicsBuffer.getGraphics();
 }
 * @param height
 */
 void flushGameBuffer(final int x, final int y, final int width,
 final int height)
 {
 // This is serialized with the
 // paint callback processing
 synchronized(flushLock)
 {
 synchronized(graphicsBuffer)
 {
 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
 // this call must not be synchronized as we
 // cannot use locking in UI thread
 graphicsBuffer.setControlBounds(getContentComp());
 synchronized(cleanupLock)
 {
 setMode(CLEANUP_NEEDED, true);
 class CanvasShellPaintListener implements PaintListener
 {
 public void paintControl(PaintEvent pe)
 {
 // Check if we got here from buffer flush
 if(graphicsBuffer.isPaintingActive())
 {
 graphicsBuffer.blitToDisplay(pe.gc.getGCData().internalGc, null);
 }
 else
 {
 {
 synchronized(flushLock)
 {
 // It's possible that this Canvas is sent to background
 // right after the visibility is checked here, however
 // it is okay as in such case we just do one extra paint
 // callback. The visibility change cannot be synchronized with
 // this method, since it would expose implementation to deadlock
 if(!isMode(CURRENTLY_VISIBLE))
 {
 return;
 }
 // Decide the area going to be painted by the callback.
 final int redrawNowX;
 final int redrawNowY;
 final int redrawNowW;
 final int redrawNowH;
 // The callback
 paint(canvasGraphics);
 // Blit frame to display
 synchronized(graphicsBuffer)
 {
 ESWTUIThreadRunner.safeSyncExec(new Runnable()
 {
 public void run()
 {
 if(event.widget.isDisposed())
 {
 EventDispatcher.instance().postEvent(event);
 }
 }
 /*
 * UI thread calls.
 */
 void doKeyReleased(int keyCode)
 {
 public void run()
 {
 setMode(SUPPRESS_DRAGEVENT, false);
 }
 }
+class CanvasShellVisibilityListener implements SymbianWindowVisibilityListener
+{
+public void handleSymbianWindowVisibilityChange(Widget widget, boolean visible) {
+if (javax.microedition.lcdui.Canvas.this.getShell() == widget)
+{
+graphicsBuffer.getWindowSurface().handleSymbianWindowVisibilityChange(visible);
+}
+}
+}
 }

changeset 48	e0d6e9bd3ca7
parent 47	f40128debb5d
child 61	bf7ee68962da