/*

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

/**

 * Utility class used to wrap a string for StringItem layout.

 */

final class StringWrapper

{

    private static final String DELIM_STR = " ,.;:!?-\n";

    private StringWrapper()

    {

        super();

    }

    /**

     * Method to be called by StringItemLayouter to provide correct wrapping of

     * a single String to a Vector of strings.

     *

     * @param inputString Contents of a StringItem

     * @param stringItemFont StringItem's font

     * @param fullWidth Full width of the Form, in pixels

     * @param freeWidth Free width is the current row of Form layout

     * @return Vector of Strings, each element to be placed in one layout row

     */

    static Vector wrapString(String inputString,

                             Font stringItemFont,

                             boolean leftToRightLayout,

                             int fullWidth,

                             int freeWidth)

    {

        if(leftToRightLayout)

        {

            // if left-to-right then just call wrapping method

            return doWrapString(inputString, stringItemFont, fullWidth,

                                freeWidth);

        }

        else

        {

            // if right-to-left then:

            // 1) reverse the string

            // 2) do wrapping

            // 3) reverse each vector element individually

            StringBuffer temp = new StringBuffer(inputString);

            Vector ret = doWrapString(temp.reverse().toString(),

                                      stringItemFont, fullWidth, freeWidth);

            for(int i = 0; i < ret.size(); i++)

            {

                temp.setLength(0);

                temp.append((String) ret.elementAt(i));

                ret.setElementAt(temp.reverse().toString(), i);

            }

            return ret;

        }

    }

    /**

     * Method to wrap a single string into many.

     *

     * @param inputString source string to wrap

     * @param font source string's font

     * @param fullWidth full form width in pixels

     * @param freeWidth free width available in current layout row, in pixels

     * @return Vector of Strings

     */

    private static Vector doWrapString(String inputString,

                                       Font font,

                                       int fullWidth,

                                       int freeWidth)

    {

        Vector result = new Vector();

        // Could happen if StringItem.setText(null) or StringItem.setText("")

        // was called

        if(inputString == null)

        {

            result.addElement("");

            return result;

        }

        int availableWidth = freeWidth;

        int tokenWidth;

        int nextDelimiterPos = -1;

        int delimiterPos = 0;

        String str = inputString;

        String token = "";

        while(str.length() > 0)

        {

            nextDelimiterPos = findNextDelimiter(str, nextDelimiterPos + 1);

            token = str.substring(0, nextDelimiterPos).trim();

            tokenWidth = font.stringWidth(token);

            if(tokenWidth > availableWidth)

            {

                if(delimiterPos == 0)

                {

                    // even the first word in the string is too long to fit

                    if((availableWidth < fullWidth)

                            && (tokenWidth <= fullWidth))

                    {

                        // the long word would fit to the next full row

                        // result.addElement("");

                        availableWidth = fullWidth;

                        nextDelimiterPos = -1;

                        delimiterPos = 0;

                        continue;

                    }

                    if(tokenWidth > fullWidth)

                    {

                        // the long word does not fit to a full row

                        // do character-boundary wrapping

                        delimiterPos =

                            findWordBreak(token, font, availableWidth);

                        result.addElement(token.substring(0, delimiterPos));

                        str = str.substring(delimiterPos);

                        availableWidth = fullWidth;

                        nextDelimiterPos = -1;

                        delimiterPos = 0;

                        continue;

                    }

                }

                result.addElement(str.substring(0, delimiterPos).trim());

                availableWidth = fullWidth;

                str = str.substring(delimiterPos);

                nextDelimiterPos = -1;

                delimiterPos = 0;

                continue;

            }

            if(nextDelimiterPos == str.length())

            {

                result.addElement(token);

                availableWidth = fullWidth;

                str = str.substring(nextDelimiterPos);

                continue;

            }

            if(nextDelimiterPos < str.length()

                    && str.charAt(nextDelimiterPos) == '\n')

            {

                result.addElement(token);

                availableWidth = fullWidth;

                str = str.substring(nextDelimiterPos + 1);

                nextDelimiterPos = -1;

                delimiterPos = 0;

                continue;

            }

            delimiterPos = nextDelimiterPos;

        }

        return result;

    }

    /**

     * Break a word on character border.

     *

     * @param word - Word to break

     * @return Part of word that fits in the current available space

     */

    private static int findWordBreak(String word, Font font, int width)

    {

        int breakPos = word.length();

        while(font.substringWidth(word, 0, breakPos) > width)

        {

            breakPos--;

        }

        return breakPos;

    }

    /**

     * The method searches for a delimiter in the String from beginning to end,

     * starting from specified position.

     *

     * @param str String to search a delimiter

     * @param startPos Start position for search

     * @return The first delimiter found

     */

    private static int findNextDelimiter(String str, int startPos)

    {

        int strLen = str.length();

        int pos = startPos;

        for(; pos < strLen; pos++)

        {

            int delimiter = DELIM_STR.indexOf(str.charAt(pos));

            if(delimiter >= 0)

            {

                if(delimiter < 8)

                {

                    // 8 is the '\n' character's index

                    return pos + 1;

                }

                break;

            }

        }

        return pos;

    }

}