/*

* 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".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package javax.microedition.lcdui;

import java.util.Enumeration;

import java.util.Vector;

import java.util.Timer;

import java.util.TimerTask;

import javax.microedition.lcdui.game.GameCanvas;

import javax.microedition.lcdui.EventDispatcher.LCDUIEvent;

import org.eclipse.ercp.swt.mobile.MobileShell;

import org.eclipse.swt.SWT;

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.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

 * derived from <code>Displayable</code> so the application can switch between

 * different <code>Canvases</code> together with other

 * <code>Displayables</code>.

 * <p>

 * <b>Canvas</b> the abstract method <code>paint(Graphics g)</code> designed

 * to be implemented by the developer.

 */

public abstract class Canvas extends Displayable

{

    /**

     *  Constant for <code>UP</code> game action.

     */

    public static final int UP = 1;

    /**

     * Constant for <code>DOWN</code> game action.

     */

    public static final int DOWN = 6;

    /**

     * Constant for <code>LEFT</code> game action.

     */

    public static final int LEFT = 2;

    /**

     * Constant for <code>RIGHT</code> game action.

     */

    public static final int RIGHT = 5;

    /**

     * Constant for <code>FIRE</code> game action.

     */

    public static final int FIRE = 8;

    /**

     * Constant for general "<code>A</code>" game action.

     */

    public static final int GAME_A = 9;

    /**

     * Constant for general "<code>B</code>" game action.

     */

    public static final int GAME_B = 10;

    /**

     * Constant for general "<code>C</code>" game action.

     */

    public static final int GAME_C = 11;

    /**

     * Constant for general "<code>D</code>" game action.

     */

    public static final int GAME_D = 12;

    /**

     * Key code for <code>0</code> key.

     */

    public static final int KEY_NUM0 = 48;

    /**

     * Key code for <code>1</code> key.

     */

    public static final int KEY_NUM1 = 49;

    /**

     * Key code for <code>2</code> key.

     */

    public static final int KEY_NUM2 = 50;

    /**

     * Key code for <code>3</code> key.

     */

    public static final int KEY_NUM3 = 51;

    /**

     * Key code for <code>4</code> key.

     */

    public static final int KEY_NUM4 = 52;

    /**

     * Key code for <code>5</code> key.

     */

    public static final int KEY_NUM5 = 53;

    /**

     * Key code for <code>6</code> key.

     */

    public static final int KEY_NUM6 = 54;

    /**

     * Key code for <code>7</code> key.

     */

    public static final int KEY_NUM7 = 55;

    /**

     * Key code for <code>8</code> key.

     */

    public static final int KEY_NUM8 = 56;

    /**

     * Key code for <code>9</code> key.

     */

    public static final int KEY_NUM9 = 57;

    /**

     * Key code for <code>*</code> key.

     */

    public static final int KEY_STAR = 42;

    /**

     * Key code for <code>#</code> key.

     */

    public static final int KEY_POUND = 35;

    private static final int GAME_CANVAS = 1;

    private static final int NO_BACKGROUND = 1 << 1;

    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 REPAINT_PENDING = 1 << 7;

    private static final int SELECTIONKEY_COMPATIBILITY = 1 << 8;

    private static final int CURRENTLY_VISIBLE = 1 << 9;

    // Listeners for various events.

    private org.eclipse.swt.events.PaintListener paintListener =

        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;

    // 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;

    private int gameKeyState;

    private static int objectCount;

    private static Shell sharedShell;

    private Shell mShell;

    private Composite canvasComp;

    private Label tickerLabel;

    private int mode;

    private Object modeLock;

    private Object repaintLock;

    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;

    private int pointerDownX;

    private int pointerDownY;

    private int twips;

    private int timeout;

    private int repaintX1;

    private int repaintY1;

    private int repaintX2;

    private int repaintY2;

    /**

     * Constructs <code>Canvas</code> object.

     */

    public Canvas()

    {

        super(null);

        synchronized(this)

        {

            objectCount++;

        }

        modeLock = new Object();

        repaintLock = new Object();

        flushLock = new Object();

        setMode(GAME_CANVAS, this instanceof GameCanvas);

        construct();

        keysPressed = new Vector();

    }

    /**

     * Disposes this instance

     * Called when finalizer is destroying this instance.

     */

    void dispose()

