/*

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

import java.util.Vector;

import java.util.Enumeration;

import java.util.Timer;

import java.util.TimerTask;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

/**

 * FormLayouter implements form layout algorithm.

 */

class FormLayouter

{

    /**

     * Form instance (not owned).

     */

    private Form form;

    /**

     * Form's scrolled composite (not owned).

     */

    protected ScrolledComposite formComposite;

    /**

     * Controls vector.

     */

    private Vector layoutObjects = new Vector();

    /**

     * Rows vector.

     */

    private Vector rows = new Vector();

    /**

     * Form's current horizontal alignment

     */

    private int currentHLayoutDirective;

    private ImageItemLayouter imIL;

    private StringItemLayouter sIL;

    private GaugeLayouter gL;

    private TextFieldLayouter tfL;

    private DateFieldLayouter dfL;

    private ChoiceGroupLayouter cgL;

    private CustomItemLayouter ciL;

    private SpacerLayouter sL;

    private int vPosition;

    private Item deferredScrollToItem;

    private boolean isCurrent;

    private Control itemMainControl;

    private static final int NO_DIRECTION = -1;

    private Item currentSelectedItem;

    private int direction = NO_DIRECTION;

    private boolean mousePressed;

    private LayoutObject currentlyUnderMouse;

    /**

     * Constructor.

     *

     * @param form Form to perform layout on.

     */

    FormLayouter(Form form)

    {

        this.form = form;

        formComposite = form.getFormComposite();

        imIL = new ImageItemLayouter(this);

        sIL = new StringItemLayouter(this);

        gL = new GaugeLayouter(this);

        dfL = new DateFieldLayouter(this);

        tfL = new TextFieldLayouter(this);

        cgL = new ChoiceGroupLayouter(this);

        ciL = new CustomItemLayouter(this);

        sL = new SpacerLayouter(this);

    }

    /**

     * Dispose and cleanup layouted items.

     */

    void dispose()

    {

        ESWTUIThreadRunner.syncExec(new Runnable()

        {

            public void run()

            {

                eswtClearRows(0, null);

    			removeAllLayoutObjects();

				rows = null;

				layoutObjects = null;

            }

        });

    }

    /**

     * Log out a control with all its children at the given indentation level.

     */

    void logControl(int level, Control control)

    {

        if(control != null)

        {

            String s2 = control.toString();

            s2 = s2.substring(0, s2.indexOf('}') - 1);

            String s3 = control.getBounds().toString();

            s3 = s3.substring(s3.indexOf('{'));

            Logger.verbose(Logger.indent(s2 + s3, level * 2));

            if(control instanceof Composite)

            {

                Control[] arr = ((Composite) control).getChildren();

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

                {

                    logControl(level + 1, arr[i]);

                }

            }

        }

    }

    /**

     * Log out all layoutobjects for each item.

     */

    void logFormLayout()

    {

        Logger.verbose(form + " ---------------------------------------------");

        LayoutObject lo = null;

        Item item = null;

        int line = -1;

        while((lo = getNextLayoutObjectOfItem(lo, null)) != null)

        {

            if(lo.getOwningItem() != item)

            {

                item = lo.getOwningItem();

                Logger.verbose(item.toString());

            }

            if(lo.getRowIdx() != line)

            {

                line = lo.getRowIdx();

            }

            Logger.verbose(Logger.indent("Row:" + lo.getRowIdx(), 2));

            logControl(2, lo.getControl());

        }

        Logger.verbose(form + " ---------------------------------------------");

    }

    /**

     * Called when Form is about to be shown.<br>

     * NOTE: this is called from eSWT UI-thread

     */

    void handleShowCurrentEvent()

    {

        Logger.method(this, "handleShowCurrentEvent");

        isCurrent = true;

        // restore our scrolling position (eSWT resets it to 0 by default)

        eswtSetScrollingPosition(vPosition, true);

        Item item = null;

        LayoutObject lo = null;

        while((lo = getNextLayoutObjectOfItem(lo, null)) != null)

        {

            if(lo.getOwningItem() != item)

            {

                // item border

                item = lo.getOwningItem();

                getItemLayouter(item).eswtAddListeners(item, lo);

            }

        }

		eswtApplyCurrentFocus();	

    }

    /**

     * Called when Form is about to be hidden.<br>

     * NOTE: this is called from eSWT UI-thread

     */

    void handleHideCurrentEvent()

