/*

* 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 org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

/**

 * DefaultFormLayoutPolciy implements form layout algorithm.

 */

class DefaultFormLayoutPolicy extends FormLayoutPolicy {

    /**

     * Form instance (not owned).

     */

    private Form form;

    /**

     * Form's scrolled composite (not owned).

     */

    protected ScrolledComposite formComposite;

    /**

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

    // Used by getItemControl() method to return Item's main conrol.

    private Control itemMainControl;

    /**

     * Constructor.

     *

     * @param form Form to perform layout on.

     */

    DefaultFormLayoutPolicy(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);

            }

        });

    }

    /**

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

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

            }

        }

    }

    /**

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

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

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

            }

        }

    }

    /**

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

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                eswtLayoutForm(startItem);

            }

        });

    }

    /**

     * eSWT callback for doLayout().

     */

    void eswtLayoutForm(int startItem) {

        int numItems = getItemCount();

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

        eswtUpdateFormComposite(false);

        if (numItems > 0) {

            Item previousItem = null;

            int startRowIndex = 0;

            if (startItem > 0) {

                // Find row with previous item.

                previousItem = getItem(startItem - 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 = startItem; 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();

        }

    }

    void handleKeyEvent(int keyCode, int keyType) {

        // Implemented in sub-class DefaultFormInteraction

    }

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

        // Implemented in sub-class DefaultFormInteraction

    }

    /**

     * Set focus to an item if it is focusable and scroll form to make it

     * visible if it is not.

     *

     * @param item Item to set as current item.

     */

    void setCurrentItem(final Item item) {

        Logger.method(this, "setCurrentItem", item);

        ESWTUIThreadRunner.syncExec(new Runnable() {

            public void run() {

                eswtSetCurrentItem(item);

            }

        });

    }

    /**

     * eSWT callback for setCurrentItem.

     */

    boolean eswtSetCurrentItem(Item item) {

        if (item != null) {

            if (isItemLayouted(item)) {

                eswtScrollToItem(item);

                deferredScrollToItem = null;

                return true;

            }

            else {

                deferredScrollToItem = item;

            }

        }

        return false;

    }

    void eswtScrollToItem(Item item) {

        if (item != null) {

            int pos = getItemBottomPosition(item) - getFormHeight();

            if (!isItemPartiallyVisible(item)) {

                eswtSetScrollingPosition(pos, true);

            }

            else if (item instanceof TextField && !isItemFullyVisible(item)) {

                eswtSetScrollingPosition(pos, true);

            }

        }

    }

    void eswtScrolltoRegion(int yTop, int yBottom, int swtDir) {

        if (yTop < vPosition || yBottom > vPosition + getFormHeight()) {

            // if the region is somewhat outside the screen

            if (swtDir == SWT.ARROW_DOWN || swtDir == SWT.ARROW_RIGHT) {

                // align to top

                eswtSetScrollingPosition(yTop, true);

            }

            else {

                // align to bottom

                eswtSetScrollingPosition(yBottom - getFormHeight(), true);

            }

        }

    }

    void eswtScrollIfNeeded(final int top, final int bottom) {

        if (bottom > vPosition + getFormHeight()) {

            eswtSetScrollingPosition(bottom - (getFormHeight() / 2), true);

        }

        else if (top < vPosition) {

            eswtSetScrollingPosition(bottom - (getFormHeight() / 2), true);

        }

    }

    /**

     * Get control's position relative to composite.

     */

    void getControlPositionOnComposite(Control control, Point location) {

        if (control != formComposite) {

            Point rel = control.getLocation();

            location.x += rel.x;

            location.y += rel.y;

            getControlPositionOnComposite(control.getParent(), location);

        }

    }

    /**

     * eSWT specific calls to do update ScrolledComposite.

     */

    private void eswtUpdateFormComposite(boolean show) {

        if (getRowCount() > 0) {

            if (show) {

                formComposite.updateScrollbar(getLastRow().getBottomPosition());

                formComposite.pack();

            }

        }

        // Could happen if changing item from very tall to very short.

        // so we have to update VPosition

        if (getVPosition() > eswtGetMaxVPosition()) {

            eswtSetScrollingPosition(eswtGetMaxVPosition(), false);

        }

        formComposite.setRedraw(show);

        formComposite.setVisible(show);

    }

    /**

     * Clean all form rows starting from startIndex.

     *

     * @param startIndex Start row from which to clean.

     * @param keepItem - item in a startRow which shouldn't be recreated.

     */

    private void eswtClearRows(int startIndex, Item keepItem) {

        Logger.method(this, "clearRows", String.valueOf(startIndex), keepItem);

        Row row = null;

        for (int i = (getRowCount() - 1); i >= startIndex; i--) {

            row = getRow(i);

            if (row.cleanRow(keepItem)) {

                break;

            }

            else {

                rows.removeElement(row);

            }

        }

        // one row always should be available.

        if ((getRowCount() == 0)) {

            // rows.addElement(tempRow);

            currentHLayoutDirective = Item.LAYOUT_DEFAULT;

            Row newRow = new Row(ItemLayouter.getMaximumItemWidth(null),

                    getCurrentHLayoutDirective());

            rows.addElement(newRow);

        }

    }

    /**

     * Update Row's internal layout. Handles LAYOUT_2 related post-processing.

     *

     * @param row Row

     */

    private void eswtUpdateRow(Row row) {

        if (row != null) {

            //Logger.verbose("updateRow start: " + row);

            int numShrink = row.getNumLayoutObjects(Item.LAYOUT_SHRINK);

            int numExpand = row.getNumLayoutObjects(Item.LAYOUT_EXPAND);

            //Logger.verbose("shrink: " + numShrink + " expand: " + numExpand);

            int vMask = Item.LAYOUT_VSHRINK | Item.LAYOUT_VEXPAND;

            // Expand items vertically with VSHRINK or VEXPAND layout directive

            LayoutObject lo = null;

            int maxHeight = row.getRowHeight(vMask);

            while ((lo = row.getNextLayoutObject(lo, vMask)) != null) {

                if (lo.getOwningItem().hasLayout(Item.LAYOUT_VSHRINK)) {

                    int pref = lo.getOwningItem().getPreferredHeight();

                    getLayouter(lo.getOwningItem()).eswtResizeObject(lo,

                            lo.getWidth(), Math.min(pref, maxHeight));

                }

                else if (lo.getOwningItem().hasLayout(Item.LAYOUT_VEXPAND)) {

                    getLayouter(lo.getOwningItem()).eswtResizeObject(lo,

                            lo.getWidth(), maxHeight);

                }

            }

            // Expand items with SHRINK layout directive

            if (numShrink > 0) {

                // Get extra space before shrink and expand

                int offset = row.getFreeSpace() / numShrink;

                // Logger.verbose("shrinkOffset: " + offset);

                if (offset >= 0) {

                    while ((lo = row.getNextLayoutObject(lo, Item.LAYOUT_SHRINK)) != null) {

                        int pref = lo.getOwningItem().getPreferredWidth();

                        int min = lo.getOwningItem().getMinimumWidth();

                        int itemWidth = Math.min(pref, min + offset);

                        getLayouter(lo.getOwningItem()).eswtResizeObject(lo,

                                itemWidth, lo.getHeight());

                    }

                }

            }

            // Expand items with EXPAND layout directive

            if (numExpand > 0) {

                // Get extra space after shrink but before expand

                int offset = row.getFreeSpace(Item.LAYOUT_EXPAND) / numExpand;

                if (offset >= 0) {

                    // Logger.verbose("expandOffset: " + offset);

                    while ((lo = row.getNextLayoutObject(lo, Item.LAYOUT_EXPAND)) != null) {

                        int pref = lo.getOwningItem().getPreferredWidth();

                        getLayouter(lo.getOwningItem()).eswtResizeObject(lo,

                                pref + offset, lo.getHeight());

                    }

                }

            }

            //if (numShrink > 0 || numExpand > 0) {

            row.updateRowInternals();

            //}

            row.updateRowLayout(form.getLeftRightLanguage());

            // Logger.verbose("updateRow: " + row);

        }

    }

    /**

     * Add a new Row.

     */

    private Row eswtAddNewRow() {

        Row lastRow = getLastRow();

        eswtUpdateRow(lastRow);

        int yShift = (lastRow == null ? 0 : lastRow.getBottomPosition());

        // create new Row

        Row newRow = new Row(ItemLayouter.getMaximumItemWidth(null),

                getCurrentHLayoutDirective());

        newRow.setYShift(yShift);

        rows.addElement(newRow);

        return newRow;

    }

    /**

     * Add a LayoutObject to the last Row.

     *

     * @param layoutObject the layout object

     */

    void eswtAddNewLayoutObject(LayoutObject layoutObject) {

        Row lastRow = getLastRow();

        // check if the current Row is full

        if (!lastRow.isEmpty()

                && lastRow.getFreeSpace() < layoutObject.getWidth()) {

            lastRow = eswtAddNewRow();

        }

        lastRow.eswtAddLayoutObject(layoutObject);

        layoutObject.setRowIdx(getRowCount() - 1);

    }

    /**

     * Optionally add a new Row and adds a LayoutObject.

     *

     * @param layoutObject the layout object

     * @param newRow adds a new row if true. If false, adds new row only if

     *            there's no space for layoutObject in current row.

     */

    void eswtAddNewLayoutObject(LayoutObject layoutObject, boolean newRow) {

        if (newRow) {

            eswtAddNewRow();

        }

        eswtAddNewLayoutObject(layoutObject);

    }

    /**

     * Layout item in a row, if needed new row is added.

     *

     * @param row - where to startLayout.

     * @param item - Item to Layout

     */

    private void eswtLayoutItem(Item item) {

        Row lastRow = getLastRow();

        boolean hlChange = setCurrentHLayoutDirective(item.internalGetLayout());

        if (hlChange || getItemNewLineBefore(item)) {

            // newline directive or horizontal layout changed

            if (lastRow.isEmpty()) {

                // if the current/last row is empty - use that

                lastRow.setRowHLayout(getCurrentHLayoutDirective());

            }

            else {

                eswtAddNewRow();

            }