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

equal deleted inserted replaced

-:4ad59aaee882
+:2f468c1958d0
 private static final int FULLSCREEN_MODE = 1 << 2;
 private static final int DISABLE_TAPDETECTION = 1 << 3;
 private static final int SUPPRESS_GAMEKEYS = 1 << 4;
 private static final int SUPPRESS_DRAGEVENT = 1 << 5;
-private static final int CLEANUP_NEEDED = 1 << 6;
 private static final int REPAINT_PENDING = 1 << 7;
 private static final int SELECTIONKEY_COMPATIBILITY = 1 << 8;
 private static final int CURRENTLY_VISIBLE = 1 << 9;
 private Composite canvasComp;
 private Label tickerLabel;
 private int mode;
 private Object modeLock;
-private Object cleanupLock;
 private Object repaintLock;
 private Object flushLock;
 private Timer timer = new Timer();
 private CanvasTimerTask timerTask;
 objectCount++;
 }
 modeLock = new Object();
 repaintLock = new Object();
-cleanupLock = new Object();
 flushLock = new Object();
 setMode(GAME_CANVAS, this instanceof GameCanvas);
 construct();
 keysPressed = new Vector();
 }
 */
 Shell eswtConstructShell(int style)
 {
 if(isMode(GAME_CANVAS))
 {
-mShell = super.eswtConstructShell(style);
+mShell = super.eswtConstructShell(style|SWT.NO_BACKGROUND);
 }
 else
 {
 if(sharedShell == null)
 {
-sharedShell = super.eswtConstructShell(style);
+sharedShell = super.eswtConstructShell(style|SWT.NO_BACKGROUND);
 }
 mShell = sharedShell;
 }
 // Give the Shell the maximized size already before it becomes visible
 }
 /**
 * Issues the request to repaint the whole Canvas.
 */
-public void repaint()
+public final void repaint()
 {
 repaint(0, 0, getWidth(), getHeight());
 }
 /**
 * @param x - left bound of the rectangle to redraw.
 * @param y - top bound of the rectangle to redraw.
 * @param width - width of the rectangle to redraw.
 * @param height - height of the rectangle to redraw.
 */
-public void repaint(int x, int y, int width, int height)
+public final void repaint(int x, int y, int width, int height)
 {
 // Paint callback event is posted without any invalid area info.
 // Invalid area info is kept in the member variables. Only one event
 // per Canvas is added to the queue. If there are more repaint() calls
 // before the already posted event has been served those are merged
 {
 return true;
 }
 /**
-* Returns game action for a specified key code.
+* Returns game action associated with key code.
 *
 * @param keyCode Key code to map to game action.
-* @return Game action for a a specified key code or
+* @return game action corresponding to key, or 0 if none
-*         IllegalArgumentException.
+* @throws IllegalArgumentException if keyCode is not a valid
 */
-public int getGameAction(int keyCode)
+public int getGameAction(int aKeyCode)
 {
-return KeyTable.getGameAction(keyCode);
+if (aKeyCode == 0)
+{
+throw new IllegalArgumentException(
+MsgRepository.CANVAS_EXCEPTION_INVALID_KEY_CODE);
+}
+return KeyTable.getGameAction(aKeyCode);
 }
 /**
 * Returns the key code specific for a certain game action.
 *
 * @param gameAction - game action to be mapped to the key code.
 * @return Key code that is mapped to the specified game action.
-*/
+* @throws IllegalArgumentException for not valid gameAction
-public int getKeyCode(int gameAction)
+*/
-{
+public int getKeyCode(int aGameAction)
-return KeyTable.getKeyCode(gameAction);
+{
+int keyCode = KeyTable.getKeyCode(aGameAction);
+if (keyCode == 0)
+{
+throw new IllegalArgumentException(
+MsgRepository.CANVAS_EXCEPTION_INVALID_GAME_ACTION);
+}
+return keyCode;
 }
 /**
 * Returns the key name specific for a certain key code.
 *
 * @param keyCode - key name to get the name of.
 * @return String that contains textual name of the key specified by the key
 *         code.
 */
-public String getKeyName(int keyCode)
+public String getKeyName(int aKeyCode)
 {
-return KeyTable.getKeyName(keyCode);
+return KeyTable.getKeyName(aKeyCode);
 }
 /**
 * Callback to be implemented by the application to render the
 * <code>Canvas</code>. The clip region of <code>Graphics</code> object
 super.handleShellActivatedEvent();
 // reset the game key state
 gameKeyState = 0;
-synchronized(cleanupLock)
-{
-setMode(CLEANUP_NEEDED, true);
-}
 LCDUIEvent event = EventDispatcher.instance().newEvent(LCDUIEvent.CANVAS_SHOWNOTIFY, this);
 EventDispatcher.instance().postEvent(event);
 }
 /**
 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);
-}
 }
 /*
 * UI thread calls
 */
 canvasGraphics = graphicsBuffer.getGraphics();
 canvasGraphics.setSyncStrategy(Graphics.SYNC_LEAVE_SURFACE_SESSION_OPEN);
 }
 // Clean the background if dirty, buffer the operations.
-synchronized(cleanupLock)
+if(isMode(NO_BACKGROUND) && event.type == LCDUIEvent.CANVAS_PAINT_NATIVE_REQUEST)
 {
-if(isMode(CLEANUP_NEEDED) && isMode(NO_BACKGROUND))
+canvasGraphics.setClip(event.x, event.y, event.width, event.height);
-{
+canvasGraphics.cleanBackground(new Rectangle(event.x, event.y, event.width, event.height));
-// UI thread can change the contentArea object reference at
-// any time. Store the object reference locally to ensure it
-// points to the same rectangle all the time.
-Rectangle contentArea = getContentArea();
-canvasGraphics.setClip(contentArea.x, contentArea.y,
-contentArea.width, contentArea.height);
-canvasGraphics.cleanBackground(contentArea);
-setMode(CLEANUP_NEEDED, false);
-}
 }
 // Clip must define the invalid area
 canvasGraphics.reset();
 canvasGraphics.setClip(redrawNowX, redrawNowY, redrawNowW, redrawNowH);
 }
 /**
 * Updates game key states and returns if the key was a game key.
 */
-private boolean updateGameKeyState(int keyCode, boolean addKeyState)
+private boolean updateGameKeyState(int aKeyCode, boolean aAddKeyState)
 {
 // Ignore key repeat events
 if(ESWTUIThreadRunner.getKeyRepeatCount() > 1)
 {
 return true;
 }
 try
 {
-int gameAction = KeyTable.getGameAction(keyCode);
+int gameAction = getGameAction(aKeyCode);
-if(addKeyState)
+boolean result = false;
-{
-// set bitfield
+// Key state should be updated only if game action
-gameKeyState |= (1 << gameAction);
+// is associated with keyCode
-}
+if(gameAction != 0)
-return true;
+{
+if(aAddKeyState)
+{
+// set bitfield
+gameKeyState |= (1 << gameAction);
+}
+result = true;
+}
+return result;
 }
 catch(IllegalArgumentException iae)
 {
 return false;
 }

changeset 79	2f468c1958d0
parent 61	bf7ee68962da