    {

        Logger.method(this, "handleHideCurrentEvent");

        isCurrent = false;

        Item item = null;

        LayoutObject lo = null;

        while((lo = getNextLayoutObjectOfItem(lo, null)) != null)

        {

            if(lo.getOwningItem() != item)

            {

                // item border

                item = lo.getOwningItem();

                getItemLayouter(item).eswtRemoveListeners(item, lo);

                getItemLayouter(item).eswtHandleVisibilityChange(item, false);

            }

        }

		direction = NO_DIRECTION;

    }

    /**

     * Called when Form is beeing resized.<br>

     * NOTE: this is called from eSWT UI-thread

     */

    void handleResizeEvent(int width, int height)

    {

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

        int numitems = getItemCount();

        for(int i = 0; i < numitems; i++)

        {

            getItem(i).invalidateCachedSizes();

        }

        ItemLayouter.eswtUpdateStaticShellSize(width, height);

    }

    /**

     * Do form layout according to startIndex.

     *

     * @param startItem - index of item which need to be layouted.

     */

    void layoutForm(final int startIndex)

    {

        ESWTUIThreadRunner.syncExec(new Runnable()

        {

            public void run()

            {

                eswtLayoutForm(startIndex);

            }

        });

    }

    /**

     * eSWT callback for doLayout().

     */

    void eswtLayoutForm(int startIndex)

    {

        int numItems = getItemCount();

        Logger.method(this, "eswtLayoutForm", startIndex + " / " + numItems);

        eswtUpdateFormComposite(false);

        if(numItems > 0)

        {

            Item previousItem = null;

            int startRowIndex = 0;

            if(startIndex > 0)

            {

                // Find row with previous item.

                previousItem = getItem(startIndex - 1);

                Row prevItemRow = getLastRowOfItem(previousItem);

                if(prevItemRow != null)

                {

                    startRowIndex = rows.indexOf(prevItemRow);

                }

            }

            // Clear rows starting from item - partial re-layouting

            eswtClearRows(startRowIndex, previousItem);

            // Layout items

            for(int i = startIndex; i < numItems; i++)

            {

                eswtLayoutItem(getItem(i));

            }

            // Update last row

            eswtUpdateRow(getLastRow());

        }

        else

        {

            eswtClearRows(0, null);

        }

        // check if we need to scroll to a particular item

        if(deferredScrollToItem != null)

        {

            eswtSetCurrentItem(deferredScrollToItem);

            deferredScrollToItem = null;

        }

        eswtUpdateFormComposite(true);

        eswtHandleVisibilityChanges();

        if(Logger.isLogVerbose())

        {

            logFormLayout();

        }

		// clear invalid selected item

		eswtCheckCurrentSelectedItem();

		if(currentSelectedItem != null

				&& (currentSelectedItem.isFocusable()))

		{

			eswtApplyCurrentFocus();

		}

		else

		{

			// If there's no item currently selected try to find first

			// focusable item and set it current (if found):

			Item found = eswtGetNextFocusableItem(

							 getItem(startIndex - 1), SWT.ARROW_RIGHT);

			if(found != null)

			{

				eswtSetCurrentSelectedItem(found, NO_DIRECTION);

			}

			else

			{

				eswtApplyCurrentFocus();

			}

		}		

    }

    /**

     * Returns if the parameter is a eSWT directional key code.

     *

     * @param keyCode key code

     */

    private boolean isDirectionKey(int keyCode)

    {

        return (keyCode == SWT.ARROW_DOWN || keyCode == SWT.ARROW_UP

                || keyCode == SWT.ARROW_LEFT || keyCode == SWT.ARROW_RIGHT);

    }

    /**

     * Handler for key events.<br>

     * The implementation moves focus and/or scrolls the form when

     * needed. The method is called by the Form.

     *

     * @param keyCode eSWT key code.

     * @param keyType eSWT key type.

     */

    final void handleKeyEvent(int keyCode, int keyType)