    {

        ESWTUIThreadRunner.update(getClass().getName(), -1);

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                if(graphicsBuffer != null)

                {

                    graphicsBuffer.dispose();

                    graphicsBuffer = null;

                }

                synchronized(this)

                {

                    objectCount--;

                    if((objectCount == 0) || isMode(GAME_CANVAS))

                    {

                        mShell.dispose();

                        sharedShell = null;

                        sharedKeypad = null;

                    }

                    else

                    {

                        Ticker ticker = getTicker();

                        if (ticker != null)

                        {

                            ticker.removeLabel(tickerLabel);

                        }

                        if(tickerLabel != null)

                        {

                            tickerLabel.dispose();

                        }

                        canvasComp.dispose();

                    }

                }

            }

        });

    }

    /* (non-Javadoc)

     * @see Displayable#eswtConstructShell(int)

     */

    Shell eswtConstructShell(int style)

    {

        if(isMode(GAME_CANVAS))

        {

        }

        else

        {

            if(sharedShell == null)

            {

            }

            mShell = sharedShell;

        }

        // Give the Shell the maximized size already before it becomes visible

        // so that it will return the correct size.

        mShell.setBounds(org.eclipse.swt.widgets.Display.getCurrent().getClientArea());

        // 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),

     * it continues running from position where it was. Otherwise

     * it will start running from beginning when this method returns.

     *

     * @param newTicker New ticker. If null, current ticker is removed.

     */

    public void setTicker(Ticker newTicker)

    {

        super.setTicker(newTicker);

        ESWTUIThreadRunner.syncExec(new Runnable()

        {

            public void run()

            {

                tickerLabel.setVisible(isMode(CURRENTLY_VISIBLE));

            }

        });

    }

    /**

     * Creates singleton Label instance used by Ticker.

     * Creates tickerLabel on shell and sets the visibility of the same.

     */

    Label getTickerLabel()

    {

        tickerLabel = super.getTickerLabel();

        if (!isMode(CURRENTLY_VISIBLE))

        {

            ESWTUIThreadRunner.syncExec(new Runnable()

            {

                public void run()

                {

                    tickerLabel.setVisible(false);

                }

            });

        }

        return tickerLabel;

    }

    /* (non-Javadoc)

     * @see Displayable#eswtConstructContent(int)

     */

    Composite eswtConstructContent(int style)

    {

        // Get JAD attribute

        setMode(NO_BACKGROUND, !JadAttributeUtil.isValue(JadAttributeUtil.ATTRIB_NOKIA_UI_ENHANCEMENT,

                                                JadAttributeUtil.VALUE_CANVAS_HAS_BACKGROUND));

        if(isMode(NO_BACKGROUND))

        {

            style |= SWT.NO_BACKGROUND;

        }

        // Get JAD attribute for S60 Selection Key Compatibility

        setMode(SELECTIONKEY_COMPATIBILITY, JadAttributeUtil.isValue(JadAttributeUtil.ATTRIB_NOKIA_MIDLET_S60_SELECTION_KEY_COMPATIBILITY,

                                    JadAttributeUtil.VALUE_TRUE));

        // Get JAD attribute for MIDlet Tap Detection

        String tapAttr = JadAttributeUtil.getValue(JadAttributeUtil.ATTRIB_NOKIA_MIDLET_TAP_DETECTION_OPTIONS);

        if(tapAttr != null)

        {

            if(tapAttr.indexOf(',') == -1)

            {

                setDefaultTapValues();

            }

            else

            {

                String twipString = tapAttr.substring(0, tapAttr.indexOf(',')).trim();

                String timeoutString = tapAttr.substring(tapAttr.indexOf(',') + 1, tapAttr.length()).trim();

                try

                {

                    twips = Integer.parseInt(twipString);

                    timeout = Integer.parseInt(timeoutString);

                    // Check for Negative Values

                    if((twips < 0) && (timeout < 0))

                    {

                        setDefaultTapValues();

                    }

                    if((twips == 0)  && (timeout == 0))

                    {

                        setMode(DISABLE_TAPDETECTION, true);

                    }

                    // if any one of the value is zero, set defaults

                    if(!((twips != 0) && (timeout != 0)))

                    {

                        setDefaultTapValues();

                    }

                }

                catch(NumberFormatException e)

                {

                    // Alpha Numeric Values of Timeouts and Timeout

                    setDefaultTapValues();

                }

            }

        }

        else

        {

            setDefaultTapValues();

        }

        canvasComp = super.eswtConstructContent(style);

        canvasComp.setVisible(false);

        createOnScreenKeypad();

        return canvasComp;

    }

    void eswtInitGraphics() {

        // create graphics buffer

       graphicsBuffer = Buffer.createInstance(this, canvasComp);

    }

    /**

     * 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

        String oskAttr = JadAttributeUtil

                         .getValue(JadAttributeUtil.ATTRIB_NOKIA_MIDLET_ON_SCREEN_KEYPAD);

        if(oskAttr != null

                && (!oskAttr.equalsIgnoreCase(JadAttributeUtil.VALUE_NO))

                && ((oskAttr

                     .equalsIgnoreCase(JadAttributeUtil.VALUE_GAMEACTIONS)) || (oskAttr

                             .equalsIgnoreCase(JadAttributeUtil.VALUE_NAVIGATIONKEYS))))

        {

            // On screen keypad is required, On devices without keyboard it can

            // be either navigation keys or navigation and game keys

            if(isMode(GAME_CANVAS))

            {

                onScreenkeypad = new CanvasKeypad(this, oskAttr);

                return onScreenkeypad;

            }

            if(sharedKeypad == null)

            {

                sharedKeypad = new CanvasKeypad(this, oskAttr);

            }

            onScreenkeypad = sharedKeypad;

            return onScreenkeypad;

        }

        return null;

    }

    Rectangle eswtLayoutShellContent()

    {

        Rectangle shellArea = mShell.getClientArea();

        int oskHeight = (onScreenkeypad != null ? onScreenkeypad.getHeight() : 0);

        int tickerHeight = (tickerLabel != null ? tickerLabel.getBounds().height : 0);

        canvasComp.setBounds(0, tickerHeight,

                              shellArea.width, shellArea.height - tickerHeight - oskHeight);

        canvasComp.setFocus();

        return canvasComp.getClientArea();

    }

    /* (non-Javadoc)

     * @see Displayable#eswtHandleShowCurrentEvent()

     */

    void eswtHandleShowCurrentEvent()

    {

        setMode(CURRENTLY_VISIBLE, true);

        eswtSetTitle();

        ((MobileShell) mShell).setFullScreenMode(isMode(FULLSCREEN_MODE));

        if(onScreenkeypad != null)

        {

            if(!isMode(GAME_CANVAS))

            {

                onScreenkeypad.setCurrentCanvas(this);

            }

            onScreenkeypad.setFullScreenMode(isMode(FULLSCREEN_MODE));

        }