/*

* Copyright (c) 2009 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.Vector;

import java.util.Timer;

import java.util.TimerTask;

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.extension.CompositeExtension;

/**

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

    // Listeners for various events.

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

        new CanvasShellPaintListener();

    private CanvasShellMouseListener mouseListener =

        new CanvasShellMouseListener();

    private Graphics canvasGraphics;

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

    private boolean suppressGameKeys;

    private boolean suppressDragEvent;

    private boolean cleanupNeeded;

    private Object cleanupLock;

    private boolean noBackground;

    private int gameKeyState;

    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 boolean disableTapDetection;

    private boolean repaintPending;

    private int repaintX1;

    private int repaintY1;

    private int repaintX2;

    private int repaintY2;

    private Object repaintLock;

    private boolean selectionKeyCompatibility;

    private boolean finalMode;

    /**

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

     */

    public Canvas()

    {

        super(null);

        repaintLock = new Object();

        cleanupLock = new Object();

        construct();

        keysPressed = new Vector();

    }

    /* (non-Javadoc)

     * @see Displayable#eswtConstructShell(int)

     */

    Shell eswtConstructShell(int style)

    {

        return super.eswtConstructShell(style /*| SWT.RESIZE*/);

    }

    /* (non-Javadoc)

     * @see Displayable#eswtConstructContent(int)

     */

    Composite eswtConstructContent(int style)

    {

        // Get JAD attribute

        noBackground = JadAttributeUtil.isValue(JadAttributeUtil.ATTRIB_NOKIA_UI_ENHANCEMENT,

                                                JadAttributeUtil.VALUE_CANVAS_HAS_BACKGROUND);

        if(noBackground)

        {

            style |= SWT.NO_BACKGROUND;

        }

        // Get JAD attribute for S60 Selection Key Compatibility

        selectionKeyCompatibility = 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))

                    {

                        disableTapDetection = 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();

        }

        Composite canvasComp = super.eswtConstructContent(style);

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

            onScreenkeypad = new CanvasKeypad(this, canvasComp, oskAttr);

        }

        return canvasComp;

    }

    /* (non-Javadoc)

     * @see Displayable#eswtHandleShowCurrentEvent()

     */

    void eswtHandleShowCurrentEvent()

    {

        super.eswtHandleShowCurrentEvent();

        getContentComp().addPaintListener(paintListener);

        getContentComp().addMouseListener(mouseListener);

        getContentComp().addMouseMoveListener(mouseListener);

    }

    /* (non-Javadoc)

     * @see Displayable#eswtHandleHideCurrentEvent()

     */

    void eswtHandleHideCurrentEvent()

    {

        super.eswtHandleHideCurrentEvent();

        getContentComp().removePaintListener(paintListener);

        getContentComp().removeMouseListener(mouseListener);

        getContentComp().removeMouseMoveListener(mouseListener);

    }

    /**

     * Issues the request to repaint the whole Canvas.

     */

    public void repaint()

    {

        repaint(0, 0, getWidth(), getHeight());

    }

    /**

     * Issues the request to repaint the specified area of the Canvas. The

     * request is processed asynchronously.

     *

     * @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)

    {

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

        // to the invalid area in the member variables without posting a new

        // event.

        synchronized(repaintLock)

        {

            if(invalidate(x, y, width, height))

            {

                // Note that repaintPending doesn't mean that there's a repaint

                // event in the queue. It means that the invalid area is going

                // to be repainted and there's no need to add a new event.

                // It's possible that the repaint event has already been

                // removed from the queue but repaintPending is still true. In

                // that case it's currently being processed and we can still

                // add to the invalid area.

                if(!repaintPending)

                {

                    EventDispatcher eventDispatcher = EventDispatcher.instance();

                    LCDUIEvent event = eventDispatcher.newEvent(

                                           LCDUIEvent.CANVAS_PAINT_MIDLET_REQUEST, this);

                    event.widget = getContentComp();

                    eventDispatcher.postEvent(event);

                    repaintPending = true;

                }

            }

        }

    }

    /**

     * Switches the Canvas between full screen and non-full screen modes.

     *

     * @param mode - true switches the Canvas to the full-screen mode.

     */

    public void setFullScreenMode(boolean mode)

    {

        finalMode = mode;

        ESWTUIThreadRunner.syncExec(new Runnable()

        {

            public void run()

            {

                ((MobileShell) getShell()).setFullScreenMode(finalMode);

                //set the CanvasKeypad to the required mode

                if(onScreenkeypad != null)

                {

                    onScreenkeypad.setFullScreenMode(finalMode);

                }

            }

        });

    }

    /**

     * Processes all the issued paint requests.

     */

    public final void serviceRepaints()

    {

        EventDispatcher.instance().serviceRepaints(this);

    }

    /**

     * Checks if the Canvas supports pointer dragging events.

     *

     * @return true if the Canvas supports pointer dragging, false otherwise.

     */

    public boolean hasPointerMotionEvents()

    {

        return true;

    }

    /**

     * Checks if the Canvas supports pointer events.

     *

     * @return true if the Canvas supports pointer events, false otherwise.

     */

    public boolean hasPointerEvents()

    {

        return true;

    }

    /**

     * Is the Canvas double buffered.

     *

     * @return true if the Canvas is double buffered, false otherwise.

     */

    public boolean isDoubleBuffered()

    {

        return true;

    }

    /**

     * Queries if the Canvas supports key repeat events.

     *

     * @return true if Canvas supports key repeat events, false otherwise.

     */

    public boolean hasRepeatEvents()

    {

        return true;

    }

    /**

     * Returns game action for a specified key code.

     *

     * @param keyCode Key code to map to game action.

     * @return Game action for a a specified key code or

     *         IllegalArgumentException.

     */

    public int getGameAction(int keyCode)

    {

        return KeyTable.getGameAction(keyCode);

    }

    /**

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

     */

    public int getKeyCode(int gameAction)

    {

        return KeyTable.getKeyCode(gameAction);

    }

    /**

     * 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)

    {

        return KeyTable.getKeyName(keyCode);

    }

    /**

     * Gets height.

     *

     * @return Height of the Displayable in pixels.

     */

    public int getHeight()

    {

        ESWTUIThreadRunner.syncExec(new Runnable()

        {

            public void run()

            {

                if(onScreenkeypad != null)

                {

                    oskHeight = onScreenkeypad.getHeight();

                }

            }

        });

        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

     * updated in <code>paint()</code> method.

     * <p>

     * Application should not take into account the source where the

     * <code>paint()</code> request came from.

     * <p>

     * Any interaction with Graphics object outside of <code>paint()</code>