    {

        Logger.method(this, "handleKeyEvent", currentSelectedItem,

                      String.valueOf(keyCode), String.valueOf(keyType));

        boolean isDirectionalKey = isDirectionKey(keyCode);

        if(keyType == SWT.KeyDown && isDirectionalKey)

        {

            eswtCheckCurrentSelectedItem();

        }

        if(currentSelectedItem != null)

        {

            if(getItemLayouter(currentSelectedItem).eswtOfferKeyEvent(

                        currentSelectedItem, keyCode, keyType))

            {

                // if the key has been consumed

                return;

            }

        }

        // scrolling/focus traverse only happens on directional key's down event

        if(keyType == SWT.KeyDown && isDirectionalKey)

        {

            // try to find next focusable item

            Item next = eswtGetNextFocusableItem(currentSelectedItem, keyCode);

            // if no visible & focusable item was found to transfer focus

            if(next == currentSelectedItem)

            {

                // try to scroll a bit

                eswtSetScrollingPosition(getNextScrollingPosition(keyCode),

                                         true);

                // find next focusable after scrolling

                next = eswtGetNextFocusableItem(currentSelectedItem, keyCode);

            }

            if(next != currentSelectedItem)

            {

                //textfield always have to be fully visible when focused.

                if(next instanceof TextField)

                {

                    eswtScrollToItem(next);

                }

                eswtSetCurrentSelectedItem(next, keyCode);

            }

        }

    }

    /**

     * Handler for pointer events.<br>

     * The method is called by the Form.

     *

     * @param x coordinate relative to scrolledComposite

     * @param y coordinate relative to scrolledComposite

     * @param type event type: SWT.MouseDown, SWT.MouseMove, SWT.MouseUp

     */

    final void handlePointerEvent(int x, int y, int type)

    {

        Logger.method(this, "handlePointerEvent", String.valueOf(x),

                      String.valueOf(y), String.valueOf(type));

        // TODO: change when DirectUI style arrives.

        /*

        Item item;

        if (type == SWT.MouseMove) {

            if (currentlyUnderMouse == null

                    || !currentlyUnderMouse.contains(x, y)) {

                if (currentlyUnderMouse != null) {

                    //currentlyUnderMouse.getControl().setCapture(false);

                }

                item = eswtFindItemUnderMouse(x, y);

                if (item != null && item != currentSelectedItem

                        && item.isFocusable()) {

                    setCurrentItem(item);

                    item.internalSetFocused(true);

                    eswtSetCurrentSelectedItem(item);

                    //following method causes all mouse events delivered to it

                    currentlyUnderMouse.getControl().setCapture(true);

                    Logger.warning("seting capture to:" + item);

                }

            }

            int currentVPosition = getVPosition();

            boolean isMouseDirectionUp = false;

            boolean doScrolling = false;

            int localY = y;

            if (y <= currentVPosition) {

                localY = Math.max(0, y);

                eswtSetScrollingPosition(localY, true);

                isMouseDirectionUp = true;

                doScrolling = true;

            }

            else if (y > (currentVPosition + getFormHeight())) {

                //check for maxVPosition

                if (y > (eswtGetMaxVPosition() + getFormHeight())) {

                    localY = eswtGetMaxVPosition() + getFormHeight();

                }

                else {

                    localY = y;

                }

                currentVPosition = localY - getFormHeight();

                eswtSetScrollingPosition(currentVPosition, true);

                isMouseDirectionUp = false;

                doScrolling = true;

            }

            if (mousePressed && doScrolling) {

                resetEventTimer(isMouseDirectionUp, localY);

            }

        }

        else

        if (type == SWT.MouseDown) {

            mousePressed = true;

            item = eswtFindItemUnderMouse(x, y);

            if (item != null && item != currentSelectedItem

                    && item.isFocusable() && getForm().getShell() ==

                        getForm().getShell().getDisplay().getActiveShell()) {

                //eswtScrollToItem(item);

                //following method causes all mouse events delivered to it

                //currentlyUnderMouse.getControl().setCapture(true);

            }

        }

        else if (type == SWT.MouseUp) {

            mousePressed = false;

            if (currentlyUnderMouse != null) {

                //currentlyUnderMouse.getControl().setCapture(false);

            }

        }*/

    }

    /**

     * Find item at the specified point.

     *

     * @param x coordinate.

     * @param y coordinate.

     * @return Item.

     */

    Item eswtFindItemUnderMouse(int x, int y)

    {

        Row itemRow;

        for(int i = 0; i < getRowCount(); i++)

        {

            itemRow = getRow(i);

            if(itemRow.getYShift() <= y && y <= itemRow.getBottomPosition())

            {

                LayoutObject lo;

                for(int j = 0; j < itemRow.size(); j++)

                {

                    lo = itemRow.getLayoutObject(j);

                    if(lo.contains(x, y))

                    {

                        Logger.info("Item under mouse: "

                                    + lo.getOwningItem());

                        currentlyUnderMouse = lo;

                        return lo.getOwningItem();

                    }

                }

                break;

            }

        }

        return null;

    }

    /**

     * Gets next (or nearest) focusable item.