/*

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

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.*;

/**

 * Structure which represents Control stored in Form Row.

 */

final class LayoutObject {

    /**

     * Control which is represented by this LayoutObject.

     */

    private Control control;

    /**

     * If control is Composite (for example if Item has label), then

     * commandControl will contain composite's child that will receive events.

     * Otherwise commandControl will be same as control.

     */

    private Control commandControl;

    private Item owningItem;

    private boolean commandsActivated;

    private int x;

    private int y;

    private int width;

    private int height;

    private EswtItemCommandListener eswtItemCommandListener =

        new EswtItemCommandListener();

    // index of the row current LayoutObject belongs to

    private int layoutRowIdx;

    /**

     * Constructor.

     *

     * @param owningItem - Item which this LayoutObject corresponds to

     * @param control - Control for that LayoutObject

     */

    LayoutObject(Item owningItem, Control control) {

        this.owningItem = owningItem;

        setControl(control);

    }

    /**

     * Set the Control for that LayoutObject.

     *

     * @param newControl Control to set

     */

    private void setControl(final Control newControl) {

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                control = newControl;

                eswtUpdateSize();

                Control temp = eswtGetCommandControl(control);

                commandControl = (temp != null ? temp : control);

                Enumeration e = owningItem.getCommands().elements();

                Command cmd = null;

                while (e.hasMoreElements()) {

                    cmd = (Command) e.nextElement();

                    eswtAddCommand(cmd);

                }

            }

        });

    }

    /**

     * Gets Control which should be used with commands.<br>

     * This might be LayoutObject's control or one of its children in case of

     * Button. Button should be handled separately here because of MSK.

     *

     * @param ctrl Control of this LayoutObject.

     * @return Control.

     */

    Control eswtGetCommandControl(Control ctrl) {

        Control ret = null;

        if (ctrl != null) {

            if (ctrl instanceof Button) {

                ret = ctrl;

            }

            else if (ctrl instanceof Composite) {

                Control[] children = ((Composite) ctrl).getChildren();

                for (int i = 0; i < children.length; i++) {

                    Control result = eswtGetCommandControl(children[i]);

                    if (result != null) {

                        ret = result;

                        break;

                    }

                }

            }

        }

        return ret;

    }

    /**

     * Dispose LayoutObject.

     */

    void dispose() {

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                control.dispose();

                control = null;

                commandControl = null;

            }

        });

    }

    /**

     * Returns the Item's vertical layout.

     */

    int getVerticalLayout() {

        return Item.getVerticalLayout(owningItem.getLayout());

    }

    /**

     * Get Control of the layoutObject.

     *

     * @return control

     */

    Control getControl() {

        return control;

    }

    /**

     * Get Item to which the LayoutObjecy belongs.

     *

     * @return owning Item

     */

    Item getOwningItem() {

        return owningItem;

    }

    /**

     * Set location of the LayoutObject and the control.

     *

     * @param xCoord x coordinate

     * @param yCoord y coordinate

     */

    void eswtSetLocation(int xCoord, int yCoord) {

        x = xCoord;

        y = yCoord;

        control.setLocation(xCoord, yCoord);

    }

    /**

     * Update LayoutObject width and height.

     */

    void eswtUpdateSize() {

        Rectangle bounds = control.getBounds();

        width = bounds.width;

        height = bounds.height;

    }

    /**

     * Get x Coordinate of LayoutObject,

     *

     * @return xCoordinate of LayoutObject.

     */

    int getX() {

        return x;

    }

    /**

     * Get y Coordinate of LayoutObject,

     *

     * @return yCoordinate of LayoutObject.

     */

    int getY() {

        return y;

    }

    /**

     * Get width of LayoutObject.

     *

     * @return width of a control

     */

    int getWidth() {

        return width;

    }

    /**

     * Get width of LayoutObject.

     *

     * @return width of a control

     */

    int getHeight() {

        return height;

    }

    /**

     * Sets the row index of the Row where this LayoutObject is placed.

     *

     * @param row Row index.

     */

    void setRowIdx(int row) {

        layoutRowIdx = row;

    }

    /**

     * Returns row index where this LayoutObject is placed.

     *

     * @return Index of the row.

     */

    int getRowIdx() {

        return layoutRowIdx;

    }

    boolean contains(int xCoord, int yCoord) {

        return (y <= yCoord && yCoord <= y + height

                && x <= xCoord && xCoord <= x + width);

    }

    /**

     * Returns if this LayoutObject is below the other.

     */

    boolean isBelow(LayoutObject other) {

        if (other != null) {

            return (this.getRowIdx() > other.getRowIdx());

        }

        return true;

    }

    /**

     * Returns if this LayoutObject is above the other.

     */

    boolean isAbove(LayoutObject other) {

        if (other != null) {

            return (this.getRowIdx() < other.getRowIdx());

        }

        return true;

    }

    /**

     * Returns the horizontal middle of the LayoutObject.

     *

     * @return x horizontal coordinate of the middle of LayoutObject.

     */

    private int getXMiddle() {

        return (x + width / 2);

    }

    /**

     * Returns the vertical middle of the LayoutObject.

     *

     * @return y vertical coordinate of the middle of LayoutObject.

     */

    private int getYMiddle() {

        return (y + height / 2);

    }

    /**

     * Returns the horizontal distance between the middle of the LayoutObjects.

     * The method is used to find next focusable item.

     *

     * @param other another LayoutObject

     * @return positive distance between the middles

     */

    int distanceTo(LayoutObject other) {

        if (other != null) {

            int xd = Math.abs(getXMiddle() - other.getXMiddle());

            int yd = Math.abs(getYMiddle() - other.getYMiddle());

            return (int) Math.sqrt(xd * xd + yd * yd);

        }

        else {

            return Integer.MAX_VALUE - 1;

        }

    }

    /**

     * Activates commands associated with owning item.

     */

    void eswtAddSelectionListenerForCommands() {

        // Logger.method(this, "eswtAddSelectionListenerForCommands");

        commandsActivated = true;

        // Add new control to commands in owning item:

        Enumeration e = owningItem.getCommands().elements();

        Command cmd = null;

        while (e.hasMoreElements()) {

            cmd = (Command) e.nextElement();

            cmd.eswtAddCommandSelectionListener(commandControl,

                    eswtItemCommandListener);

        }

        // Add SelectionListener to Button control.

        // Listener is activated when command mapped to MSK is clicked.

        if (commandControl instanceof Button && !commandControl.isDisposed()) {

            ((Button) commandControl)

                    .addSelectionListener(eswtItemCommandListener);

        }

    }

    /**

     * DeActivates commands associated with owning item.

     */

    void eswtRemoveSelectionListenerForCommands() {

        // Logger.method(this, "eswtRemoveSelectionListenerForCommands");

        commandsActivated = false;

        // Add new control to commands in owning item:

        Enumeration e = owningItem.getCommands().elements();

        Command cmd = null;

        while (e.hasMoreElements()) {

            cmd = (Command) e.nextElement();

            cmd.eswtRemoveCommandSelectionListener(commandControl,

                    eswtItemCommandListener);

        }

        // Remove SelectionListener from Button control.

        // Listener is activated when command mapped to MSK is clicked.

        if (commandControl instanceof Button && !commandControl.isDisposed()) {

            ((Button) commandControl)

                    .removeSelectionListener(eswtItemCommandListener);

        }

    }

    /**

     * Adds command to the owning item.

     *

     * @param command The command to be added.

     */

    void addCommand(final Command command) {

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                eswtAddCommand(command);

            }

        });

    }

    /**

     * eSWT callback to add a Command.

     */

    void eswtAddCommand(Command command) {

        //Logger.method(this, "eswtAddCommand", command);

        if (command != null && commandControl != null) {

            command.eswtAddESWTCommand(commandControl,

                    (command == owningItem.getDefaultCommand()));

            if (commandsActivated) {

                command.eswtAddCommandSelectionListener(commandControl,

                        eswtItemCommandListener);

            }

        }

    }

    /**

     * Removes command from the owning item.

     *

     * @param command The command to be removed.

     */

    void removeCommand(final Command command) {

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                eswtRemoveCommand(command);

            }

        });

    }

    /**

     * eSWT callback to remove a Command.

     */

    private void eswtRemoveCommand(Command command) {

        //Logger.method(this, "eswtRemoveCommand", command);

        if (command != null && commandControl != null) {

            if (commandsActivated) {

                command.eswtRemoveCommandSelectionListener(commandControl,

                        eswtItemCommandListener);

            }

            command.eswtRemoveESWTCommand(commandControl);

        }

    }

    /**

     * Inner class which receives SelectionEvents from eSWT and convert and

     * forwards those events to LCDUI Item's ItemCommandListener.

     */

    class EswtItemCommandListener implements SelectionListener {

        public void widgetDefaultSelected(SelectionEvent e) {

        }

        /**

         * Executed by eSWT when event occurs. This method will then call

         * Item's ItemCommandListener if event source matches with the

         * Commands added to the Item.

         */

        public void widgetSelected(SelectionEvent event) {

            // Go through all Commands added to owning item:

            Enumeration e = owningItem.getCommands().elements();

            Command cmd = null;

            while (e.hasMoreElements()) {

                cmd = (Command) e.nextElement();

                // get eSWT Command of this Control from Command and compare

                // it to the widget which launched the event:

                if (cmd.getESWTCommand(commandControl) == event.widget) {

                    owningItem.callCommandAction(cmd);

                    break;

                }

                // Handle MSK:

                Command mskCmd = owningItem.getMSKCommand();

                if (mskCmd != null && cmd == mskCmd) {

                    if (commandControl == event.widget) {

                        owningItem.callCommandAction(cmd);

                        break;

                    }

                }

            }

        }

    }

    public String toString() {

        return owningItem + " [line:" + layoutRowIdx + "]";

    }

}