New implementation based on the new LWUIT design
authorguillaum1 <guillaum1@users.evolvis.org>
Tue, 27 Jan 2009 17:32:54 +0000 (17:32 +0000)
committerguillaum1 <guillaum1@users.evolvis.org>
Tue, 27 Jan 2009 17:32:54 +0000 (17:32 +0000)
92 files changed:
components/core/java/org/thenesis/lwuit/.gitignore [new file with mode: 0644]
components/glue/java/javax/microedition/m3g/Graphics3D.java [moved from core/java/javax/microedition/m3g/Graphics3D.java with 100% similarity]
components/glue/java/javax/microedition/m3g/Image2D.java [moved from core/java/javax/microedition/m3g/Image2D.java with 100% similarity]
components/glue/java/javax/microedition/media/MediaException.java [moved from core/java/javax/microedition/media/MediaException.java with 100% similarity]
components/glue/java/javax/microedition/media/Player.java [moved from core/java/javax/microedition/media/Player.java with 100% similarity]
components/implementation/java/org/thenesis/lwuimb/EditForm.java [new file with mode: 0644]
components/implementation/java/org/thenesis/lwuimb/EventMapper.java [moved from core/java/com/sun/lwuit/EventMapper.java with 94% similarity]
components/implementation/java/org/thenesis/lwuimb/GenericEventMapper.java [moved from core/java/com/sun/lwuit/GenericEventMapper.java with 93% similarity]
components/implementation/java/org/thenesis/lwuimb/LWUIMBImplementation.java [new file with mode: 0644]
components/implementation/java/org/thenesis/lwuimb/configuration/Configuration.java [moved from core/java/org/thenesis/lwuit/configuration/Configuration.java with 99% similarity]
components/implementation/java/org/thenesis/lwuimb/configuration/ConfigurationProperties.java [moved from core/java/org/thenesis/lwuit/configuration/ConfigurationProperties.java with 99% similarity]
components/implementation/java/org/thenesis/lwuimb/configuration/Properties.java [moved from core/java/org/thenesis/lwuit/configuration/Properties.java with 99% similarity]
components/overlay/java/com/sun/lwuit/M3G.java [moved from core/java/com/sun/lwuit/M3G.java with 100% similarity]
components/overlay/java/com/sun/lwuit/impl/ImplementationFactory.java [moved from core/java/com/sun/lwuit/events/DataChangedListener.java with 51% similarity]
components/overlay/java/com/sun/lwuit/util/Log.java [moved from core/java/com/sun/lwuit/util/Log.java with 100% similarity]
core/java/Makefile [deleted file]
core/java/com/sun/lwuit/Button.java [deleted file]
core/java/com/sun/lwuit/ButtonGroup.java [deleted file]
core/java/com/sun/lwuit/Calendar.java [deleted file]
core/java/com/sun/lwuit/CheckBox.java [deleted file]
core/java/com/sun/lwuit/ComboBox.java [deleted file]
core/java/com/sun/lwuit/Command.java [deleted file]
core/java/com/sun/lwuit/Component.java [deleted file]
core/java/com/sun/lwuit/Container.java [deleted file]
core/java/com/sun/lwuit/CustomFont.java [deleted file]
core/java/com/sun/lwuit/Dialog.java [deleted file]
core/java/com/sun/lwuit/Display.java [deleted file]
core/java/com/sun/lwuit/EditForm.java [deleted file]
core/java/com/sun/lwuit/EventDispatcher.java [deleted file]
core/java/com/sun/lwuit/Font.java [deleted file]
core/java/com/sun/lwuit/Form.java [deleted file]
core/java/com/sun/lwuit/Graphics.java [deleted file]
core/java/com/sun/lwuit/Image.java [deleted file]
core/java/com/sun/lwuit/IndexedImage.java [deleted file]
core/java/com/sun/lwuit/Label.java [deleted file]
core/java/com/sun/lwuit/List.java [deleted file]
core/java/com/sun/lwuit/MediaComponent.java [deleted file]
core/java/com/sun/lwuit/MonthView.java [deleted file]
core/java/com/sun/lwuit/Painter.java [deleted file]
core/java/com/sun/lwuit/Popup.java [deleted file]
core/java/com/sun/lwuit/RGBImage.java [deleted file]
core/java/com/sun/lwuit/RadioButton.java [deleted file]
core/java/com/sun/lwuit/RunnableWrapper.java [deleted file]
core/java/com/sun/lwuit/StaticAnimation.java [deleted file]
core/java/com/sun/lwuit/SystemFont.java [deleted file]
core/java/com/sun/lwuit/TabbedPane.java [deleted file]
core/java/com/sun/lwuit/TextArea.java [deleted file]
core/java/com/sun/lwuit/TextField.java [deleted file]
core/java/com/sun/lwuit/VirtualImplementation.java [deleted file]
core/java/com/sun/lwuit/animations/Animation.java [deleted file]
core/java/com/sun/lwuit/animations/CommonTransitions.java [deleted file]
core/java/com/sun/lwuit/animations/Motion.java [deleted file]
core/java/com/sun/lwuit/animations/Transition.java [deleted file]
core/java/com/sun/lwuit/animations/Transition3D.java [deleted file]
core/java/com/sun/lwuit/animations/package.html [deleted file]
core/java/com/sun/lwuit/events/ActionEvent.java [deleted file]
core/java/com/sun/lwuit/events/ActionListener.java [deleted file]
core/java/com/sun/lwuit/events/FocusListener.java [deleted file]
core/java/com/sun/lwuit/events/SelectionListener.java [deleted file]
core/java/com/sun/lwuit/events/StyleListener.java [deleted file]
core/java/com/sun/lwuit/events/package.html [deleted file]
core/java/com/sun/lwuit/geom/Dimension.java [deleted file]
core/java/com/sun/lwuit/geom/Rectangle.java [deleted file]
core/java/com/sun/lwuit/geom/package.html [deleted file]
core/java/com/sun/lwuit/layouts/BorderLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/BoxLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/CoordinateLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/FlowLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/GridLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/GroupLayout.java [deleted file]
core/java/com/sun/lwuit/layouts/Layout.java [deleted file]
core/java/com/sun/lwuit/layouts/LayoutStyle.java [deleted file]
core/java/com/sun/lwuit/layouts/package.html [deleted file]
core/java/com/sun/lwuit/list/DefaultListCellRenderer.java [deleted file]
core/java/com/sun/lwuit/list/DefaultListModel.java [deleted file]
core/java/com/sun/lwuit/list/ListCellRenderer.java [deleted file]
core/java/com/sun/lwuit/list/ListModel.java [deleted file]
core/java/com/sun/lwuit/list/package.html [deleted file]
core/java/com/sun/lwuit/package.html [deleted file]
core/java/com/sun/lwuit/painter/BackgroundPainter.java [deleted file]
core/java/com/sun/lwuit/painter/PainterChain.java [deleted file]
core/java/com/sun/lwuit/painter/package.html [deleted file]
core/java/com/sun/lwuit/plaf/Border.java [deleted file]
core/java/com/sun/lwuit/plaf/DefaultLookAndFeel.java [deleted file]
core/java/com/sun/lwuit/plaf/LookAndFeel.java [deleted file]
core/java/com/sun/lwuit/plaf/Style.java [deleted file]
core/java/com/sun/lwuit/plaf/UIManager.java [deleted file]
core/java/com/sun/lwuit/plaf/package.html [deleted file]
core/java/com/sun/lwuit/util/Effects.java [deleted file]
core/java/com/sun/lwuit/util/Resources.java [deleted file]
core/java/com/sun/lwuit/util/package.html [deleted file]
demos/java/org/thenesis/lwuimb/demo/BaseDemo.java

diff --git a/components/core/java/org/thenesis/lwuit/.gitignore b/components/core/java/org/thenesis/lwuit/.gitignore
new file mode 100644 (file)
index 0000000..e69de29
diff --git a/components/implementation/java/org/thenesis/lwuimb/EditForm.java b/components/implementation/java/org/thenesis/lwuimb/EditForm.java
new file mode 100644 (file)
index 0000000..b7c6b5e
--- /dev/null
@@ -0,0 +1,1749 @@
+package org.thenesis.lwuimb;\r
+\r
+import org.thenesis.microbackend.ui.KeyConstants;\r
+import org.thenesis.microbackend.ui.graphics.VirtualKeyboard;\r
+\r
+import com.sun.lwuit.Command;\r
+import com.sun.lwuit.Component;\r
+import com.sun.lwuit.Display;\r
+import com.sun.lwuit.Font;\r
+import com.sun.lwuit.Form;\r
+import com.sun.lwuit.Graphics;\r
+import com.sun.lwuit.Image;\r
+import com.sun.lwuit.Label;\r
+import com.sun.lwuit.TextArea;\r
+import com.sun.lwuit.events.ActionEvent;\r
+import com.sun.lwuit.events.ActionListener;\r
+import com.sun.lwuit.geom.Dimension;\r
+import com.sun.lwuit.geom.Rectangle;\r
+import com.sun.lwuit.layouts.BorderLayout;\r
+import com.sun.lwuit.plaf.Style;\r
+import com.sun.lwuit.util.Log;\r
+\r
+public class EditForm extends Form {\r
+\r
+    private VirtualKeyboardComponent keyboardComponent = new VirtualKeyboardComponent();\r
+    LWUIMBImplementation implementation;\r
+    private Form lastForm;\r
+    private TextArea textArea;\r
+    private EditableTextArea editableTextArea;\r
+\r
+    private Command okCommand;\r
+    private Command disableCommand;\r
+    private Command enableCommand;\r
+    private Command cancelCommand;\r
+\r
+    public EditForm(LWUIMBImplementation implementation, Form lastForm, TextArea textArea) {\r
+        super("Edit");\r
+        this.implementation = implementation;\r
+        this.lastForm = lastForm;\r
+        this.textArea = textArea;\r
+        setScrollable(false);\r
+\r
+        // Create subcomponent\r
+        keyboardComponent.setFocusable(true);\r
+        editableTextArea = new EditableTextArea(this, textArea);\r
+        editableTextArea.setFocusable(false);\r
+\r
+        // Add subcomponents to the form\r
+        setLayout(new BorderLayout());\r
+        addComponent(BorderLayout.CENTER, editableTextArea);\r
+        addComponent(BorderLayout.SOUTH, keyboardComponent);\r
+\r
+        // Create commands\r
+        okCommand = new Command("Ok");\r
+        addCommand(okCommand);\r
+        disableCommand = new Command("Disable Virtual Keyboard");\r
+        addCommand(disableCommand);\r
+        enableCommand = new Command("Enable Virtual Keyboard");\r
+        cancelCommand = new Command("Cancel");\r
+        addCommand(cancelCommand);\r
+        setCommandListener(new ActionListener() {\r
+            public void actionPerformed(ActionEvent e) {\r
+                if (e.getCommand() == okCommand) {\r
+                    saveAndExit();\r
+                } else if (e.getCommand() == disableCommand) {\r
+                    removeComponent(keyboardComponent);\r
+                    removeCommand(disableCommand);\r
+                    addCommand(enableCommand);\r
+                    editableTextArea.setFocusable(true);\r
+                } else if (e.getCommand() == enableCommand) {\r
+                    addComponent(BorderLayout.SOUTH, keyboardComponent);\r
+                    removeCommand(enableCommand);\r
+                    addCommand(disableCommand);\r
+                    editableTextArea.setFocusable(false);\r
+                } else if (e.getCommand() == cancelCommand) {\r
+                    cancel();\r
+                }\r
+                e.consume();\r
+            }\r
+        });\r
+\r
+        //registerAnimated(editableTextArea);\r
+\r
+    }\r
+\r
+    public void cancel() {\r
+        //        Display.getInstance().setCurrent(lastForm);\r
+        lastForm.show();\r
+    }\r
+\r
+    public void saveAndExit() {\r
+        textArea.setText(editableTextArea.getText());\r
+        //Display.getInstance().setCurrent(lastForm);\r
+        lastForm.show();\r
+    }\r
+\r
+    private class VirtualKeyboardComponent extends Label {\r
+\r
+        private Dimension dim = new Dimension(VirtualKeyboard.WIDTH, VirtualKeyboard.HEIGHT);\r
+        private int posX;\r
+        private int posY;\r
+        private VirtualKeyboard keyboard = new VirtualKeyboard();\r
+        private int[] buffer;\r
+        private Image keyboardImage;\r
+\r
+        /**\r
+         * Construct an empty label\r
+         */\r
+        public VirtualKeyboardComponent() {\r
+            VirtualKeyboardComponent.this.setHandlesInput(true);\r
+            VirtualKeyboardComponent.this.setFocusPainted(false);\r
+\r
+            buffer = new int[VirtualKeyboard.HEIGHT * VirtualKeyboard.WIDTH];\r
+            keyboard.activateCursor(true);\r
+        }\r
+\r
+        /**\r
+         * @inheritDoc\r
+         */\r
+        protected Dimension calcPreferredSize() {\r
+            return dim;\r
+        }\r
+\r
+        protected void initComponent() {\r
+            super.initComponent();\r
+            VirtualKeyboardComponent.this.requestFocus();\r
+        }\r
+\r
+        public void paint(Graphics g) {\r
+\r
+            if (keyboard.isDirty()) {\r
+                keyboard.draw(buffer);\r
+            }\r
+\r
+            calcPosition();\r
+            keyboardImage = Image.createImage(buffer, VirtualKeyboard.WIDTH, VirtualKeyboard.HEIGHT);\r
+            //g.fillRect(0, 0, width, height)\r
+            g.drawImage(keyboardImage, posX, posY);\r
+\r
+        }\r
+\r
+        public void handleKey(int key) {\r
+\r
+            if (key >= 0) {\r
+                //System.out.println("key " + key);\r
+                switch (key) {\r
+                case 10: // Enter\r
+                    editableTextArea.insertChar('\n');\r
+                    //completeInputMode(true);\r
+                    break;\r
+                case 24: // Cancel\r
+                    //completeInputMode(false);\r
+                    break;\r
+                case 8: // Backspace\r
+                    editableTextArea.deletePreviousChar();\r
+                    break;\r
+                case VirtualKeyboard.KEY_UP:\r
+                    editableTextArea.moveCaret(Display.GAME_UP, true);\r
+                    break;\r
+                case VirtualKeyboard.KEY_DOWN:\r
+                    editableTextArea.moveCaret(Display.GAME_DOWN, true);\r
+                    break;\r
+                case VirtualKeyboard.KEY_LEFT:\r
+                    editableTextArea.moveCaret(Display.GAME_LEFT, true);\r
+                    break;\r
+                case VirtualKeyboard.KEY_RIGHT:\r
+                    editableTextArea.moveCaret(Display.GAME_RIGHT, true);\r
+                    break;\r
+                default:\r
+                    editableTextArea.insertChar((char) key);\r
+                    //textField.insert(String.valueOf((char)key), textField.size());\r
+                }\r
+            }\r
+\r
+        }\r
+\r
+        public void keyPressed(int keyCode) {\r
+\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualKeyboardComponent.keyPressed()");\r
+\r
+            int gameAction = Display.getInstance().getGameAction(keyCode);\r
+\r
+            switch (gameAction) {\r
+            case Display.GAME_UP:\r
+                keyboard.moveUp();\r
+                break;\r
+            case Display.GAME_DOWN:\r
+                keyboard.moveDown();\r
+                break;\r
+            case Display.GAME_LEFT:\r
+                keyboard.moveLeft();\r
+                break;\r
+            case Display.GAME_RIGHT:\r
+                keyboard.moveRight();\r
+                break;\r
+            case Display.GAME_FIRE:\r
+                int key = keyboard.pushKey();\r
+                handleKey(key);\r
+                break;\r
+            }\r
+\r
+            if (keyboard.isDirty())\r
+                repaint();\r
+\r
+        }\r
+\r
+        public void keyReleased(int keyCode) {\r
+            keyboard.releaseKey();\r
+            if (keyboard.isDirty())\r
+                repaint();\r
+        }\r
+\r
+        public void pointerPressed(int x, int y) {\r
+            calcPosition();\r
+\r
+            //System.out.println("x=" + x + " y=" + y);\r
+            //            System.out.println("getX=" + getX() + " getY=" + getY() + " getW=" + getWidth() + " getH=" + getHeight());\r
+            //            System.out.println("Padding(LEFT)=" + getStyle().getPadding(Component.LEFT) + " Padding(RIGHT)=" + getStyle().getPadding(Component.RIGHT) + " Padding(TOP)=" + getStyle().getPadding(Component.TOP) + " Padding(BOTTOM)=" + getStyle().getPadding(Component.BOTTOM));\r
+            //            System.out.println("Margin(LEFT)=" + getStyle().getMargin(Component.LEFT) + " Margin(RIGHT)=" + getStyle().getMargin(Component.RIGHT) + " Margin(TOP)=" + getStyle().getMargin(Component.TOP) + " Margin(BOTTOM)=" + getStyle().getMargin(Component.BOTTOM));\r
+            //            System.out.println("posX=" + posX + " posY=" + posY);\r
+            //System.out.println("getAbsoluteX=" + getAbsoluteX() + " getAbsoluteY=" + getAbsoluteY());\r
+            //            System.out.println("(x - posX)=" + (x - posX) + "  (y - posY)=" + (y - posY));\r
+            //            int shift = -getStyle().getPadding(Component.TOP) - getStyle().getPadding(Component.BOTTOM) - getStyle().getMargin(Component.TOP) - getStyle().getMargin(Component.BOTTOM);\r
+            //            System.out.println("shift=" + shift)\r
+\r
+            // FIXME Where does the shift come from ? Bug ?\r
+            int shift = getAbsoluteY() - getY();\r
+            int key = keyboard.pushKey(x - posX, y - posY - shift);\r
+            handleKey(key);\r
+\r
+            if (keyboard.isDirty())\r
+                repaint();\r
+        }\r
+\r
+        public void pointerReleased(int x, int y) {\r
+            keyboard.releaseKey();\r
+            if (keyboard.isDirty())\r
+                repaint();\r
+        }\r
+\r
+        private void calcPosition() {\r
+            int x = getX(); // + c.getStyle().getPadding(Component.LEFT);\r
+            int y = getY(); // + c.getStyle().getPadding(Component.TOP);\r
+            int w = getWidth(); // - c.getStyle().getPadding(Component.LEFT) - c.getStyle().getPadding(Component.RIGHT);\r
+            int h = getHeight(); // - c.getStyle().getPadding(Component.TOP) - c.getStyle().getPadding(Component.BOTTOM) - c.getStyle().getMargin(Component.TOP) - c.getStyle().getMargin(Component.BOTTOM);\r
+            //System.out.println("w=" + w + " h=" + h);\r
+            posX = x + (w - VirtualKeyboard.WIDTH) / 2;\r
+            posY = y + (h - VirtualKeyboard.HEIGHT) / 2;\r
+        }\r
+\r
+    }\r
+\r
+}\r
+\r
+class EditableTextArea extends TextArea {\r
+\r
+    private EditForm editForm;\r
+    private int position = 0;\r
+\r
+    public EditableTextArea(EditForm editForm, TextArea ta) {\r
+        //this(ta.getText(), ta.getMaxSize(), 2, ta.getColumns(), ta.getConstraint());\r
+        super(ta.getText(), ta.getRows(), ta.getColumns(), ta.getConstraint());\r
+        setEditable(false);\r
+        this.editForm = editForm;\r
+    }\r
+\r
+    public void insertChar(char c) {\r
+        String text = getText();\r
+        int index = position + getCaretLine();\r
+        String newText = text.substring(0, index) + c + text.substring(index, text.length());\r
+        setText(newText);\r
+        position++;\r
+        repaint();\r
+    }\r
+\r
+    public boolean deleteChar() {\r
+        if (position > 0) {\r
+            int index = position + getCaretLine();\r
+            String text = getText();\r
+            String newText = text.substring(0, index) + text.substring(index + 1, text.length());\r
+            setText(newText);\r
+            repaint();\r
+            return true;\r
+        }\r
+        return true;\r
+    }\r
+\r
+    public boolean deletePreviousChar() {\r
+        if (position > 0) {\r
+            position--;\r
+            int index = position + getCaretLine();\r
+            String text = getText();\r
+            String newText = text.substring(0, index) + text.substring(index + 1, text.length());\r
+            setText(newText);\r
+            repaint();\r
+            return true;\r
+        }\r
+        return false;\r
+    }\r
+\r
+    private int getCaretLine() {\r
+        int lines = getLines();\r
+        int size = 0;\r
+\r
+        for (int i = 0; i < lines; i++) {\r
+            String t = getTextAt(i);\r
+            if (size + t.length() >= position) {\r
+                return i;\r
+            }\r
+            size += t.length();\r
+        }\r
+\r
+        return lines - 1;\r
+    }\r
+\r
+    private int getLengthAtLine(int line) {\r
+        int size = 0;\r
+        for (int i = 0; i < line; i++) {\r
+            String t = getTextAt(i);\r
+            size += t.length();\r
+        }\r
+        return size;\r
+    }\r
+\r
+    private int getCaretPositionInLine(int line) {\r
+        int lengthAtPreviousLine = (line == 0) ? 0 : getLengthAtLine(line);\r
+        //System.out.println("moveCaret: lengthAtPreviousLine=" + lengthAtPreviousLine);\r
+        int positionInLine = position - lengthAtPreviousLine;\r
+        return positionInLine;\r
+    }\r
+\r
+    public void moveCaret(int action, boolean fireKeyEvent) {\r
+\r
+        if (fireKeyEvent) {\r
+            onKeyPressed(action);\r
+        }\r
+\r
+        if (action == Display.GAME_DOWN) {\r
+            int caretLine = getCaretLine();\r
+            int caretPositionInLine = getCaretPositionInLine(caretLine);\r
+            //System.out.println("moveCaret: DOWN: caretLine=" + caretLine + " caretPositionInLine=" + caretPositionInLine);\r
+\r
+            if ((caretLine + 1) < getLines()) {\r
+                int length = getLengthAtLine(caretLine + 1);\r
+                String text = getText();\r
+                if (length < text.length()) {\r
+                    int newPositionInLine = Math.min(text.length() - length, caretPositionInLine);\r
+                    position = length + newPositionInLine;\r
+                }\r
+                repaint();\r
+            }\r
+\r
+        } else if (action == Display.GAME_UP) {\r
+            int caretLine = getCaretLine();\r
+            int caretPositionInLine = getCaretPositionInLine(caretLine);\r
+            //System.out.println("moveCaret: UP: caretLine=" + caretLine + " caretPositionInLine=" + caretPositionInLine);\r
+\r
+            if (caretLine > 0) {\r
+                int length = getLengthAtLine(caretLine - 1);\r
+                String text = getText();\r
+                if (length < text.length()) {\r
+                    int newPositionInLine = Math.min(text.length() - length, caretPositionInLine);\r
+                    position = length + newPositionInLine;\r
+                }\r
+                repaint();\r
+            }\r
+        } else if (action == Display.GAME_LEFT) {\r
+            if (position > 0) {\r
+                position--;\r
+                repaint();\r
+            }\r
+        } else if (action == Display.GAME_RIGHT) {\r
+            String text = getText();\r
+            if (position < text.length() - 1) {\r
+                position++;\r
+                repaint();\r
+            }\r
+        }\r
+\r
+    }\r
+\r
+    public void onKeyPressed(int action) {\r
+\r
+        int rowsGap = getRowsGap();\r
+        int linesToScroll = getLinesToScroll();\r
+\r
+        //scroll the TextArea\r
+        Rectangle rect = new Rectangle(getScrollX(), getScrollY(), getWidth(), getHeight());\r
+        Font textFont = getStyle().getFont();\r
+        if (action == Display.GAME_DOWN) {\r
+            //if((getScrollY() + getHeight()) <(rowsGap + getStyle().getFont().getHeight()) * getLines()) {\r
+            if ((getScrollY() + getHeight()) < (rowsGap + getStyle().getFont().getHeight()) * (getCaretLine() + 2)) {\r
+                rect.setY(rect.getY() + (textFont.getHeight() + rowsGap) * linesToScroll);\r
+                scrollRectToVisible(rect, this);\r
+            } else {\r
+                setHandlesInput(false);\r
+            }\r
+        } else {\r
+            if (action == Display.GAME_UP) {\r
+                if (getScrollY() > 0) {\r
+                    rect.setY(Math.max(0, rect.getY() - (textFont.getHeight() + rowsGap) * linesToScroll));\r
+                    scrollRectToVisible(rect, this);\r
+                } else {\r
+                    setHandlesInput(false);\r
+                }\r
+            }\r
+        }\r
+    }\r
+\r
+    public void keyPressed(int keyCode) {\r
+\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] EditForm.EditableTextArea.keyPressed(): keyCode=" + keyCode);\r
+\r
+        int action = Display.getInstance().getGameAction(keyCode);\r
+        onKeyPressed(action);\r
+\r
+        // Check if the key code is an action\r
+        if (action == Display.GAME_FIRE) {\r
+            insertChar('\n');\r
+            return;\r
+        } else if (action == Display.GAME_DOWN || action == Display.GAME_LEFT || action == Display.GAME_RIGHT || action == Display.GAME_UP) {\r
+            moveCaret(action, false);\r
+            return;\r
+        }\r
+\r
+        // Check if the keyCode is a system key or a a visible character\r
+        int systemKeyCode = editForm.implementation.getEventMapper().getSystemKey(keyCode);\r
+        if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_DELETE) {\r
+            deleteChar();\r
+        } else if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_BACKSPACE) {\r
+            deletePreviousChar();\r
+        } else { // Insert\r
+            char lastKeyChar = editForm.implementation.getLastKeyChar();\r
+            if (lastKeyChar != KeyConstants.CHAR_UNDEFINED) {\r
+                insertChar(lastKeyChar);\r
+            }\r
+        }\r
+    }\r
+\r
+    /**\r
+     * @inheritDoc\r
+     */\r
+    public void paint(Graphics g) {\r
+\r
+        setFG(g, this);\r
+        int line = getLines();\r
+        int oX = g.getClipX();\r
+        int oY = g.getClipY();\r
+        int oWidth = g.getClipWidth();\r
+        int oHeight = g.getClipHeight();\r
+        Font f = getStyle().getFont();\r
+        int fontHeight = f.getHeight();\r
+        for (int i = 0; i < line; i++) {\r
+            int x = getX() + getStyle().getPadding(Component.LEFT);\r
+            int y = getY() + getStyle().getPadding(Component.TOP) + (getRowsGap() + fontHeight) * i;\r
+            if (Rectangle.intersects(x, y, getWidth(), fontHeight, oX, oY, oWidth, oHeight)) {\r
+                String rowText = (String) getTextAt(i);\r
+                //display ******** if it is a password field\r
+                String displayText = "";\r
+                if ((getConstraint() & TextArea.PASSWORD) != 0) {\r
+                    for (int j = 0; j < rowText.length(); j++) {\r
+                        displayText += "*";\r
+                    }\r
+                } else {\r
+                    displayText = rowText;\r
+                }\r
+\r
+                g.drawString(displayText, x, y);\r
+\r
+                // Caret\r
+                if (getCaretLine() == i) {\r
+                    int cursorX = x + f.charsWidth(displayText.toCharArray(), 0, getCaretPositionInLine(i));\r
+                    int oldColor = g.getColor();\r
+                    g.setColor(0xFF0000);\r
+                    g.drawLine(cursorX, y, cursorX, y + fontHeight);\r
+                    g.setColor(oldColor);\r
+                }\r
+            }\r
+        }\r
+\r
+    }\r
+\r
+    /**\r
+     * Sets the foreground color and font for a generic component, reuse-able by\r
+     * most component drawing code\r
+     * \r
+     * @param g\r
+     *            graphics context\r
+     * @param c\r
+     *            component from which fg styles should be set\r
+     */\r
+    public void setFG(Graphics g, Component c) {\r
+        Style s = c.getStyle();\r
+        g.setFont(s.getFont());\r
+        if (c.isEnabled()) {\r
+            if (c.hasFocus() && c.isFocusPainted()) {\r
+                g.setColor(s.getFgSelectionColor());\r
+            } else {\r
+                g.setColor(s.getFgColor());\r
+            }\r
+        } else {\r
+            g.setColor(disableColor);\r
+        }\r
+    }\r
+\r
+    /**\r
+     * This color is used to paint disable mode.\r
+     */\r
+    private int disableColor = 0xcccccc;\r
+\r
+}\r
+\r
+//class EditableTextArea extends TextArea {\r
+//    \r
+//    private EditForm editForm;\r
+//    private int position = 0;\r
+//\r
+//    public EditableTextArea(EditForm editForm, TextArea ta) {\r
+//        //this(ta.getText(), ta.getMaxSize(), 2, ta.getColumns(), ta.getConstraint());\r
+//        super("|" + ta.getText(), ta.getRows(), ta.getColumns(), ta.getConstraint());\r
+//        setEditable(false);\r
+//        this.editForm = editForm;\r
+//    }\r
+//  \r
+//\r
+//    public void insertChar(char c) {\r
+//        insertChar(c, position);\r
+//    }\r
+//\r
+//    private void insertChar(char c, int p) {\r
+//        String text = getText();\r
+//        String newText = text.substring(0, p) + c + text.substring(p, text.length());\r
+//        setText(newText);\r
+//        position++;\r
+//    }\r
+//\r
+//    public boolean deleteChar() {\r
+//        System.out.println("[DEBUG] EditForm.EditableTextArea.deleteChar()");\r
+//        if (position > 0) {\r
+//            String text = getText();\r
+//            String newText = text.substring(0, position) + "|" + text.substring(position + 2, text.length());\r
+//            setText(newText);\r
+//            return true;\r
+//        }\r
+//        return true;\r
+//    }\r
+//\r
+////    private boolean deleteChar(int p) {\r
+////        if (position > 0) {\r
+////            position--;\r
+////            String text = getText();\r
+////            String newText = text.substring(0, position) + "|" + text.substring(position + 2, text.length());\r
+////            setText(newText);\r
+////            return true;\r
+////        }\r
+////        return true;\r
+////    }\r
+//\r
+//    public boolean deletePreviousChar() {\r
+//        System.out.println("[DEBUG] EditForm.EditableTextArea.deletePreviousChar()");\r
+//        if (position > 0) {\r
+//            position--;\r
+//            String text = getText();\r
+//            String newText = text.substring(0, position) + "|" + text.substring(position + 2, text.length());\r
+//            setText(newText);\r
+//            return true;\r
+//        }\r
+//        return false;\r
+//    }\r
+//    \r
+//    private int getCaretLine() {\r
+//        int lines = getLines();\r
+//        int size = 0;\r
+//        \r
+//        for (int i  = 0; i < lines; i++) {\r
+//            String t = getTextAt(i);\r
+//            if (size + t.length() >= position) {\r
+//                return i;\r
+//            }\r
+//            size += t.length();\r
+//        }\r
+//        \r
+//        return lines - 1;\r
+//    }\r
+//    \r
+//    private int getLengthAtLine(int line) {\r
+//        int size = 0;\r
+//        for (int i  = 0; i < line; i++) {\r
+//            String t = getTextAt(i);\r
+//            size += t.length();\r
+//        }\r
+//        return size;\r
+//    }\r
+//    \r
+//    private int getCaretPositionInLine(int line) {\r
+//        int lengthAtPreviousLine  = (line == 0) ? 0 : getLengthAtLine(line);\r
+//        //System.out.println("moveCaret: lengthAtPreviousLine=" + lengthAtPreviousLine);\r
+//        int positionInLine = position - lengthAtPreviousLine;\r
+//        return positionInLine;\r
+//    }\r
+//    \r
+//    public String removeCaretFromText() {\r
+//        String text = getText();\r
+//        String newText = text.substring(0, position ) +  text.substring(position + 1, text.length());\r
+//        return newText;\r
+//    }\r
+//    \r
+//    private String insertCaretAtPosition(String text, int p) {\r
+//        String newText = text.substring(0, p ) +  "|" + text.substring(p, text.length());\r
+//        return newText;\r
+//    }\r
+//\r
+//    public void moveCaret(int action) {\r
+//        \r
+//      if (action == Display.GAME_DOWN) {\r
+//          int caretLine = getCaretLine();\r
+//          int caretPositionInLine = getCaretPositionInLine(caretLine);\r
+//          //System.out.println("moveCaret: DOWN: caretLine=" + caretLine + " caretPositionInLine=" + caretPositionInLine);\r
+//          \r
+//          if ((caretLine + 1) < getLines()) {\r
+//              int length = getLengthAtLine(caretLine + 1);\r
+//              String text = removeCaretFromText();\r
+//              if (length < text.length()) {\r
+//                  int newPositionInLine = Math.min(text.length() - length, caretPositionInLine);\r
+//                  position = length + newPositionInLine;\r
+//                  String newText = insertCaretAtPosition(text, position);\r
+//                  setText(newText);\r
+//              }\r
+//          }\r
+//         \r
+//      } else if (action == Display.GAME_UP) {\r
+//          int caretLine = getCaretLine();\r
+//          int caretPositionInLine = getCaretPositionInLine(caretLine);\r
+//          //System.out.println("moveCaret: UP: caretLine=" + caretLine + " caretPositionInLine=" + caretPositionInLine);\r
+//          \r
+//          if (caretLine > 0) {\r
+//              int length = getLengthAtLine(caretLine - 1);\r
+//              String text = removeCaretFromText();\r
+//              if (length < text.length()) {\r
+//                  int newPositionInLine = Math.min(text.length() - length, caretPositionInLine);\r
+//                  position = length - 1 + newPositionInLine;\r
+//                  String newText = insertCaretAtPosition(text, position);\r
+//                  setText(newText);\r
+//              }\r
+//          }\r
+//      } else if (action == Display.GAME_LEFT) {\r
+//          String text = getText();\r
+//          if (position > 0) {\r
+//              String newText = text.substring(0, position - 1) + "|" + text.charAt(position - 1)  + text.substring(position + 1, text.length());\r
+//              setText(newText);\r
+//              position--;\r
+//          }\r
+//      } else if (action == Display.GAME_RIGHT) {\r
+//          String text = getText();\r
+//          if (position < text.length() - 1) {\r
+//              String newText = text.substring(0, position) +  text.charAt(position + 1) + "|" + text.substring(position + 2, text.length());\r
+//              setText(newText);\r
+//              position++;\r
+//          }\r
+//      }\r
+//\r
+//    }\r
+//    \r
+//  public void keyPressed(int keyCode) {\r
+//        super.keyPressed(keyCode);\r
+//\r
+//        //if (Log.TRACE_ENABLED)\r
+//            System.out.println("[DEBUG] EditForm.EditableTextArea.keyPressed(): keyCode=" + keyCode);\r
+//\r
+//        // Check if the key code is an action\r
+//        int action = Display.getInstance().getGameAction(keyCode);\r
+//        if (action == Display.GAME_FIRE) {\r
+//            insertChar('\n');\r
+//            return;\r
+//        } else if (action == Display.GAME_DOWN || action == Display.GAME_LEFT || action == Display.GAME_RIGHT || action == Display.GAME_UP) {\r
+//            moveCaret(action);\r
+//            return;\r
+//        }\r
+//\r
+//        // Check if the keyCode is a system key or a a visible character\r
+//        int systemKeyCode = editForm.implementation.getEventMapper().getSystemKey(keyCode);\r
+//        if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_DELETE) {\r
+//           deleteChar();\r
+//        } else if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_BACKSPACE) {\r
+//            deletePreviousChar();\r
+//        } else { // Insert\r
+//            char lastKeyChar = editForm.implementation.getLastKeyChar();\r
+//            if (lastKeyChar != KeyConstants.CHAR_UNDEFINED) {\r
+//                insertChar(lastKeyChar);\r
+//            }\r
+//        }\r
+//    }\r
+//    \r
+//}\r
+\r
+///**\r
+// * An multi-line editable region that can display text and allow a user to edit\r
+// * it.\r
+// */\r
+//class EditableTextArea extends Component {\r
+//    private static int defaultMaxSize = 124;\r
+//    private static boolean autoDegradeMaxSize = false;\r
+//    private static boolean hadSuccessfulEdit = false;\r
+//\r
+//    private int linesToScroll = 1;\r
+//    \r
+//    /**\r
+//     * Unsupported characters is a string that contains characters that cause issues \r
+//     * when rendering on some problematic fonts. The rendering engine can thus remove them\r
+//     * when drawing.\r
+//     */\r
+//    private String unsupportedChars = "\t\r";\r
+//    \r
+//    /**\r
+//     * Allows any type of input into a text field, if a constraint is not\r
+//     * supported by an underlying implementation this will be the default.\r
+//     */\r
+//    public static final int ANY = 0;\r
+//\r
+//    /**\r
+//     * The user is allowed to enter an e-mail address.\r
+//     */\r
+//    public static final int EMAILADDR = 1;\r
+//\r
+//    /**\r
+//     * The user is allowed to enter only an integer value.\r
+//     */\r
+//    public static final int NUMERIC = 2;\r
+//\r
+//    /**\r
+//     * The user is allowed to enter a phone number.\r
+//     */\r
+//    public static final int PHONENUMBER = 3;\r
+//\r
+//    /**\r
+//     * The user is allowed to enter a URL.\r
+//     */\r
+//    public static final int URL = 4;\r
+//\r
+//    /**\r
+//     * The user is allowed to enter numeric values with optional decimal\r
+//     * fractions, for example "-123", "0.123", or ".5".\r
+//     */\r
+//    public static final int DECIMAL = 5;\r
+//\r
+//    /**\r
+//     * Indicates that the text entered is confidential data that should be\r
+//     * obscured whenever possible.\r
+//     */\r
+//    public static final int PASSWORD = 0x10000;\r
+//\r
+//    /**\r
+//     * Indicates that editing is currently disallowed.\r
+//     */\r
+//    public static final int UNEDITABLE = 0x20000;\r
+//\r
+//    /**\r
+//     * Indicates that the text entered is sensitive data that the implementation\r
+//     * must never store into a dictionary or table for use in predictive,\r
+//     * auto-completing, or other accelerated input schemes.\r
+//     */\r
+//    public static final int SENSITIVE = 0x40000;\r
+//\r
+//    /**\r
+//     * Indicates that the text entered does not consist of words that are likely\r
+//     * to be found in dictionaries typically used by predictive input schemes.\r
+//     */\r
+//    public static final int NON_PREDICTIVE = 0x80000;\r
+//\r
+//    /**\r
+//     * This flag is a hint to the implementation that during text editing, the\r
+//     * initial letter of each word should be capitalized.\r
+//     */\r
+//    public static final int INITIAL_CAPS_WORD = 0x100000;\r
+//\r
+//    /**\r
+//     * This flag is a hint to the implementation that during text editing, the\r
+//     * initial letter of each sentence should be capitalized.\r
+//     */\r
+//    public static final int INITIAL_CAPS_SENTENCE = 0x200000;\r
+//    //private int modifierFlag = 0x00000;\r
+//\r
+//    /**\r
+//     * Input constraint which should be one of CONSTRAINT_ANY,\r
+//     * CONSTRAINT_NUMERIC, CONSTRAINT_PHONENUMBER, CONSTRAINT_URL or\r
+//     * CONSTRAINT_EMAIL\r
+//     */\r
+//    private int constraint = ANY;\r
+//\r
+//    private String text = "";\r
+//\r
+//    private boolean editable = true;\r
+//\r
+//    private int maxSize = defaultMaxSize; //maximum size (number of characters) that can be stored in this TextField.\r
+//\r
+//    private int rows = 1;\r
+//\r
+//    private int columns = 1;\r
+//\r
+//    // problematic  maxSize = 20; //maximum size (number of characters) that can be stored in this TextField.\r
+//\r
+//    private static String id = "TextArea";\r
+//\r
+//    private Vector rowStrings;\r
+//    private int widthForRowCalculations = -1;\r
+//\r
+//    private int rowsGap = 2;\r
+//\r
+//    private boolean triggerClose;\r
+//\r
+//    private Vector actionListeners = null;\r
+//\r
+//    /**\r
+//     * Indicates that the text area should "grow" in height based on the content\r
+//     * beyond the limits indicate by the rows variable\r
+//     */\r
+//    private boolean growByContent = true;\r
+//    \r
+//    /**\r
+//     * Indicates the widest character in the alphabet, this is useful for detecting\r
+//     * linebreaks internally. In CJK languages the widest char is different than W\r
+//     * hence this functionality is exposed to developers.\r
+//     */\r
+//    private static char widestChar = 'W';\r
+//\r
+//    private int cursorRow = 0;\r
+//    private int cursorColumn = 0;\r
+//\r
+//    private EditForm editForm;\r
+//\r
+//    /**\r
+//     * Creates an area with the given text, maximum size, rows, columns and\r
+//     * constrint\r
+//     * \r
+//     * @param text\r
+//     *            the text to be displayed; if text is null, the empty string ""\r
+//     *            will be displayed\r
+//     * @param maxSize\r
+//     *            text area maximum size\r
+//     * @param rows\r
+//     *            the number of rows\r
+//     * @param columns\r
+//     *            - the number of columns\r
+//     * @param constraint\r
+//     *            one of ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, DECIMAL it\r
+//     *            can be bitwised or'd with one of PASSWORD, UNEDITABLE,\r
+//     *            SENSITIVE, NON_PREDICTIVE, INITIAL_CAPS_SENTENCE,\r
+//     *            INITIAL_CAPS_WORD. E.g. ANY | PASSWORD.\r
+//     */\r
+//    public EditableTextArea(EditForm form, TextArea ta) {\r
+//        // FIXME\r
+//        this(ta.getText(), ta.getMaxSize(), 2, ta.getColumns(), ta.getConstraint());\r
+//        //this(ta.getText(), ta.getMaxSize(), ta.getRows(), ta.getColumns(), ta.getConstraint());\r
+//        this.editForm = form;\r
+//    }\r
+//\r
+//    private EditableTextArea(String text, int maxSize, int rows, int columns, int constraint) {\r
+//        this.maxSize = maxSize;\r
+//        setText(text);\r
+//        setConstraint(constraint);\r
+//        this.rows = rows;\r
+//        this.columns = columns;\r
+//        LookAndFeel laf = UIManager.getInstance().getLookAndFeel();\r
+//        setSmoothScrolling(laf.isDefaultSmoothScrolling());\r
+//        setHandlesInput(true);\r
+//\r
+//        //            Style style = new Style();\r
+//        //            style.setBgColor(0xFFFFFF, false);\r
+//        //            style.setFgColor(0x000000, false);\r
+//        //            style.setBgSelectionColor(0xFFFFFF, false);\r
+//        //            style.setFgSelectionColor(0x000000, false);\r
+//        //            style.setFont(Font.getDefaultFont(), false);\r
+//        //            setStyle(style);\r
+//    }\r
+//\r
+//    //        public boolean animate() {\r
+//    //            return true;\r
+//    //        }\r
+//\r
+//    /**\r
+//     * Sets the constraint\r
+//     * \r
+//     * @param constraint\r
+//     *            one of ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, DECIMAL it\r
+//     *            can be bitwised or'd with one of PASSWORD, UNEDITABLE,\r
+//     *            SENSITIVE, NON_PREDICTIVE, INITIAL_CAPS_SENTENCE,\r
+//     *            INITIAL_CAPS_WORD. E.g. ANY | PASSWORD.\r
+//     */\r
+//    public void setConstraint(int constraint) {\r
+//        this.constraint = constraint;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the editing constraint value\r
+//     * \r
+//     * @return the editing constraint value\r
+//     * @see #setConstraint\r
+//     */\r
+//    public int getConstraint() {\r
+//        return constraint;\r
+//    }\r
+//\r
+//    /**\r
+//     * Sets the text within this text area\r
+//     * \r
+//     * @param t\r
+//     *            new value for the text area\r
+//     */\r
+//    public void setText(String t) {\r
+//        setTextInternal(t);\r
+//        repaint();\r
+//    }\r
+//\r
+//    private void setTextInternal(String t) {\r
+//        this.text = (t != null) ? t : "";\r
+//        setShouldCalcPreferredSize(true);\r
+//        if(maxSize < text.length()) {\r
+//            maxSize = text.length() + 1;\r
+//        }\r
+//        \r
+//        // reset scrolling\r
+//        setScrollX(0);\r
+//        setScrollY(0);\r
+//        \r
+//        // special case to make the text field really fast...\r
+//        rowStrings=null; //zero the vector inorder to initialize it on the next paint\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the text in the text area\r
+//     * \r
+//     * @return the text in the text area\r
+//     */\r
+//    public String getText() {\r
+//        return text;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns true if this area is editable\r
+//     * \r
+//     * @return true if this area is editable\r
+//     */\r
+//    public boolean isEditable() {\r
+//        return editable;\r
+//    }\r
+//\r
+//    /**\r
+//     * Sets this text area to be editable or readonly\r
+//     * \r
+//     * @param b\r
+//     *            true is text are is editable; otherwise false\r
+//     */\r
+//    public void setEditable(boolean b) {\r
+//        editable = b;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the maximum size for the text area\r
+//     * \r
+//     * @return the maximum size for the text area\r
+//     */\r
+//    public int getMaxSize() {\r
+//        return maxSize;\r
+//    }\r
+//\r
+//    /**\r
+//     * Sets the maximum size of the text area\r
+//     * \r
+//     * @param maxSize\r
+//     *            the maximum size of the text area\r
+//     */\r
+//    public void setMaxSize(int maxSize) {\r
+//        this.maxSize = maxSize;\r
+//    }\r
+//\r
+//    private int getCursorPosition(int row, int column) {\r
+//        Vector rowsV = getRowStrings();\r
+//        int index = 0;\r
+//        for (int i = 0; i <= row; i++) {\r
+//            if (i == cursorRow) {\r
+//                index += cursorColumn;\r
+//            } else {\r
+//                String s = (String) rowsV.elementAt(i);\r
+//                index += s.length();\r
+//            }\r
+//        }\r
+//        return index;\r
+//    }\r
+//\r
+//    private void setCursorPosition(int position) {\r
+//        Vector rowsV = getRowStrings();\r
+//        int index = 0;\r
+//        for (int i = 0; i < rowsV.size(); i++) {\r
+//            int rowSize = ((String) rowsV.elementAt(i)).length();\r
+//            if ((position >= index) && (position < (index + rowSize))) {\r
+//                cursorRow = i;\r
+//                cursorColumn = position - index;\r
+//                break;\r
+//            } else {\r
+//                index += rowSize;\r
+//            }\r
+//        }\r
+//\r
+//    }\r
+//\r
+//    public void insertChar(char c) {\r
+//        int position = getCursorPosition(cursorRow, cursorColumn);\r
+//        insertChar(c, position);\r
+//    }\r
+//\r
+//    private void insertChar(char c, int position) {\r
+//        String newText = text.substring(0, position) + c + text.substring(position, text.length());\r
+//        setTextInternal(newText);\r
+//        setCursorPosition(position + 1);\r
+//    }\r
+//\r
+//    public boolean deleteChar() {\r
+//        int position = getCursorPosition(cursorRow, cursorColumn);\r
+//        return deleteChar(position);\r
+//    }\r
+//\r
+//    private boolean deleteChar(int position) {\r
+//        if (text.length() > 0) {\r
+//            System.out.println("text.charAt(position)=" + text.charAt(position));\r
+//            String newText = text.substring(0, position) + text.substring(position + 1, text.length());\r
+//            setTextInternal(newText);\r
+//            return true;\r
+//        }\r
+//        return false;\r
+//    }\r
+//\r
+//    public boolean deletePreviousChar() {\r
+//        int position = getCursorPosition(cursorRow, cursorColumn);\r
+//        if (position > 0) {\r
+//            setCursorPosition(position - 1);\r
+//            deleteChar(position - 1);\r
+//            return true;\r
+//        }\r
+//        return false;\r
+//    }\r
+//\r
+//    public void moveCaret(int action) {\r
+//\r
+//        //scroll the TextArea\r
+//        Rectangle rect = new Rectangle(getScrollX(), getScrollY(), getWidth(), getHeight());\r
+//        Font textFont = getStyle().getFont();\r
+//\r
+//        // TODO Remove\r
+//        //System.out.println("cursorRow =" + cursorRow + " cursorColumn=" + cursorColumn + "rows=" + rows + " column=" + columns);\r
+//\r
+//        if (action == Display.GAME_DOWN) {\r
+//            cursorRow++;\r
+//            if ((getScrollY() + getHeight()) < (rowsGap + getStyle().getFont().getHeight()) * getLines()) {\r
+//                rect.setY(rect.getY() + textFont.getHeight() + rowsGap);\r
+//                scrollRectToVisible(rect, this);\r
+//            } else {\r
+//                setHandlesInput(false);\r
+//            }\r
+//        } else if (action == Display.GAME_UP) {\r
+//            cursorRow--;\r
+//            if (getScrollY() > 0) {\r
+//                rect.setY(Math.max(0, rect.getY() - textFont.getHeight() - rowsGap));\r
+//                scrollRectToVisible(rect, this);\r
+//            } else {\r
+//                setHandlesInput(false);\r
+//            }\r
+//        } else if (action == Display.GAME_LEFT) {\r
+//            cursorColumn--;\r
+//        } else if (action == Display.GAME_RIGHT) {\r
+//            cursorColumn++;\r
+//        }\r
+//\r
+//        // Check bounds\r
+//        if (cursorRow < 0) {\r
+//            cursorRow = 0;\r
+//        }\r
+//        int nRows = getRowStrings().size();\r
+//        if (nRows > 0) {\r
+//            if (cursorRow > nRows - 1) {\r
+//                cursorRow = nRows - 1;\r
+//            }\r
+//            if (cursorColumn < 0) {\r
+//                cursorColumn = 0;\r
+//            }\r
+//            String s = getTextAt(cursorRow);\r
+//            if (cursorColumn > s.length()) {\r
+//                cursorColumn = s.length();\r
+//            }\r
+//            int position = getCursorPosition(cursorRow, cursorColumn);\r
+////            System.out.println("position=" + position + " text.charAt(position)=" + text.charAt(position) + " line.charAt(cursorColumn)="\r
+////                    + s.charAt(cursorColumn));\r
+////            System.out.println("s.length()=" + s.length() + " cursor position=" + getCursorPosition(cursorRow, cursorColumn) + " c="\r
+////                    + text.charAt(getCursorPosition(cursorRow, cursorColumn)));\r
+//        }\r
+//\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    public void keyPressed(int keyCode) {\r
+//        super.keyPressed(keyCode);\r
+//\r
+//        if (Log.TRACE_ENABLED)\r
+//            System.out.println("[DEBUG] EditForm.EditableTextArea.keyPressed(): keyCode=" + keyCode);\r
+//\r
+//        // Check if the key code is an action\r
+//        int action = Display.getInstance().getGameAction(keyCode);\r
+//        if (action == Display.GAME_FIRE) {\r
+//            insertChar('\n');\r
+//            repaint();\r
+//            return;\r
+//        } else if (action == Display.GAME_DOWN || action == Display.GAME_LEFT || action == Display.GAME_RIGHT || action == Display.GAME_UP) {\r
+//            moveCaret(action);\r
+//            repaint();\r
+//            return;\r
+//        }\r
+//\r
+//        // Check if the keyCode is a system key or a a visible character\r
+//        int systemKeyCode = editForm.implementation.getEventMapper().getSystemKey(keyCode);\r
+//        if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_DELETE) {\r
+//            if (deleteChar()) {\r
+//                repaint();\r
+//            }\r
+//        } else if (systemKeyCode == LWUIMBImplementation.SYSTEM_KEY_BACKSPACE) {\r
+//            if (deletePreviousChar()) {\r
+//                repaint();\r
+//            }\r
+//        } else { // Insert\r
+//            char lastKeyChar = editForm.implementation.getLastKeyChar();\r
+//            if (lastKeyChar != KeyConstants.CHAR_UNDEFINED) {\r
+//                insertChar(lastKeyChar);\r
+//            }\r
+//            repaint();\r
+//        }\r
+//\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    protected void fireClicked() {\r
+//        onClick();\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    protected boolean isSelectableInteraction() {\r
+//        return editable;\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    public void keyReleased(int keyCode) {\r
+//        //        int action = com.sun.lwuit.Display.getInstance().getGameAction(keyCode);\r
+//        //        if (isEditable()) {\r
+//        //            // this works around a bug where fire is also a softkey on devices such as newer Nokia\r
+//        //            // series 40's\r
+//        //            if (triggerClose && action == Display.GAME_FIRE) {\r
+//        //                triggerClose = false;\r
+//        //                onClick();\r
+//        //                return;\r
+//        //            }\r
+//        //        }\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    public boolean isScrollableY() {\r
+//        return (rowsGap + getStyle().getFont().getHeight()) * getLines() > getHeight();\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    protected void paintScrollbarY(Graphics g) {\r
+//        int prefH = (rowsGap + getStyle().getFont().getHeight()) * getLines();\r
+//        float offset = ((float) getScrollY()) / ((float) prefH);\r
+//        float block = ((float) getHeight()) / ((float) prefH);\r
+//        UIManager.getInstance().getLookAndFeel().drawVerticalScroll(g, this, offset, block);\r
+//    }\r
+//\r
+//    void onClick() {\r
+//        //            if (isEditable()) {\r
+//        //                editString();\r
+//        //            }\r
+//    }\r
+//\r
+//    //        void editString() {\r
+//    //            if (autoDegradeMaxSize && (!hadSuccessfulEdit) && (maxSize > 1024)) {\r
+//    //                try {\r
+//    //                    Display.getInstance().editString(this, getMaxSize(), getConstraint(), getText());\r
+//    //                } catch (IllegalArgumentException err) {\r
+//    //                    maxSize -= 1024;\r
+//    //                    setDefaultMaxSize(maxSize);\r
+//    //                    editString();\r
+//    //                }\r
+//    //            } else {\r
+//    //                Display.getInstance().editString(this, getMaxSize(), getConstraint(), getText());\r
+//    //            }\r
+//    //        }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    public void pointerReleased(int x, int y) {\r
+//        super.pointerReleased(x, y);\r
+//        if (isEditable()) {\r
+//            onClick();\r
+//        }\r
+//    }\r
+//\r
+////    /**\r
+////     * @inheritDoc\r
+////     */\r
+////    void focusGainedInternal() {\r
+////        super.focusGainedInternal();\r
+////        //setHandlesInput(isScrollableY());\r
+////        //setHandlesInput(true);\r
+////    }\r
+////\r
+////    /**\r
+////     * @inheritDoc\r
+////     */\r
+////    void focusLostInternal() {\r
+////        super.focusLostInternal();\r
+////        //setHandlesInput(false);\r
+////        //setHandlesInput(false);\r
+////    }\r
+//\r
+//    /**\r
+//     * Returns the number of columns in the text area\r
+//     * \r
+//     * @return the number of columns in the text area\r
+//     */\r
+//    public int getColumns() {\r
+//        return columns;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the number of rows in the text area\r
+//     * \r
+//     * @return the number of rows in the text area\r
+//     */\r
+//    public int getRows() {\r
+//        return rows;\r
+//    }\r
+//\r
+//    /**\r
+//     * Sets the number of columns in the text area\r
+//     * \r
+//     * @param columns\r
+//     *            number of columns\r
+//     */\r
+//    public void setColumns(int columns) {\r
+//        setShouldCalcPreferredSize(true);\r
+//        this.columns = columns;\r
+//    }\r
+//\r
+//    /**\r
+//     * Sets the number of rows in the text area\r
+//     * \r
+//     * @param rows\r
+//     *            number of rows\r
+//     */\r
+//    public void setRows(int rows) {\r
+//        setShouldCalcPreferredSize(true);\r
+//        this.rows = rows;\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    protected String getUIID() {\r
+//        return id;\r
+//    }\r
+//\r
+////    void initComponentImpl() {\r
+////        super.initComponentImpl();\r
+////        getRowStrings();\r
+////    }\r
+//\r
+//    private Vector getRowStrings() {\r
+//        if (rowStrings == null || widthForRowCalculations != getWidth()) {\r
+//            initRowString();\r
+//            setShouldCalcPreferredSize(true);\r
+//            //setPreferredH(getStyle().getPadding(TOP) + getStyle().getPadding(BOTTOM) + (getStyle().getFont().getHeight() + rowsGap)*rowStrings.size());\r
+//        }\r
+//        return rowStrings;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the number of text lines in the TextArea\r
+//     * \r
+//     * @return the number of text lines in the TextArea\r
+//     */\r
+//    public int getLines() {\r
+//        int retVal;\r
+//        Vector v = getRowStrings();\r
+//        retVal = v.size();\r
+//        return retVal;\r
+//    }\r
+//\r
+//    /**\r
+//     * Returns the text in the given row of the text box\r
+//     * \r
+//     * @param line\r
+//     *            the line number in the text box\r
+//     */\r
+//    public String getTextAt(int line) {\r
+//        Vector rowsV = getRowStrings();\r
+//        return (String) rowsV.elementAt(line);\r
+//    }\r
+//\r
+//    private int indexOf(char[] t, char c, int offset, int length) {\r
+//        for(int iter = offset ; iter < t.length && iter < offset+length; iter++) {\r
+//            if(t[iter] == c) {\r
+//                return iter;\r
+//           }\r
+//       }\r
+//       return -1;\r
+//   }\r
+//\r
+//    private boolean fastCharWidthCheck(char[] chrs, int off, int length, int width, int charWidth, Font f) {\r
+//        if (length * charWidth < width) {\r
+//            return true;\r
+//        }\r
+//        return f.charsWidth(chrs, off, length) < width;\r
+//    }\r
+//    \r
+//    /**\r
+//     * Override this to modify the text for rendering in cases of invalid characters \r
+//     * for display, this method allows the developer to replace such characters e.g.:\r
+//     * replace "\\t" with 4 spaces\r
+//     * \r
+//     * @param text the text to process\r
+//     * @return the given string as a processed char array ready for rendering\r
+//     */\r
+//    protected char[] preprocess(String text) {\r
+//        return text.toCharArray();\r
+//    }\r
+//\r
+//    private void initRowString() {\r
+//        rowStrings= new Vector();\r
+//        widthForRowCalculations = getWidth();\r
+//        \r
+//        // single line text area is essentially a text field\r
+//        if(rows == 1) {\r
+//            rowStrings.addElement(getText());\r
+//            return;\r
+//        }\r
+//        if(text == null || text.equals("")){\r
+//            return;\r
+//        }\r
+//        char[] text = preprocess(getText());\r
+//        \r
+//        int rows = this.rows;\r
+//        if(growByContent) {\r
+//            rows = Math.max(rows, getLines());\r
+//        }\r
+//        Style style = getStyle();\r
+//        Font font = style.getFont();\r
+//        int charWidth = font.charWidth(widestChar);\r
+//        int textAreaWidth = getWidth()- style.getPadding(RIGHT) - style.getPadding(LEFT)- \r
+//            style.getMargin(RIGHT) - style.getMargin(LEFT); //(border(=gap) + gap )*2\r
+//        if(textAreaWidth <= 0) {\r
+//            textAreaWidth = Math.min(10, columns) * charWidth;\r
+//        }\r
+//        int minCharactersInRow = Math.max(1, textAreaWidth / charWidth);\r
+//        int rowIndex=0;\r
+//        int from=0;\r
+//        int to=from+minCharactersInRow;\r
+//        int textLength=text.length;\r
+//        String rowText;\r
+//        int i,spaceIndex;\r
+//        \r
+//        // if there is any possibility of a scrollbar we need to reduce the textArea\r
+//        // width to accommodate it\r
+//        if(textLength / minCharactersInRow > Math.max(2, rows)) {\r
+//            textAreaWidth -= UIManager.getInstance().getLookAndFeel().getVerticalScrollWidth();\r
+//        }\r
+//        \r
+//        String unsupported = getUnsupportedChars();\r
+//        \r
+//        /*\r
+//        iteration over the string using indexes, from - the beginning of the row , to - end of a row\r
+//        for each row we will try to search for a "space" character at the end of the row ( row is text area available width)\r
+//        indorder to improve the efficiency we do not search an entire row but we start from minCharactersInRow which indicates\r
+//        what is the minimum amount of characters that can feet in the text area width.\r
+//        if we dont find we will go backwards and search for the first space available,\r
+//        if there is no space in the entire row we will cut the line inorder to fit in.\r
+//         */\r
+//\r
+//        //Don't rely on the fact that short text has no newline character. we always have to parse the text.\r
+//        to = Math.max( Math.min(textLength-1,to), 0 );\r
+//        while(to<textLength) {\r
+//            if(to>textLength){\r
+//                to=textLength;\r
+//            }\r
+//\r
+//            spaceIndex=-1;\r
+//            rowText="";\r
+//            int maxLength = to;\r
+//\r
+//            // search for "space" character at close as possible to the end of the row\r
+//            for( i=to; i < textLength && fastCharWidthCheck(text, from, i - from, textAreaWidth, charWidth, font)  ; i++){\r
+//                char c = text[i];\r
+//                if(unsupported.indexOf(c) > -1) {\r
+//                    text[i] = ' ';\r
+//                }\r
+//                if(c == ' ' || c == '\n') {\r
+//                    spaceIndex=i;\r
+//                    // newline has been found. We can end the loop here as the line cannot grow more\r
+//                    if (c == '\n')\r
+//                        break; \r
+//                }\r
+//                maxLength++;\r
+//            }\r
+//\r
+//            // if we got to the end of the text use the entire row,\r
+//            // also if space is next character (in the next row) we can cut the line\r
+//            if(i == textLength || text[i] == ' ' || text[i] == '\n') {\r
+//                spaceIndex=i;\r
+//            }\r
+//\r
+//            // if we found space in the limit width of the row (searched only from minCharactersInRow)\r
+//            if(spaceIndex!=-1){\r
+//                // make sure that if we have a newline character before the end of the line we should\r
+//                // break there instead\r
+//                int newLine = indexOf(text, '\n', from, spaceIndex - from);\r
+//                if(newLine > -1 && newLine < spaceIndex) {\r
+//                    spaceIndex = newLine;\r
+//                }\r
+//\r
+//                rowText = new String(text, from, spaceIndex - from);\r
+//                from=spaceIndex+1;\r
+//\r
+//            } // if there is no space from minCharactersInRow to limit need to search backwards\r
+//            else{\r
+//                for( i=to; spaceIndex==-1 && i>=from ; i--){\r
+//                    char chr = text[i];\r
+//                    if(chr == ' ' || chr == '\n' || chr == '\t') {\r
+//                        spaceIndex=i;\r
+//                        \r
+//                        // don't forget to search for line breaks in the\r
+//                        // remaining part. otherwise we overlook possible\r
+//                        // line breaks!\r
+//                        int newLine = indexOf(text, '\n', from, i - from);\r
+//                        if(newLine > -1 && newLine < spaceIndex) {\r
+//                           spaceIndex = newLine;\r
+//                        }\r
+//                        rowText = new String(text, from, spaceIndex - from);\r
+//                        from=spaceIndex+1;\r
+//                    }\r
+//\r
+//                }\r
+//                if(spaceIndex==-1) {\r
+//                    // from = to + 1;\r
+//                    if(maxLength <= 0) {\r
+//                        maxLength = 1;\r
+//                    }\r
+//                    spaceIndex = maxLength;\r
+//                    rowText = new String(text, from, spaceIndex - from);\r
+//                    from = spaceIndex;\r
+//                }\r
+//            }\r
+//\r
+//            rowStrings.addElement(rowText); \r
+//            //adding minCharactersInRow doesn't work if what is left is less\r
+//            //then minCharactersInRow\r
+//            to=from;//+minCharactersInRow;\r
+//            rowIndex++;\r
+//        }\r
+//    }\r
+//\r
+//    /**\r
+//     * Gets the num of pixels gap between the rows\r
+//     * \r
+//     * @return the gap between rows in pixels\r
+//     */\r
+//    public int getRowsGap() {\r
+//        return rowsGap;\r
+//    }\r
+//\r
+//    /**\r
+//     * The gap in pixels between rows\r
+//     * \r
+//     * @param rowsGap\r
+//     *            num of pixels to gap between rows\r
+//     */\r
+//    public void setRowsGap(int rowsGap) {\r
+//        this.rowsGap = rowsGap;\r
+//    }\r
+//\r
+//    //        private long lastTime = System.currentTimeMillis();\r
+//    //        private boolean showCursor = true;\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    public void paint(Graphics g) {\r
+//\r
+//        //            if (System.currentTimeMillis() - lastTime < 500) {\r
+//        //                return;\r
+//        //            }\r
+//        //            lastTime = System.currentTimeMillis();\r
+//\r
+//        int lines = getLines();\r
+//        int oX = g.getClipX();\r
+//        int oY = g.getClipY();\r
+//        int oWidth = g.getClipWidth();\r
+//        int oHeight = g.getClipHeight();\r
+//        Font f = getStyle().getFont();\r
+//        int fontHeight = f.getHeight();\r
+//        for (int i = 0; i < lines; i++) {\r
+//            int x = getX() + getStyle().getPadding(Component.LEFT);\r
+//            int y = getY() + getStyle().getPadding(Component.TOP) + (getRowsGap() + fontHeight) * i;\r
+//            if (Rectangle.intersects(x, y, getWidth(), fontHeight, oX, oY, oWidth, oHeight)) {\r
+//                String rowText = (String) getTextAt(i);\r
+//                //display ******** if it is a password field\r
+//                String displayText = "";\r
+//                if ((getConstraint() & TextArea.PASSWORD) != 0) {\r
+//                    for (int j = 0; j < rowText.length(); j++) {\r
+//                        displayText += "*";\r
+//                    }\r
+//                } else {\r
+//                    displayText = rowText;\r
+//                }\r
+//                g.setColor(getStyle().getFgColor());\r
+//                g.drawString(displayText, x, y);\r
+//\r
+//                // TODO remove\r
+//                //System.out.println("line: "+ i);\r
+//\r
+//                // Cursor\r
+//                if (cursorRow == i) {\r
+//                    int cursorX = x + f.charsWidth(displayText.toCharArray(), 0, cursorColumn);\r
+//                    //if (showCursor) {\r
+//                    g.setColor(0xFF0000);\r
+//                    //                        } else {\r
+//                    //                            g.setColor(getStyle().getBgColor());\r
+//                    //                        }\r
+//                    //                        showCursor = !showCursor;\r
+//                    g.drawLine(cursorX, y, cursorX, y + fontHeight);\r
+//                }\r
+//            }\r
+//        }\r
+//    }\r
+//\r
+//    /**\r
+//     * @inheritDoc\r
+//     */\r
+//    protected Dimension calcPreferredSize() {\r
+//        int prefW = 0;\r
+//        int prefH = 0;\r
+//        Font f = Font.getDefaultFont();\r
+//\r
+//        //if this is a text field the preferred size should be the text width\r
+//        if (getRows() == 1) {\r
+//            prefW = f.stringWidth(getText());\r
+//        } else {\r
+//            prefW = f.stringWidth("W") * getColumns();\r
+//        }\r
+//        int rows = getRows();\r
+//        prefH = (f.getHeight() + 2) * rows;\r
+//        int columns = getColumns();\r
+//        String str = "";\r
+//        for (int iter = 0; iter < columns; iter++) {\r
+//            str += 'W';\r
+//        }\r
+//        prefW = Math.max(prefW, f.stringWidth(str));\r
+//        prefH = Math.max(prefH, rows * f.getHeight());\r
+//\r
+//        // TODO Remove me\r
+//        //            System.out.println("[DEBUG] EditForm.calcPreferredSize(): rows= " + rows + " columns=" + columns);\r
+//        //            System.out.println("[DEBUG] EditForm.calcPreferredSize(): prefW= " + prefW + " prefH=" + prefH);\r
+//        //return new Dimension(180,180);\r
+//        return new Dimension(prefW + getStyle().getPadding(Component.RIGHT) + getStyle().getPadding(Component.LEFT), prefH\r
+//                + getStyle().getPadding(Component.TOP) + getStyle().getPadding(Component.BOTTOM));\r
+//    }\r
+//\r
+////    /**\r
+////     * Add an action listener which is invoked when the text area was modified\r
+////     * not during modification. A text <b>field</b> might never fire an action\r
+////     * event if it is edited in place and the user never leaves the text field!\r
+////     * \r
+////     * @param a\r
+////     *            actionListener\r
+////     */\r
+////    public void addActionListener(ActionListener a) {\r
+////        if (actionListeners == null) {\r
+////            actionListeners = new Vector();\r
+////        }\r
+////        if (!actionListeners.contains(a)) {\r
+////            actionListeners.addElement(a);\r
+////        }\r
+////    }\r
+////\r
+////    /**\r
+////     * Removes an action listener\r
+////     * \r
+////     * @param a\r
+////     *            actionListener\r
+////     */\r
+////    public void removeActionListener(ActionListener a) {\r
+////        if (actionListeners == null) {\r
+////            actionListeners = new Vector();\r
+////        }\r
+////        actionListeners.removeElement(a);\r
+////    }\r
+////\r
+////    /**\r
+////     * Notifies listeners of a change to the text area\r
+////     */\r
+////    void fireActionEvent() {\r
+////        if (actionListeners != null) {\r
+////            ActionEvent evt = new ActionEvent(this);\r
+////            for (int iter = 0; iter < actionListeners.size(); iter++) {\r
+////                ActionListener a = (ActionListener) actionListeners.elementAt(iter);\r
+////                a.actionPerformed(evt);\r
+////            }\r
+////        }\r
+////    }\r
+////\r
+////    /**\r
+////     * @inheritDoc\r
+////     */\r
+////    void onEditComplete(String text) {\r
+////        setText(text);\r
+////    }\r
+//\r
+//    /**\r
+//     * Sets the default limit for the native text box size\r
+//     * \r
+//     * @param value\r
+//     *            default value for the size of the native text box\r
+//     */\r
+//    public static void setDefaultMaxSize(int value) {\r
+//        defaultMaxSize = value;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates that the text area should "grow" in height based on the content\r
+//     * beyond the limits indicate by the rows variable\r
+//     * \r
+//     * @return true if the text component should grow and false otherwise\r
+//     */\r
+//    public boolean isGrowByContent() {\r
+//        return growByContent;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates that the text area should "grow" in height based on the content\r
+//     * beyond the limits indicate by the rows variable\r
+//     * \r
+//     * @param growByContent\r
+//     *            true if the text component should grow and false otherwise\r
+//     */\r
+//    public void setGrowByContent(boolean growByContent) {\r
+//        this.growByContent = growByContent;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates whether a high value for default maxSize will be reduced to a\r
+//     * lower value if the underlying platform throws an exception.\r
+//     */\r
+//    public static void setAutoDegradeMaxSize(boolean value) {\r
+//        autoDegradeMaxSize = value;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates whether a high value for default maxSize will be reduced to a\r
+//     * lower value if the underlying platform throws an exception.\r
+//     */\r
+//    public static boolean isAutoDegradeMaxSize() {\r
+//        return autoDegradeMaxSize;\r
+//    }\r
+//    \r
+//    /**\r
+//     * Unsupported characters is a string that contains characters that cause issues \r
+//     * when rendering on some problematic fonts. The rendering engine can thus remove them\r
+//     * when drawing.\r
+//     * \r
+//     * @return unsupported characters string\r
+//     */\r
+//    public String getUnsupportedChars() {\r
+//        return unsupportedChars;\r
+//    }\r
+//\r
+//    /**\r
+//     * Unsupported characters is a string that contains characters that cause issues \r
+//     * when rendering on some problematic fonts. The rendering engine can thus remove them\r
+//     * when drawing.\r
+//     * \r
+//     * @param unsupportedChars the unsupported character string\r
+//     */\r
+//    public void setUnsupportedChars(String unsupportedChars) {\r
+//        this.unsupportedChars = unsupportedChars;\r
+//    }\r
+//    \r
+//    /**\r
+//     * Indicates the number of lines to scroll with every scroll operation\r
+//     * \r
+//     * @return number bigger or equal to 1\r
+//     */\r
+//    public int getLinesToScroll() {\r
+//        return linesToScroll;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates the number of lines to scroll with every scroll operation\r
+//     * \r
+//     * @param linesToScroll number bigger or equal to 1\r
+//     */\r
+//    public void setLinesToScroll(int linesToScroll) {\r
+//        if (linesToScroll < 1) {\r
+//            throw new IllegalArgumentException("lines to scroll has to be >= 1");\r
+//        }\r
+//        this.linesToScroll = linesToScroll;\r
+//    }\r
+//\r
+//    /**\r
+//     * Indicates the widest character in the alphabet, this is useful for detecting\r
+//     * linebreaks internally. In CJK languages the widest char is different than W\r
+//     * hence this functionality is exposed to developers.\r
+//     * \r
+//     * @param widestC the widest character\r
+//     */\r
+//    public static void setWidestChar(char widestC) {\r
+//        widestChar = widestC;\r
+//    }\r
+//\r
+//\r
+//    /**\r
+//     * Indicates the widest character in the alphabet, this is useful for detecting\r
+//     * linebreaks internally. In CJK languages the widest char is different than W\r
+//     * hence this functionality is exposed to developers.\r
+//     * \r
+//     * @return the widest character\r
+//     */\r
+//    public static char getWidestChar() {\r
+//        return widestChar;\r
+//    }\r
+//}\r
@@ -1,4 +1,4 @@
-package com.sun.lwuit;\r
+package org.thenesis.lwuimb;\r
 \r
 public interface EventMapper {\r
        /**\r
@@ -69,5 +69,5 @@ public interface EventMapper {
 \r
     public int getSoftRightKeyCode();\r
 \r
-    public int getSoftRight2KeyCode();\r
+    public int getBackspaceKeyCode();\r
 }\r
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA\r
  * 02110-1301 USA \r
  */\r
-package com.sun.lwuit;\r
+package org.thenesis.lwuimb;\r
 \r
 \r
-import org.thenesis.lwuit.configuration.Configuration;\r
+import org.thenesis.lwuimb.configuration.Configuration;\r
 import org.thenesis.microbackend.ui.KeyConstants;\r
 \r
+import com.sun.lwuit.Display;\r
+\r
 \r
 public class GenericEventMapper implements EventMapper {\r
     \r
@@ -127,8 +129,8 @@ public class GenericEventMapper implements EventMapper {
         return KEY_SOFT_RIGHT;\r
     }\r
 \r
-    public int getSoftRight2KeyCode() {\r
-        return KEY_SOFT_RIGHT2;\r
+    public int getBackspaceKeyCode() {\r
+        return KEY_BACKSPACE;\r
     }\r
        \r
 \r
@@ -157,9 +159,9 @@ public class GenericEventMapper implements EventMapper {
 \r
        public int getSystemKey(int keyCode) {\r
                if (keyCode == KEY_BACKSPACE)\r
-                       return VirtualImplementation.SYSTEM_KEY_BACKSPACE;\r
+                       return LWUIMBImplementation.SYSTEM_KEY_BACKSPACE;\r
                else if (keyCode == KEY_DELETE)\r
-                       return VirtualImplementation.SYSTEM_KEY_DELETE;\r
+                       return LWUIMBImplementation.SYSTEM_KEY_DELETE;\r
                else\r
                        return 0;\r
            \r
diff --git a/components/implementation/java/org/thenesis/lwuimb/LWUIMBImplementation.java b/components/implementation/java/org/thenesis/lwuimb/LWUIMBImplementation.java
new file mode 100644 (file)
index 0000000..4ca60b2
--- /dev/null
@@ -0,0 +1,715 @@
+package org.thenesis.lwuimb;\r
+\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+\r
+import org.thenesis.lwuimb.configuration.Configuration;\r
+import org.thenesis.lwuimb.configuration.ConfigurationProperties;\r
+import org.thenesis.microbackend.ui.BackendEventListener;\r
+import org.thenesis.microbackend.ui.graphics.VirtualFont;\r
+import org.thenesis.microbackend.ui.graphics.VirtualGraphics;\r
+import org.thenesis.microbackend.ui.graphics.VirtualImage;\r
+import org.thenesis.microbackend.ui.graphics.VirtualToolkit;\r
+\r
+import com.sun.lwuit.Component;\r
+import com.sun.lwuit.Display;\r
+import com.sun.lwuit.Form;\r
+import com.sun.lwuit.TextArea;\r
+import com.sun.lwuit.impl.LWUITImplementation;\r
+import com.sun.lwuit.util.Log;\r
+\r
+public class LWUIMBImplementation extends LWUITImplementation {\r
+\r
+    public static final int SYSTEM_KEY_BACKSPACE = -2;\r
+    public static final int SYSTEM_KEY_DELETE = -3;\r
+\r
+    /**\r
+     * On some devices getKeyCode returns numeric values for game actions, this\r
+     * breaks the code since we filter these values. We pick unused negative\r
+     * values for game keys and assign them to game keys for getKeyCode.\r
+     */\r
+    private static int[] portableKeyCodes;\r
+    private static int[] portableKeyCodeValues;\r
+    /**\r
+     * This member holds the left soft key value\r
+     */\r
+    static int[] leftSK = new int[] { -6 };\r
+    /**\r
+     * This member holds the right soft key value\r
+     */\r
+    static int[] rightSK = new int[] { -7 };\r
+    /**\r
+     * This member holds the back command key value\r
+     */\r
+    static int backSK = -11;\r
+    /**\r
+     * This member holds the clear command key value\r
+     */\r
+    static int clearSK = -8;\r
+    static int backspaceSK = -8;\r
+\r
+    private int alpha = 255;\r
+    private int[] rgbArr;\r
+    private boolean flushGraphicsBug;\r
+\r
+    private VirtualToolkit virtualToolkit;\r
+    private static VirtualFont defaultFont;\r
+    private EventMapper eventMapper = new GenericEventMapper();\r
+    private VirtualBackendEventListener backendEventListener = new VirtualBackendEventListener();\r
+    private char lastKeyChar;\r
+    private int lastKeyPressed;\r
+    \r
+    private EditForm editForm;\r
+\r
+    /**\r
+     * This flag indicates if the drawRGB method is able to draw negative x and\r
+     * y In drawRGB method, some devices such as BlackBerry throw exceptions if\r
+     * you try to give negative values to drawRGB method.\r
+     */\r
+    private static boolean drawNegativeOffsetsInRGB = true;\r
+\r
+    @Override\r
+    public int charWidth(Object nativeFont, char ch) {\r
+        return font(nativeFont).charWidth(ch);\r
+    }\r
+\r
+    @Override\r
+    public int charsWidth(Object nativeFont, char[] ch, int offset, int length) {\r
+        return font(nativeFont).charsWidth(ch, offset, length);\r
+    }\r
+\r
+    @Override\r
+    public void clipRect(Object graphics, int x, int y, int width, int height) {\r
+        ((VirtualGraphics) graphics).clipRect(x, y, width, height);\r
+    }\r
+\r
+    @Override\r
+    public Object createFont(int face, int style, int size) {\r
+        return virtualToolkit.createFont(face, style, size);\r
+    }\r
+\r
+    @Override\r
+    public Object createImage(String path) throws IOException {\r
+        InputStream is = getClass().getResourceAsStream(path);\r
+        return createImage(is);\r
+    }\r
+\r
+    @Override\r
+    public Object createImage(InputStream is) throws IOException {\r
+        return virtualToolkit.createImage(is);\r
+    }\r
+\r
+    @Override\r
+    public Object createImage(byte[] bytes, int offset, int len) {\r
+        return virtualToolkit.createImage(bytes, offset, len);\r
+    }\r
+    \r
+    @Override\r
+    public Object createImage(int[] rgb, int width, int height) {\r
+        return virtualToolkit.createRGBImage(rgb, width, height, true);\r
+    }\r
+\r
+    @Override\r
+    public Object createMutableImage(int width, int height, int fillColor) {\r
+        VirtualImage i = virtualToolkit.createImage(width, height);\r
+        if (fillColor != 0xffffffff) {\r
+            VirtualGraphics g = i.getGraphics();\r
+            g.setColor(fillColor);\r
+            g.fillRect(0, 0, width, height);\r
+        }\r
+        return i;\r
+    }\r
+\r
+    @Override\r
+    public void drawArc(Object graphics, int x, int y, int width, int height, int startAngle, int arcAngle) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawArc(x, y, width, height, startAngle, arcAngle);\r
+    }\r
+\r
+    @Override\r
+    public void drawImage(Object graphics, Object img, int x, int y) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawImage((VirtualImage) img, x, y, VirtualGraphics.TOP | VirtualGraphics.LEFT);\r
+    }\r
+\r
+    @Override\r
+    public void drawLine(Object graphics, int x1, int y1, int x2, int y2) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawLine(x1, y1, x2, y2);\r
+    }\r
+\r
+    @Override\r
+    public void drawRGB(Object graphics, int[] rgbData, int offset, int x, int y, int w, int h, boolean processAlpha) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        int rgbX = x;\r
+        int rgbY = y;\r
+\r
+        //if the x or y are positive simply redirect the call to midp Graphics\r
+        if (rgbX >= 0 && rgbY >= 0) {\r
+            nativeGraphics.drawRGB(rgbData, offset, w, rgbX, rgbY, w, h, processAlpha);\r
+            return;\r
+        }\r
+\r
+        //first time try to draw with negative indexes\r
+        if (drawNegativeOffsetsInRGB) {\r
+            try {\r
+                nativeGraphics.drawRGB(rgbData, offset, w, rgbX, rgbY, w, h, processAlpha);\r
+                return;\r
+            } catch (RuntimeException e) {\r
+                //if you failed it might be because you tried to paint with negative\r
+                //indexes\r
+                drawNegativeOffsetsInRGB = false;\r
+            }\r
+        }\r
+\r
+        //if the translate causes us to paint out of the bounds\r
+        //we will paint only the relevant rows row by row to avoid some devices bugs\r
+        //such as BB that fails to paint if the coordinates are negative.\r
+        if (rgbX < 0 && rgbX + w > 0) {\r
+            if (w < rgbData.length) {\r
+                for (int i = 1; i <= rgbData.length / w; i++) {\r
+                    offset = -rgbX + (w * (i - 1));\r
+                    rgbY++;\r
+                    if (rgbY >= 0) {\r
+                        nativeGraphics.drawRGB(rgbData, offset, (w + rgbX), 0, rgbY, w + rgbX, 1, processAlpha);\r
+                    }\r
+                }\r
+            }\r
+        }\r
+    }\r
+\r
+    @Override\r
+    public void drawRect(Object graphics, int x, int y, int width, int height) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawRect(x, y, width, height);\r
+    }\r
+\r
+    @Override\r
+    public void drawRoundRect(Object graphics, int x, int y, int width, int height, int arcWidth, int arcHeight) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);\r
+    }\r
+\r
+    @Override\r
+    public void drawString(Object graphics, String str, int x, int y) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.drawString(str, x, y, VirtualGraphics.TOP | VirtualGraphics.LEFT);\r
+    }\r
+\r
+    @Override\r
+    public void editString(Component cmp, int maxSize, int constraint, String text) {\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] VirtualImplementation.editString()");\r
+\r
+        EditForm editForm = new EditForm(this, Display.getInstance().getCurrent(), (TextArea) cmp);\r
+        editForm.show();\r
+    }\r
+\r
+    @Override\r
+    public void fillArc(Object graphics, int x, int y, int width, int height, int startAngle, int arcAngle) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.fillArc(x, y, width, height, startAngle, arcAngle);\r
+    }\r
+\r
+    @Override\r
+    public void fillRect(Object graphics, int x, int y, int w, int h) {\r
+\r
+        if (isAlphaGlobal()) {\r
+            VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+            nativeGraphics.fillRect(x, y, w, h);\r
+            return;\r
+        }\r
+\r
+        if (alpha == 0) {\r
+            return;\r
+        }\r
+\r
+        if (alpha == 0xff) {\r
+            VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+            nativeGraphics.fillRect(x, y, w, h);\r
+        } else {\r
+            int transparencyLevel = alpha << 24;\r
+            int color = (getColor(graphics) & 0x00FFFFFF);\r
+            color = (color | transparencyLevel);\r
+\r
+            if (rgbArr == null || rgbArr.length < w) {\r
+                rgbArr = new int[w];\r
+            }\r
+            for (int i = 0; i < w; i++) {\r
+                rgbArr[i] = color;\r
+            }\r
+\r
+            int rgbX = x;\r
+            int rgbY = y;\r
+\r
+            if (rgbX < 0 && rgbX + w > 0) {\r
+                w = rgbX + w;\r
+                rgbX = 0;\r
+            }\r
+\r
+            if (w < 0) {\r
+                return;\r
+            }\r
+\r
+            for (int i = 0; i < h; i++) {\r
+                if (rgbX >= 0 && rgbY + i >= 0) {\r
+                    drawRGB(graphics, rgbArr, 0, rgbX, rgbY + i, w, 1, true);\r
+                }\r
+            }\r
+\r
+        }\r
+\r
+    }\r
+\r
+    @Override\r
+    public void fillRoundRect(Object graphics, int x, int y, int width, int height, int arcWidth, int arcHeight) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight);\r
+    }\r
+\r
+    @Override\r
+    public void flushGraphics(int x, int y, int width, int height) {\r
+\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] VirtualImplementation.flushGraphics(x, y, w, h)");\r
+\r
+        // disable flush graphics bug when media is playing to prevent the double buffer\r
+        // from clearing the media and producing flickering\r
+        Form current = getCurrentForm();\r
+        if (!flushGraphicsBug || (current != null && current.hasMedia())) {\r
+            virtualToolkit.flushGraphics(x, y, width, height);\r
+        } else {\r
+            flushGraphics();\r
+        }\r
+\r
+    }\r
+\r
+    @Override\r
+    public void flushGraphics() {\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] VirtualImplementation.flushGraphics()");\r
+        virtualToolkit.flushGraphics(0, 0, getDisplayWidth(), getDisplayHeight());\r
+    }\r
+\r
+    @Override\r
+    public int getAlpha(Object graphics) {\r
+        return alpha;\r
+    }\r
+\r
+    //    /**\r
+    //     * This member holds the left soft key value\r
+    //     */\r
+    //    static int[] leftSK = new int[] {-6};\r
+    //    /**\r
+    //     * This member holds the right soft key value\r
+    //     */\r
+    //    static int[] rightSK = new int[]{-7};\r
+    //    /**\r
+    //     * This member holds the back command key value\r
+    //     */\r
+    //    static int backSK = -11;\r
+    //    /**\r
+    //     * This member holds the clear command key value\r
+    //     */\r
+    //    static int clearSK = -8;\r
+    //    static int backspaceSK = -8;\r
+\r
+    private void setSoftKeyCodes() {\r
+        // Initialy set known key codes\r
+        leftSK[0] = eventMapper.getSoftLeftKeyCode();\r
+        rightSK[0] = eventMapper.getSoftRightKeyCode();\r
+        backspaceSK = eventMapper.getBackspaceKeyCode();\r
+        clearSK = eventMapper.getClearKeyCode();\r
+        backSK = eventMapper.getBackKeyCode();\r
+\r
+        try {\r
+            // if the back key is assigned to a game action by mistake then\r
+            // workaround it implicitly\r
+            int game = getGameAction(backSK);\r
+            if (game == Display.GAME_UP || game == Display.GAME_DOWN || game == Display.GAME_RIGHT || game == Display.GAME_LEFT\r
+                    || game == Display.GAME_FIRE) {\r
+                backSK = -50000;\r
+            }\r
+        } catch (Exception ok) {\r
+        }\r
+\r
+        try {\r
+            // if the clear key is assigned to a game action by mistake then\r
+            // workaround it implicitly\r
+            int game = getGameAction(clearSK);\r
+            if (game == Display.GAME_UP || game == Display.GAME_DOWN || game == Display.GAME_RIGHT || game == Display.GAME_LEFT\r
+                    || game == Display.GAME_FIRE) {\r
+                clearSK = -50000;\r
+            }\r
+            game = getGameAction(backspaceSK);\r
+            if (game == Display.GAME_UP || game == Display.GAME_DOWN || game == Display.GAME_RIGHT || game == Display.GAME_LEFT\r
+                    || game == Display.GAME_FIRE) {\r
+                backspaceSK = -50000;\r
+            }\r
+        } catch (Exception ok) {\r
+        }\r
+\r
+    }\r
+\r
+    @Override\r
+    public int getBackKeyCode() {\r
+        return backSK;\r
+    }\r
+\r
+    @Override\r
+    public int getBackspaceKeyCode() {\r
+        return backspaceSK;\r
+    }\r
+\r
+    @Override\r
+    public int getClearKeyCode() {\r
+        return clearSK;\r
+    }\r
+\r
+    @Override\r
+    public int getClipHeight(Object graphics) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        return nativeGraphics.getClipHeight();\r
+    }\r
+\r
+    @Override\r
+    public int getClipWidth(Object graphics) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        return nativeGraphics.getClipWidth();\r
+    }\r
+\r
+    @Override\r
+    public int getClipX(Object graphics) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        return nativeGraphics.getClipX();\r
+    }\r
+\r
+    @Override\r
+    public int getClipY(Object graphics) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        return nativeGraphics.getClipY();\r
+    }\r
+\r
+    @Override\r
+    public int getColor(Object graphics) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        return nativeGraphics.getColor();\r
+    }\r
+\r
+    @Override\r
+    public Object getDefaultFont() {\r
+        return virtualToolkit.getDefaultFont();\r
+    }\r
+    \r
+    @Override\r
+    public int getDisplayWidth() {\r
+        return virtualToolkit.getRootSurface().getWidth() - 1;\r
+    }\r
+\r
+    @Override\r
+    public int getDisplayHeight() {\r
+        return virtualToolkit.getRootSurface().getHeight() - 1;\r
+    }\r
+\r
+    @Override\r
+    public int getGameAction(int keyCode) {\r
+        try {\r
+            // prevent game actions from being returned by numeric keypad thus screwing up\r
+            // keypad based navigation and text input\r
+            if (keyCode >= '0' && keyCode <= '9') {\r
+                return 0;\r
+            }\r
+            if (portableKeyCodes != null) {\r
+                for (int iter = 0; iter < portableKeyCodeValues.length; iter++) {\r
+                    if (portableKeyCodeValues[iter] == keyCode) {\r
+                        return portableKeyCodes[iter];\r
+                    }\r
+                }\r
+            }\r
+\r
+            return eventMapper.getGameAction(keyCode);\r
+        } catch (IllegalArgumentException err) {\r
+            // this is a stupid MIDP requirement some implementations throw this\r
+            // exception for some keys\r
+            return 0;\r
+        }\r
+    }\r
+\r
+    @Override\r
+    public int getHeight(Object nativeFont) {\r
+        return font(nativeFont).getHeight();\r
+    }\r
+\r
+    @Override\r
+    public int getImageHeight(Object i) {\r
+        return ((VirtualImage) i).getHeight();\r
+    }\r
+\r
+    @Override\r
+    public int getImageWidth(Object i) {\r
+        return ((VirtualImage) i).getWidth();\r
+    }\r
+\r
+    @Override\r
+    public int getKeyCode(int gameAction) {\r
+        if (portableKeyCodes == null) {\r
+            portableKeyCodes = new int[] { Display.GAME_DOWN, Display.GAME_LEFT, Display.GAME_RIGHT, Display.GAME_UP, Display.GAME_FIRE };\r
+            portableKeyCodeValues = new int[5];\r
+            int currentValue = -500;\r
+            int offset = 0;\r
+            while (offset < portableKeyCodeValues.length) {\r
+                currentValue--;\r
+                try {\r
+                    if (eventMapper.getGameAction(currentValue) != 0) {\r
+                        continue;\r
+                    }\r
+                } catch (IllegalArgumentException ignor) {\r
+                    // this is good, the game key is unassigned\r
+                }\r
+                portableKeyCodeValues[offset] = currentValue;\r
+                offset++;\r
+            }\r
+        }\r
+        for (int iter = 0; iter < portableKeyCodes.length; iter++) {\r
+            if (portableKeyCodes[iter] == gameAction) {\r
+                return portableKeyCodeValues[iter];\r
+            }\r
+        }\r
+        return 0;\r
+    }\r
+\r
+    @Override\r
+    public Object getNativeGraphics() {\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] VirtualImplementation.getGraphics()");\r
+        return virtualToolkit.getRootGraphics();\r
+    }\r
+\r
+    @Override\r
+    public Object getNativeGraphics(Object image) {\r
+        return ((VirtualImage) image).getGraphics();\r
+    }\r
+\r
+    @Override\r
+    public void getRGB(Object nativeImage, int[] arr, int offset, int x, int y, int width, int height) {\r
+        ((VirtualImage) nativeImage).getRGB(arr, offset, width, x, y, width, height);\r
+    }\r
+\r
+    @Override\r
+    public int[] getSoftkeyCode(int index) {\r
+        if (index == 0) {\r
+            return leftSK;\r
+        }\r
+        if (index == 1) {\r
+            return rightSK;\r
+        }\r
+        return null;\r
+    }\r
+\r
+    @Override\r
+    public int getSoftkeyCount() {\r
+        return 2;\r
+    }\r
+\r
+    @Override\r
+    public void init(Object m) {\r
+        //Copy LWUIT config in the MicroBackend config\r
+        ConfigurationProperties properties = Configuration.getAllProperties();\r
+        org.thenesis.microbackend.ui.Configuration microBackendConfig = new org.thenesis.microbackend.ui.Configuration();\r
+        for (int i = 0; i < properties.size(); i++) {\r
+            microBackendConfig.addParameter(properties.getKeyAt(i), properties.getValueAt(i));\r
+        }\r
+       \r
+        virtualToolkit = VirtualToolkit.createToolkit(microBackendConfig, backendEventListener);\r
+        virtualToolkit.initialize(m);\r
+\r
+        setSoftKeyCodes();\r
+    }\r
+\r
+    @Override\r
+    public boolean isTouchDevice() {\r
+        // TODO \r
+        return false;\r
+    }\r
+\r
+    @Override\r
+    public Object scale(Object nativeImage, int width, int height) {\r
+        VirtualImage image = (VirtualImage) nativeImage;\r
+        int srcWidth = image.getWidth();\r
+        int srcHeight = image.getHeight();\r
+\r
+        // no need to scale\r
+        if (srcWidth == width && srcHeight == height) {\r
+            return image;\r
+        }\r
+\r
+        int[] currentArray = new int[srcWidth];\r
+        int[] destinationArray = new int[width * height];\r
+        scaleArray(image, srcWidth, srcHeight, height, width, currentArray, destinationArray);\r
+\r
+        return createImage(destinationArray, width, height);\r
+    }\r
+\r
+    private void scaleArray(VirtualImage currentImage, int srcWidth, int srcHeight, int height, int width, int[] currentArray,\r
+            int[] destinationArray) {\r
+        // Horizontal Resize\r
+        int yRatio = (srcHeight << 16) / height;\r
+        int xRatio = (srcWidth << 16) / width;\r
+        int xPos = xRatio / 2;\r
+        int yPos = yRatio / 2;\r
+\r
+        // if there is more than 16bit color there is no point in using mutable\r
+        // images since they won't save any memory\r
+        for (int y = 0; y < height; y++) {\r
+            int srcY = yPos >> 16;\r
+            getRGB(currentImage, currentArray, 0, 0, srcY, srcWidth, 1);\r
+            for (int x = 0; x < width; x++) {\r
+                int srcX = xPos >> 16;\r
+                int destPixel = x + y * width;\r
+                if ((destPixel >= 0 && destPixel < destinationArray.length) && (srcX < currentArray.length)) {\r
+                    destinationArray[destPixel] = currentArray[srcX];\r
+                }\r
+                xPos += xRatio;\r
+            }\r
+            yPos += yRatio;\r
+            xPos = xRatio / 2;\r
+        }\r
+    }\r
+\r
+    @Override\r
+    public void setAlpha(Object graphics, int alpha) {\r
+        this.alpha = alpha;\r
+    }\r
+\r
+    @Override\r
+    public void setClip(Object graphics, int x, int y, int width, int height) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.setClip(x, y, width, height);\r
+    }\r
+\r
+    @Override\r
+    public void setColor(Object graphics, int RGB) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.setColor(RGB);\r
+    }\r
+\r
+    @Override\r
+    public void setNativeFont(Object graphics, Object font) {\r
+        VirtualGraphics nativeGraphics = (VirtualGraphics) graphics;\r
+        nativeGraphics.setFont(font(font));\r
+    }\r
+\r
+    @Override\r
+    public int stringWidth(Object nativeFont, String str) {\r
+        return font(nativeFont).stringWidth(str);\r
+    }\r
+\r
+    @Override\r
+    public int getFace(Object nativeFont) {\r
+        return font(nativeFont).getFace();\r
+    }\r
+    \r
+    @Override\r
+    public int getSize(Object nativeFont) {\r
+        return font(nativeFont).getSize();\r
+    }\r
+    \r
+    @Override\r
+    public int getStyle(Object nativeFont) {\r
+        return font(nativeFont).getStyle();\r
+    }\r
+    \r
+    /**\r
+     * @inheritDoc\r
+     */\r
+    public void saveTextEditingState() {\r
+        if (Log.TRACE_ENABLED)\r
+            System.out.println("[DEBUG] LWUIMBImplementation.saveTextEditingState()");\r
+        \r
+        // FIXME ?\r
+//        String text = editForm.getString();\r
+//        Display.getInstance().onEditingComplete(currentTextComponent, text);\r
+//        currentTextBox = null;\r
+//        waitForEdit.setDone(true);\r
+    }\r
+\r
+    private VirtualFont font(Object f) {\r
+        if (f == null) {\r
+            return (VirtualFont) getDefaultFont();\r
+        }\r
+        return (VirtualFont) f;\r
+    }\r
+\r
+    EventMapper getEventMapper() {\r
+        return eventMapper;\r
+    }\r
+\r
+    char getLastKeyChar() {\r
+        return lastKeyChar;\r
+    }\r
+\r
+    /**\r
+     * Listens events coming from the UIBackend and send it to the event queue\r
+     */\r
+    private class VirtualBackendEventListener implements BackendEventListener {\r
+\r
+        private boolean dragEnabled = false;\r
+\r
+        public VirtualBackendEventListener() {\r
+        }\r
+\r
+        public void keyPressed(int keyCode, char c, int modifiers) {\r
+\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.keyPressed(): keyCode=" + keyCode + " c=" + c);\r
+\r
+            LWUIMBImplementation.this.keyPressed(keyCode);\r
+\r
+            lastKeyPressed = keyCode;\r
+            lastKeyChar = c;\r
+        }\r
+\r
+        public void keyReleased(int keyCode, char c, int modifiers) {\r
+\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.keyReleased(): keyCode=" + keyCode + " c=" + c);\r
+\r
+            LWUIMBImplementation.this.keyReleased(keyCode);\r
+        }\r
+\r
+        public void mouseMoved(int x, int y, int modifiers) {\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.mouseMoved(): x=" + x + " y=" + y + " drag enabled ? "\r
+                        + dragEnabled);\r
+\r
+            if (dragEnabled) {\r
+                LWUIMBImplementation.this.pointerDragged(x, y);\r
+            }\r
+\r
+        }\r
+\r
+        public void mousePressed(int x, int y, int modifiers) {\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.mousePressed(): x=" + x + " y=" + y);\r
+\r
+            dragEnabled = true;\r
+            LWUIMBImplementation.this.pointerPressed(x, y);\r
+        }\r
+\r
+        public void mouseReleased(int x, int y, int modifiers) {\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.mouseReleased(): x=" + x + " y=" + y);\r
+\r
+            dragEnabled = false;\r
+            LWUIMBImplementation.this.pointerReleased(x, y);\r
+        }\r
+\r
+        public void windowClosed() {\r
+            if (Log.TRACE_ENABLED)\r
+                System.out.println("[DEBUG] VirtualBackendEventListener.windowClosed(): Window delete event received");\r
+\r
+        }\r
+\r
+    }\r
+\r
+}\r
@@ -1,57 +1,73 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-package com.sun.lwuit.events;\r
-\r
-/**\r
- * Event callback interface invoked when a {@link com.sun.lwuit.list.ListModel}\r
- * changes its state thus indicating to the view that it should refresh.\r
- * \r
- * @author Chen Fishbein\r
- */\r
-public interface DataChangedListener {\r
-    /**\r
-     * Type value for removed data in ListModel\r
-     */\r
-    public static int REMOVED = 0;\r
-    \r
-    /**\r
-     * Type value for added data in ListModel\r
-     */\r
-    public static int ADDED = 1;\r
-    \r
-    /**\r
-     * Type value for changed data in ListModel\r
-     */\r
-    public static int CHANGED = 2;\r
-    \r
-    /**\r
-     * Invoked when there was a change in the underlying model\r
-     * \r
-     * @param type the type data change; REMOVED, ADDED or CHANGED\r
-     * @param index item index in a list model\r
-     */\r
-    public void dataChanged(int type, int index);\r
-    \r
-}\r
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+package com.sun.lwuit.impl;
+
+import org.thenesis.lwuimb.LWUIMBImplementation;
+
+
+/**
+ * Generic class allowing 3rd parties to replace the underlying implementation in
+ * LWUIT seamlessly. The factory can be replaced by 3rd parties to install a new
+ * underlying implementation using elaborate logic. 
+ *
+ * @author Shai Almog
+ */
+public class ImplementationFactory {
+    private static ImplementationFactory instance = new ImplementationFactory();
+    
+    /**
+     * Allows third parties to replace the implementation factory
+     */
+    protected ImplementationFactory() {
+    }
+    
+    /**
+     * Returns the singleton instance of this class
+     * 
+     * @return instanceof Implementation factory
+     */
+    public static ImplementationFactory getInstance() {
+        return instance;
+    }
+    
+    /**
+     * Install a new implementation factory this method is invoked by implementors
+     * to replace a factory.
+     * 
+     * @param i implementation factory instance
+     */
+    public static void setInstance(ImplementationFactory i) {
+        instance = i;
+    }
+    
+    /**
+     * Factory method to create the implementation instance
+     * 
+     * @return a newly created implementation instance
+     */
+    public LWUITImplementation createImplementation() {
+        return new LWUIMBImplementation();
+    }
+}
diff --git a/core/java/Makefile b/core/java/Makefile
deleted file mode 100644 (file)
index 74090d7..0000000
+++ /dev/null
@@ -1,438 +0,0 @@
-#
-# Makefile created at Sat Sep  6 11:34:55 2008, by mmake
-#
-
-# Programs (with common options):
-SHELL          = /bin/sh
-CP             = cp
-RM              = rm -f
-MV              = mv -f
-SED            = sed
-ETAGS          = etags
-XARGS          = xargs
-CAT            = cat
-FIND            = find
-CPP            = cpp -C -P
-
-INSTALL         = install
-INSTALL_PROG    = $(INSTALL) -m $(MODE_PROGS)
-INSTALL_FILE    = $(INSTALL) -m $(MODE_FILES)
-INSTALL_DIR     = $(INSTALL) -m $(MODE_DIRS) -d
-
-# Install modes 
-MODE_PROGS      = 555
-MODE_FILES      = 444
-MODE_DIRS       = 2755
-
-# Build programs
-JAVAC           = jikes
-JAVADOC         = javadoc
-JAR             = jar
-
-# Build flags
-JAVAC_FLAGS     = 
-JAVADOC_FLAGS   = -version -author
-JAR_FLAGS       = cvf0
-JIKES_DEP_FLAG = +M
-
-# ------------------------------------------------------------------- #
-
-# Prefix for every install directory
-PREFIX         = 
-
-# Where to start installing the class files. Set this to an empty value
-#  if you dont want to install classes
-CLASS_DIR      = $(PREFIX)classes
-
-# The directory to install the jar file in. Set this to an empty value
-#  if you dont want to install a jar file
-JAR_DIR                = $(PREFIX)lib
-
-# The directory to install the app bundle in. Set this to an empty value
-#  if you dont want to install an app bundle
-BUNDLE_DIR      = $(PREFIX)lib
-
-
-# The directory to install html files generated by javadoc
-DOC_DIR         = $(PREFIX)doc/api-docs
-
-# The directory to install script files in
-SCRIPT_DIR     = $(PREFIX)bin
-
-# ------------------------------------------------------------------- #
-
-# The name of the jar file to install
-JAR_FILE        = 
-
-# 
-# The VERSION variable below should be set to a value 
-# that will be tested in the .xjava code and Info.plist. 
-# 
-VERSION                = CHANGE_ME
-
-# ------------------------------------------------------------------- #
-
-# The name of the OS X Application Bundle to install
-BUNDLE_FILE    = 
-
-# Folder containing App Bundle resources (Info.plist, *.icns, etc.)
-BUNDLE_RESOURCE_DIR = misc/macosx
-
-# Items to copy to the Resources folder of the bundle
-BUNDLE_RESOURCES = $(addsuffix .icns, $(basename $(APP_FILE)) Document)
-
-# Location of JavaApplicatonStub
-JAVA_STUB      = /System/Library/Frameworks/JavaVM.framework/Resources/MacOS/JavaApplicationStub
-
-# ------------------------------------------------------------------- #
-
-# Resource files:
-#  Extend the list to install other files of your choice
-RESOURCE_SRC   := *.properties *.gif *.au
-
-# Objects that should go into the jar file. (find syntax)
-JAR_OBJS       := \( -name '*.class' -o -name '*.gif' -o -name "*.au" \
-                      -o -name '*.properties' \)
-
-# Include the separate variables file if it exists
-MAKEFILE_VARS  = makefile.vars
-VARS   = $(wildcard $(MAKEFILE_VARS))
-ifneq ($(VARS),)
-       include $(MAKEFILE_VARS)
-endif
-
-
-# Packages we should compile
-PACKAGES = \
-       com.sun.lwuit.painter \
-       com.sun.lwuit.animations \
-       javax.microedition.media \
-       com.sun.lwuit.util \
-       com.sun.lwuit.plaf \
-       javax.microedition.m3g \
-       com.sun.lwuit.events \
-       com.sun.lwuit.geom \
-       com.sun.lwuit.list \
-       com.sun.lwuit \
-       org.thenesis.lwuit.configuration \
-       com.sun.lwuit.layouts
-
-
-# All packages that can be recursively compiled.
-ALL_PACKAGES = \
-       org.thenesis.lwuit \
-       javax \
-       org.thenesis \
-       org \
-       javax.microedition \
-       com.sun \
-       com \
-       $(PACKAGES)
-
-
-# Packages to generate docs for.
-JAVADOC_PACKAGES = $(PACKAGES)
-
-
-# Resource packages
-RESOURCES = 
-
-
-# Directories with shell scripts
-SCRIPTS = 
-
-# ------------------------------------------------------------------- #
-
-# A marker variable for the top level directory
-TOPLEVEL       := .
-
-# Subdirectories with java files:
-JAVA_DIRS      := $(subst .,/,$(PACKAGES)) $(TOPLEVEL)
-
-# Subdirectories with only resource files:
-RESOURCE_DIRS  := $(subst .,/,$(RESOURCES))
-
-# All the .xjava source files:
-XJAVA_SRC      := $(foreach dir, $(JAVA_DIRS), $(wildcard $(dir)/*.xjava))
-
-# All the xjava files to build
-XJAVA_OBJS     := $(XJAVA_SRC:.xjava=.java)
-
-# Directory coresponding to a package
-PACKAGE_DIR    = $(subst .,/,$(1))
-
-# All the (x)java files in a package
-PACKAGE_SRC    =  $(shell $(FIND) $(PACKAGE_DIR) \( -name '*.java' -or -name '*.xjava' \) )
-
-# All the classes to build in a package
-PACKAGE_OBJS   = $(patsubst %.java,%.class,$(PACKAGE_SRC: %.xjava=%.java))
-
-# All the .java source files:
-JAVA_SRC       := $(foreach dir, $(JAVA_DIRS), $(wildcard $(dir)/*.java))
-JAVA_SRC       := $(XJAVA_OBJS) $(JAVA_SRC)
-
-# Dependency files:
-DEPEND_OBJS    := $(JAVA_SRC:.java=.u)
-
-# The intermediate java files and main classes we should build:
-JAVA_OBJS      := $(XJAVA_OBJS) $(JAVA_SRC:.java=.class)
-
-#  Search for resource files in both JAVA_DIRS and RESOURCE_DIRS
-RESOURCE_OBJS  := $(foreach dir, $(JAVA_DIRS) $(RESOURCE_DIRS), \
-                    $(wildcard $(foreach file, $(RESOURCE_SRC), \
-                    $(dir)/$(file))))
-
-# All the shell scripts source
-SCRIPT_SRCS    := $(foreach dir, $(SCRIPTS), $(wildcard $(dir)/*.sh))
-# All shell scripts we should install
-SCRIPT_OBJS            := $(SCRIPT_SRCS:.sh=)
-
-# All the files to install into CLASS_DIR
-INSTALL_OBJS   := $(foreach dir, $(JAVA_DIRS), $(wildcard $(dir)/*.class))
-# Escape inner class delimiter $
-INSTALL_OBJS   := $(subst $$,\$$,$(INSTALL_OBJS))
-# Add the resource files to be installed as well
-INSTALL_OBJS   := $(INSTALL_OBJS) $(RESOURCE_OBJS)
-
-
-# ------------------------------------------------------------------- #
-
-
-define check-exit
-|| exit 1
-
-endef
-
-
-# -----------
-# Build Rules
-# -----------
-
-%.java: %.xjava
-       $(CPP) -D$(VERSION) $< $@
-
-%.class: %.java
-       $(JAVAC) $(JAVAC_FLAGS) $<
-
-%.jar: $(JAVA_OBJS) $(RESOURCE_OBJS)
-       $(FIND) $(TOPLEVEL) $(JAR_OBJS) -print | $(XARGS) \
-       $(JAR) $(JAR_FLAGS) $(JAR_FILE) 
-
-%.u: %.java
-       $(JAVAC) $(JIKES_DEP_FLAG) $<
-
-
-# -------
-# Targets
-# -------
-
-.PHONY: all jar install uninstall doc clean depend tags bundle \
-       help $(ALL_PACKAGES)
-
-all::  $(JAVA_OBJS)
-
-help:
-       @echo "Usage: make {all|jar|srcjar|bundle|install|uninstall|doc|clean|depend|tags|PACKAGE_NAME}"
-       @echo " all: build all classes"
-       @echo " jar: build jar file"
-       @echo " srcjar: build source jar file"
-       @echo " bundle: build OS X app bundle"
-       @echo " install: install classes into $(CLASS_DIR)"
-       @echo "         jar into $(JAR_DIR)"
-       @echo "         bundle into $(BUNDLE_DIR)"
-       @echo "         javadocs into $(DOC_DIR)"
-       @echo "         scripts into $(SCRIPT_DIR)"
-       @echo " uninstall: remove installed files"
-       @echo " doc: generate api docs from javadoc comments"
-       @echo " clean: remove classes and temporary files"
-       @echo " depend: build class dependency info using jikes"
-       @echo " tags: build emacs tags file"
-       @echo " PACKAGE_NAME: builds all classes in this package and any subpackages."
-
-# Jar target
-ifneq ($(strip $(JAR_FILE)),)
-jar:  $(JAR_FILE)
-ifneq ($(strip $(JAR_DIR)),)
-install:: $(JAR_FILE)
-       @echo "===> [Installing jar file, $(JAR_FILE) in $(JAR_DIR)] "
-       $(INSTALL_DIR) $(JAR_DIR) $(check-exit)
-       $(INSTALL_FILE) $(JAR_FILE) $(JAR_DIR) $(check-exit)
-uninstall::
-       @echo "===> [Removing jar file, $(JAR_FILE) from $(JAR_DIR)] "
-       $(RM) $(JAR_DIR)/$(JAR_FILE)  $(check-exit)
-else
-install::
-       @echo "No jar install dir defined"
-endif
-clean::
-       $(RM) $(JAR_FILE)
-else
-jar:
-       @echo "No jar file defined"
-endif
-
-SRC_JAR_FILE := $(basename $(JAR_FILE))-src$(suffix $JAR_FILE)
-
-# Source jar target
-srcjar : $(SRC_JAR_FILE)
-$(SRC_JAR_FILE): $(JAVA_SRC) $(RESOURCE_OBJS)
-       $(FIND) $(TOPLEVEL) $(JAR_OBJS: .class=.java) -print | $(XARGS) \
-       $(JAR) $(JAR_FLAGS) $@
-
-# Bundle target
-ifneq ($(strip $(BUNDLE_FILE)),)
-bundle:  $(BUNDLE_FILE)
-$(BUNDLE_FILE) : $(JAR_FILE)
-       $(INSTALL_DIR) $(BUNDLE_FILE)/Contents/Resources/Java $(check-exit)
-       $(INSTALL_DIR) $(BUNDLE_FILE)/Contents/MacOS $(check-exit)
-       $(INSTALL_PROG) $(JAVA_STUB) $(BUNDLE_FILE)/Contents/MacOS/ \
-               $(check-exit)
-       ( $(CAT) $(BUNDLE_RESOURCE_DIR)/Info.plist | $(SED) -e \
-               s/VERSION/$(VERSION)/ >98762infoplist876 ) $(check-exit)
-       $(INSTALL_FILE) 98762infoplist876 \
-               $(BUNDLE_FILE)/Contents/Info.plist $(check-exit)
-       $(RM) 98762infoplist876 $(check-exit)
-       $(INSTALL_FILE) $(JAR_FILE) $(BUNDLE_FILE)/Contents/Resources/Java
-       checkexit="";for f in $(BUNDLE_RESOURCES); do \
-               $(INSTALL_FILE) $(BUNDLE_RESOURCE_DIR)$$f $(BUNDLE_FILE)/Contents/Resources/ \
-               || checkexit=$?; \
-               done; test -z $$checkexit
-
-ifneq ($(strip $(BUNDLE_DIR)),)
-# This is probably bad, but I don't know how else to do it
-install:: $(BUNDLE_FILE)
-       @echo "===> [Installing app bundle, $(BUNDLE_FILE) in $(BUNDLE_DIR)] "
-       $(INSTALL_DIR) $(BUNDLE_DIR) $(check-exit)
-       $(CP) -R $(BUNDLE_FILE) $(BUNDLE_DIR) $(check-exit)
-       $(INSTALL_FILE) $(BUNDLE_FILE) $(BUNDLE_DIR) $(check-exit)
-uninstall::
-       @echo "===> [Removing bundle file, $(BUNDLE_FILE) from $(BUNDLE_DIR)] "
-       $(RM) -r $(BUNDLE_DIR)/$(BUNDLE_FILE)  $(check-exit)
-else
-install::
-       @echo "No bundle install dir defined"
-endif
-clean::
-       $(RM) -r $(BUNDLE_FILE)
-else
-bundle:
-       @echo "No bundle file defined"
-endif
-
-
-# Install target for Classes and Resources 
-ifneq ($(strip $(CLASS_DIR)),)
-install:: $(JAVA_OBJS)
-       @echo "===> [Installing classes in $(CLASS_DIR)] "
-       $(INSTALL_DIR) $(CLASS_DIR) $(check-exit)
-       $(foreach dir, $(JAVA_DIRS) $(RESOURCE_DIRS), \
-               $(INSTALL_DIR) $(CLASS_DIR)/$(dir) $(check-exit))
-       $(foreach file, $(INSTALL_OBJS), \
-               $(INSTALL_FILE) $(file) $(CLASS_DIR)/$(file) \
-       $(check-exit))
-uninstall::
-       @echo "===> [Removing class-files from $(CLASS_DIR)] "
-       $(foreach file, $(INSTALL_OBJS), \
-               $(RM) $(CLASS_DIR)/$(file) \
-       $(check-exit))
-else
-# Print a warning here if you like. (No class install dir defined)
-endif
-
-
-
-# Depend target
-ifeq ($(findstring jikes,$(JAVAC)),jikes)
-depend: $(XJAVA_OBJS) $(DEPEND_OBJS)
-       ( $(CAT) $(DEPEND_OBJS) |  $(SED) -e '/\.class$$/d' \
-         -e '/.*$$.*/d' > $(MAKEFILE_DEPEND); $(RM) $(DEPEND_OBJS); )
-else
-depend:
-       @echo "mmake needs the jikes compiler to build class dependencies"
-endif
-
-
-
-# Doc target
-ifneq ($(strip $(JAVADOC_PACKAGES)),)
-doc:   $(JAVA_SRC)
-       @echo "===> [Installing java documentation in $(DOC_DIR)] "
-       $(INSTALL_DIR) $(DOC_DIR) $(check-exit)
-       $(JAVADOC) $(JAVADOC_FLAGS) -d $(DOC_DIR) $(JAVADOC_PACKAGES)
-else
-doc:
-       @echo "You must put your source files in a package to run make doc"
-endif
-
-
-
-# Script target
-ifneq ($(strip  $(SCRIPT_OBJS)),)
-all::   $(SCRIPT_OBJS)
-ifneq ($(strip $(SCRIPT_DIR)),)
-install:: $(SCRIPT_OBJS)
-       @echo "===> [Installing shell-scripts in $(SCRIPT_DIR)] "
-       $(INSTALL_DIR) $(SCRIPT_DIR) $(check-exit)
-       $(foreach file, $(SCRIPT_OBJS), \
-               $(INSTALL_PROG) $(file) $(SCRIPT_DIR) $(check-exit))
-uninstall:: 
-       @echo "===> [Removing shell-scripts from $(SCRIPT_DIR)] "
-       $(foreach file, $(SCRIPT_OBJS), \
-               $(RM) $(SCRIPT_DIR)/$(file) $(check-exit))
-else
-# Print a warning here if you like. (No script install dir defined)
-endif
-clean::
-       rm -f $(SCRIPT_OBJS)
-endif
-
-
-
-# Tag target
-tags:  
-       @echo "Tagging"
-       $(ETAGS) $(filter-out $(XJAVA_OBJS), $(JAVA_SRC)) $(XJAVA_SRC)
-
-
-
-# Various cleanup routines
-clean::
-       $(FIND) . \( -name '*~' -o -name '*.class' \) -print | \
-       $(XARGS) $(RM) 
-       $(FIND) . -name '*.u' -print | $(XARGS) $(RM)
-
-ifneq ($(strip $(XJAVA_SRC)),)
-clean::
-       $(RM) $(XJAVA_OBJS)
-endif
-
-# ----------------------------------------
-# Include the dependency graph if it exist
-# ----------------------------------------
-MAKEFILE_DEPEND        = makefile.dep
-DEPEND = $(wildcard $(MAKEFILE_DEPEND))
-ifneq ($(DEPEND),)
-       include $(MAKEFILE_DEPEND)
-endif
-
-#package targets
-org.thenesis.lwuit : $(call PACKAGE_OBJS,org.thenesis.lwuit)
-javax : $(call PACKAGE_OBJS,javax)
-org.thenesis : $(call PACKAGE_OBJS,org.thenesis)
-org : $(call PACKAGE_OBJS,org)
-javax.microedition : $(call PACKAGE_OBJS,javax.microedition)
-com.sun : $(call PACKAGE_OBJS,com.sun)
-com : $(call PACKAGE_OBJS,com)
-com.sun.lwuit.painter : $(call PACKAGE_OBJS,com.sun.lwuit.painter)
-com.sun.lwuit.animations : $(call PACKAGE_OBJS,com.sun.lwuit.animations)
-javax.microedition.media : $(call PACKAGE_OBJS,javax.microedition.media)
-com.sun.lwuit.util : $(call PACKAGE_OBJS,com.sun.lwuit.util)
-com.sun.lwuit.plaf : $(call PACKAGE_OBJS,com.sun.lwuit.plaf)
-javax.microedition.m3g : $(call PACKAGE_OBJS,javax.microedition.m3g)
-com.sun.lwuit.events : $(call PACKAGE_OBJS,com.sun.lwuit.events)
-com.sun.lwuit.geom : $(call PACKAGE_OBJS,com.sun.lwuit.geom)
-com.sun.lwuit.list : $(call PACKAGE_OBJS,com.sun.lwuit.list)
-com.sun.lwuit : $(call PACKAGE_OBJS,com.sun.lwuit)
-org.thenesis.lwuit.configuration : $(call PACKAGE_OBJS,org.thenesis.lwuit.configuration)
-com.sun.lwuit.layouts : $(call PACKAGE_OBJS,com.sun.lwuit.layouts)
-
diff --git a/core/java/com/sun/lwuit/Button.java b/core/java/com/sun/lwuit/Button.java
deleted file mode 100644 (file)
index f9cc4cb..0000000
+++ /dev/null
@@ -1,323 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.geom.Dimension;\r
-import com.sun.lwuit.events.ActionEvent;\r
-import com.sun.lwuit.events.ActionListener;\r
-import com.sun.lwuit.plaf.Border;\r
-import com.sun.lwuit.plaf.UIManager;\r
-\r
-\r
-/**\r
- * Button is the base class for several UI widgets allowing clickability.\r
- * It has 3 states: rollover, pressed and the default state it \r
- * can also have ActionListeners that react when the Button is clicked.\r
- * \r
- * @author Chen Fishbein\r
- */\r
-public class Button extends Label {\r
-    /**\r
-     * Indicates the rollover state of a button which is equivalent to focused for\r
-     * most uses\r
-     */\r
-    public static final int STATE_ROLLOVER = 0;\r
-    \r
-    /**\r
-     * Indicates the pressed state of a button \r
-     */\r
-    public static final int STATE_PRESSED = 1;\r
-    \r
-    /**\r
-     * Indicates the default state of a button which is neither pressed nor focused\r
-     */\r
-    public static final int STATE_DEAFULT = 2;\r
-    \r
-    private static String id = "Button";\r
-    \r
-    private EventDispatcher dispatcher = new EventDispatcher();\r
-    \r
-    private int state = STATE_DEAFULT;\r
-    \r
-    private Image pressedIcon;\r
-    \r
-    private Image rolloverIcon;\r
-  \r
-    private Command cmd;\r
-    \r
-    /** \r
-     * Constructs a button with an empty string for its text.\r
-     */\r
-    public Button() {\r
-        this("");\r
-    }\r
-    \r
-    /**\r
-     * Constructs a button with the specified text.\r
-     * \r
-     * @param text label appearing on the button\r
-     */\r
-    public Button(String text) {\r
-        this(text, null);\r
-    }\r
-    \r
-    /**\r
-     * Allows binding a command to a button for ease of use\r
-     * \r
-     * @param cmd command whose text would be used for the button and would recive action events\r
-     * from the button\r
-     */\r
-    public Button(Command cmd) {\r
-        this(cmd.getCommandName(), cmd.getIcon());\r
-        addActionListener(cmd);\r
-        this.cmd = cmd;\r
-    }\r
-    \r
-    /**\r
-     * Constructs a button with the specified image.\r
-     * \r
-     * @param icon appearing on the button\r
-     */\r
-    public Button(Image icon) {\r
-        this("", icon);\r
-    }\r
-    \r
-    /**\r
-     * Constructor a button with text and image\r
-     * \r
-     * @param text label appearing on the button\r
-     * @param icon image appearing on the button\r
-     */\r
-    public Button(String text, Image icon) {\r
-        super(text);\r
-        setFocusable(true);\r
-        setIcon(icon);\r
-        this.pressedIcon = icon;\r
-        this.rolloverIcon = icon;\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    void focusGainedInternal() {\r
-        state = STATE_ROLLOVER;\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    void focusLostInternal() {\r
-        state = STATE_DEAFULT;\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected String getUIID() {\r
-        return id;\r
-    }\r
-    \r
-    /**\r
-     * Returns the button state\r
-     * \r
-     * @return One of STATE_ROLLOVER, STATE_DEAFULT, STATE_PRESSED\r
-     */\r
-    public int getState() {\r
-        return state;\r
-    }\r
-    \r
-    /**\r
-     * Indicates the icon that is displayed on the button when the button is in \r
-     * pressed state\r
-     * \r
-     * @return icon used\r
-     * @see #STATE_PRESSED\r
-     */\r
-    public Image getPressedIcon() {\r
-        return pressedIcon;\r
-    }\r
-    \r
-    /**\r
-     * Indicates the icon that is displayed on the button when the button is in \r
-     * rolled over state\r
-     * \r
-     * @return icon used\r
-     * @see #STATE_ROLLOVER\r
-     */\r
-    public Image getRolloverIcon() {\r
-        return rolloverIcon;\r
-    }\r
-    \r
-    /**\r
-     * Indicates the icon that is displayed on the button when the button is in \r
-     * rolled over state\r
-     * \r
-     * @param rolloverIcon icon to use\r
-     * @see #STATE_ROLLOVER\r
-     */\r
-    public void setRolloverIcon(Image rolloverIcon) {\r
-        this.rolloverIcon = rolloverIcon;\r
-        setShouldCalcPreferredSize(true);\r
-        repaint();\r
-        \r
-    }\r
-    \r
-    /**\r
-     * Indicates the icon that is displayed on the button when the button is in \r
-     * pressed state\r
-     * \r
-     * @param pressedIcon icon used\r
-     * @see #STATE_PRESSED\r
-     */\r
-    public void setPressedIcon(Image pressedIcon) {\r
-        this.pressedIcon = pressedIcon;\r
-        setShouldCalcPreferredSize(true);\r
-        repaint();\r
-    }\r
-    \r
-    /**\r
-     * Adds a listener to the button which will cause an event to dispatch on click\r
-     * \r
-     * @param l implementation of the action listener interface\r
-     */\r
-    public void addActionListener(ActionListener l){\r
-        dispatcher.addListener(l);\r
-    }\r
-    \r
-    /**\r
-     * Removes the given action listener from the button\r
-     * \r
-     * @param l implementation of the action listener interface\r
-     */\r
-    public void removeActionListener(ActionListener l){\r
-        dispatcher.removeListener(l);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    void fireActionEvent(){\r
-        super.fireActionEvent();\r
-        if(cmd != null) {\r
-            dispatcher.fireActionEvent(new ActionEvent(cmd));\r
-        } else {\r
-            dispatcher.fireActionEvent(new ActionEvent(this));\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * Invoked to change the state of the button to the pressed state\r
-     */\r
-    void pressed(){\r
-        if(isEnabled()) {\r
-            state=STATE_PRESSED;\r
-            repaint();\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * Invoked to change the state of the button to the released state\r
-     */\r
-    void released(){\r
-        if(isEnabled()) {\r
-            state=STATE_ROLLOVER;\r
-            repaint();\r
-            fireActionEvent();\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void keyPressed(int keyCode) {\r
-        if (Display.getInstance().getGameAction(keyCode) == Display.GAME_FIRE){\r
-            pressed();\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void keyReleased(int keyCode) {\r
-        if (Display.getInstance().getGameAction(keyCode) == Display.GAME_FIRE){\r
-            released();\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected void fireClicked() {\r
-        pressed();\r
-        released();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected boolean isSelectableInteraction() {\r
-        return true;\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void pointerPressed(int x, int y) {\r
-        pressed();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void pointerReleased(int x, int y) {\r
-        released();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void paint(Graphics g) {\r
-        UIManager.getInstance().getLookAndFeel().drawButton(g, this);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected Dimension calcPreferredSize(){\r
-        return UIManager.getInstance().getLookAndFeel().getButtonPreferredSize(this);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected Border getBorder() {\r
-        if(getState() != STATE_PRESSED){\r
-            return super.getBorder();\r
-        } else {\r
-            return getStyle().getBorder().createPressedVersion();\r
-        }\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/ButtonGroup.java b/core/java/com/sun/lwuit/ButtonGroup.java
deleted file mode 100644 (file)
index 153f704..0000000
+++ /dev/null
@@ -1,160 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-\r
-package com.sun.lwuit;\r
-\r
-/**\r
- * This class is used to create a multiple-exclusion scope for a set of \r
- * RadioButtons. Creating a set of RadioButtons with the same ButtonGroup object\r
- * means that only one RadioButton can be selected amoung the ButtonGroup.\r
- * Initialy all RadioButtons are unselected.\r
- * \r
- * @author Nir Shabi\r
- */\r
-public class ButtonGroup {\r
-    \r
-    \r
-    private java.util.Vector buttons = new java.util.Vector();\r
-    private int selectedIndex=-1;\r
-    \r
-    /** \r
-     * Creates a new instance of ButtonsGroup \r
-     */\r
-    public ButtonGroup() {\r
-    }\r
-    \r
-    /**\r
-     * Adds a RadioButton to the group\r
-     * \r
-     * @param rb a RadioButton to add\r
-     */\r
-    public void add(RadioButton rb){\r
-        if(rb==null)\r
-            return;\r
-        buttons.addElement(rb);\r
-        if(rb.isSelected())\r
-            setSelected(selectedIndex);\r
-        rb.setGroup(this);\r
-        \r
-    }\r
-\r
-    /**\r
-     * removes a RadioButton from the group\r
-     * \r
-     * @param rb a RadioButton to remove\r
-     */\r
-    public void remove(RadioButton rb){\r
-        if(rb==null)\r
-            return;\r
-        buttons.removeElement(rb);\r
-        if(rb.isSelected())\r
-            clearSelection();\r
-        rb.setGroup(null);\r
-    }\r
-    \r
-    /**\r
-     * Clears the selection such that none of the buttons in the ButtonGroup are selected.\r
-     */\r
-    public void clearSelection() {\r
-        if(selectedIndex!=-1) {\r
-            ((RadioButton)buttons.elementAt(selectedIndex)).setSelected(false);\r
-            selectedIndex=-1;\r
-        }\r
-        \r
-    }\r
-    \r
-    /**\r
-     * Returns the number of buttons in the group.\r
-     * \r
-     * @return number of radio buttons in the group\r
-     */\r
-    public int getButtonCount() {\r
-        return buttons.size();\r
-    }\r
-    \r
-    /**\r
-     * Returns whether a radio button in the group is selected.\r
-     * \r
-     * @return true if a selection was made in the radio button group\r
-     */\r
-    public boolean isSelected() {\r
-        if(selectedIndex!= -1)\r
-            return true;\r
-        return false;\r
-    }\r
-    \r
-    /**\r
-     * Return the index of the selected button within the group\r
-     * \r
-     * @return the index of the selected button within the group\r
-     */\r
-    public int getSelectedIndex() {\r
-        return selectedIndex;\r
-    }\r
-    \r
-    /**\r
-     * Returns the radio button at the given group index\r
-     * \r
-     * @param index offset within the group starting with 0 and no larger than getButtonCount()\r
-     * @return the radio button instance\r
-     */\r
-    public RadioButton getRadioButton(int index) {\r
-        if(index >=0 && index < getButtonCount())\r
-            return ((RadioButton)buttons.elementAt(index));\r
-        return null;\r
-    }\r
-\r
-    /**\r
-     * Selects the given radio button\r
-     * \r
-     * @param rb the radio button to set as selected\r
-     */\r
-    public void setSelected(RadioButton rb) {\r
-        if (rb != null) {\r
-            int index = buttons.indexOf(rb);\r
-            setSelected(index);\r
-        } else {\r
-            clearSelection();\r
-        }\r
-    }\r
-    \r
-    /**\r
-     * Sets the selected Radion button by index\r
-     * \r
-     * @param index the index of the radio button to mark as selected\r
-     */\r
-    public void setSelected(int index) {\r
-        if(index < 0  ||  index >= getButtonCount() )\r
-            throw new IllegalArgumentException("Inedx out of bounds");\r
-        \r
-        if(selectedIndex!=-1) {\r
-            //unselect last selected Radio button\r
-            ((RadioButton)buttons.elementAt(selectedIndex)).setSelected(false);\r
-            ((RadioButton)buttons.elementAt(selectedIndex)).repaint();\r
-        }\r
-        ((RadioButton)buttons.elementAt(index)).setSelected(true);\r
-        selectedIndex=index;\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/Calendar.java b/core/java/com/sun/lwuit/Calendar.java
deleted file mode 100644 (file)
index eb3bb7d..0000000
+++ /dev/null
@@ -1,181 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.events.ActionListener;\r
-import com.sun.lwuit.plaf.Style;\r
-import com.sun.lwuit.layouts.BorderLayout;\r
-import com.sun.lwuit.layouts.BoxLayout;\r
-import com.sun.lwuit.layouts.FlowLayout;\r
-import com.sun.lwuit.plaf.UIManager;\r
-import java.util.Date;\r
-import java.util.Hashtable;\r
-\r
-/**\r
- * Date widget for selecting a date/time value. \r
- * <p>To localize strings for month names\r
- * use the values "Calendar.Month" in the resource localization e.g. "Calendar.Jan", "Calendar.Feb" etc...\r
- *\r
- * @author Iddo Ari\r
- */\r
-public class Calendar extends Container {\r
-    protected Label month;\r
-    protected Label year;\r
-    private MonthView mv;\r
-    private static String[] MONTHS = new String[]{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};\r
-\r
-    /**\r
-     * Creates a new instance of Calendar set to the given date based on time\r
-     * since epoch (the java.util.Date convention)\r
-     * \r
-     * @param time time since epoch\r
-     */\r
-    public Calendar(long time) {\r
-        super(new BorderLayout());\r
-        Container upper = new Container(new FlowLayout(Component.CENTER));\r
-        mv = new MonthView(time, this);\r
-        \r
-        month = new Label(MONTHS[mv.getMonth()]);\r
-        java.util.Calendar cal = java.util.Calendar.getInstance();\r
-        cal.setTime(new java.util.Date(time));\r
-        month.getStyle().setBgTransparency(0);\r
-        int y = cal.get(java.util.Calendar.YEAR);\r
-        year = new Label("" + y);\r
-        year.getStyle().setBgTransparency(0);\r
-        \r
-        Container cnt = new Container(new BoxLayout(BoxLayout.X_AXIS));\r
-        cnt.addComponent(month);\r
-        cnt.addComponent(year);\r
-        upper.addComponent(cnt);\r
-        \r
-        addComponent(BorderLayout.NORTH, upper);\r
-        addComponent(BorderLayout.CENTER, mv);\r
-    }\r
-    \r
-    /**\r
-     * Constructs a calendar with the current date and time\r
-     */\r
-    public Calendar() {\r
-        this(System.currentTimeMillis());\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected String getUIID() {\r
-        return "Calendar";\r
-    }\r
-\r
-    /**\r
-     * Returns the time for the current calendar.\r
-     * \r
-     * @return the time for the current calendar.\r
-     */\r
-    public long getSelectedDay() {\r
-        return mv.getSelectedDay();\r
-    }\r
-\r
-    void componentChanged() {\r
-        java.util.Calendar cal = java.util.Calendar.getInstance();\r
-\r
-        cal.set(java.util.Calendar.YEAR, mv.getYear());\r
-        cal.set(java.util.Calendar.MONTH, mv.getMonth());\r
-        cal.set(java.util.Calendar.DAY_OF_MONTH, mv.getDayOfMonth());\r
-        Hashtable t =  UIManager.getInstance().getResourceBundle();\r
-        String text = MONTHS[mv.getMonth()];\r
-        if(t != null) {\r
-            Object o = t.get("Calendar." + text);\r
-            if(o != null) {\r
-                text = (String)o;\r
-            }\r
-        } \r
-        month.setText(text);\r
-        year.setText("" + mv.getYear());\r
-        month.getParent().revalidate();\r
-    }\r
-\r
-    /**\r
-     * Return the date object matching the current selection\r
-     * \r
-     * @return the date object matching the current selection\r
-     */\r
-    public Date getDate() {\r
-        return new Date(mv.getSelectedDay());\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void paint(Graphics g) {\r
-        super.paint(g);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void refreshTheme() {\r
-        mv.refreshTheme();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void setStyle(Style s) {\r
-        // make sure the labels have the style of the calendar and not the style of a label\r
-        super.setStyle(s);\r
-        month.setStyle(s);\r
-        year.setStyle(s);\r
-    }\r
-\r
-    /**\r
-     * Sets the style of the month view component within the calendar\r
-     */\r
-    public void setMonthViewStyle(Style s) {\r
-        mv.setStyle(s);\r
-    }\r
-\r
-    /**\r
-     * Sets the style of the month view component within the calendar\r
-     */\r
-    public Style getMonthViewStyle() {\r
-        return mv.getStyle();\r
-    }\r
-\r
-    \r
-    /**\r
-     * Fires when a change is made to the month view of this component\r
-     */\r
-    public void addActionListener(ActionListener l){\r
-        mv.addActionListener(l);\r
-    }\r
-    \r
-    /**\r
-     * Fires when a change is made to the month view of this component\r
-     */\r
-    public void removeActionListener(ActionListener l){\r
-        mv.removeActionListener(l);\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/CheckBox.java b/core/java/com/sun/lwuit/CheckBox.java
deleted file mode 100644 (file)
index 950822e..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.plaf.UIManager;\r
-import com.sun.lwuit.geom.*;\r
-\r
-/**\r
- * Checkbox is a button that can be selected or deselected, and which displays\r
- * its state to the user.\r
- * \r
- * @author Chen Fishbein\r
- */\r
-public class CheckBox extends Button {\r
-    \r
-    private static final String id = "CheckBox";\r
-    \r
-    private boolean selected= false;\r
-    \r
-    /**\r
-     * Constructs a checkbox with the given text\r
-     * \r
-     * @param text to display next to the checkbox\r
-     */\r
-    public CheckBox(String text) {\r
-        this(text, null);\r
-    }\r
-\r
-    /**\r
-     * Constructs a checkbox with no text\r
-     */\r
-    public CheckBox() {\r
-        this("");\r
-    }\r
-    \r
-    /**\r
-     * Constructs a checkbox with the given icon\r
-     * \r
-     * @param icon icon to display next to the checkbox\r
-     */\r
-    public CheckBox(Image icon) {\r
-        this("", icon);\r
-    }\r
-\r
-    /**\r
-     * Constructs a checkbox with the given text and icon\r
-     * \r
-     * @param text to display next to the checkbox\r
-     * @param icon icon to display next to the text\r
-     */\r
-    public CheckBox(String text,Image icon) {\r
-        super(text,icon);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected String getUIID() {\r
-        return id;\r
-    }\r
-    \r
-    /**\r
-     * Return true if the checkbox is selected\r
-     * \r
-     * @return true if the checkbox is selected\r
-     */\r
-    public boolean isSelected() {\r
-        return selected;\r
-    }\r
-    \r
-    /**\r
-     * Selects the current checkbox\r
-     * \r
-     * @param selected value for selection\r
-     */\r
-    public void setSelected(boolean selected) {\r
-        this.selected = selected;\r
-        repaint();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void released() {\r
-        selected = !isSelected();\r
-        super.released();\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void paint(Graphics g) {\r
-        UIManager.getInstance().getLookAndFeel().drawCheckBox(g, this);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected Dimension calcPreferredSize(){\r
-        return UIManager.getInstance().getLookAndFeel().getCheckBoxPreferredSize(this);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected String paramString() {\r
-        return super.paramString() + ", selected = " +selected;\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/ComboBox.java b/core/java/com/sun/lwuit/ComboBox.java
deleted file mode 100644 (file)
index b661557..0000000
+++ /dev/null
@@ -1,218 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.geom.Dimension;\r
-import com.sun.lwuit.plaf.Style;\r
-import com.sun.lwuit.events.ActionEvent;\r
-import com.sun.lwuit.events.ActionListener;\r
-import com.sun.lwuit.layouts.BorderLayout;\r
-import com.sun.lwuit.list.DefaultListCellRenderer;\r
-import com.sun.lwuit.list.DefaultListModel;\r
-import com.sun.lwuit.list.ListCellRenderer;\r
-import com.sun.lwuit.list.ListModel;\r
-import com.sun.lwuit.plaf.UIManager;\r
-import java.util.Vector;\r
-\r
-/**\r
- * A combo box is a list that allows only one selection at a time, when a user clicks\r
- * the combo box a popup button with the full list of elements allows the selection of\r
- * a single element. The combo box is driven by the list model and allows all the renderer\r
- * features of the List as well. \r
- * \r
- * @see List\r
- * @author Chen Fishbein\r
- */\r
-public class ComboBox extends List {\r
-\r
-    private static String id = "ComboBox";\r
-    private Component popupContent;\r
-    private List contained;\r
-    private Popup popup;\r
-\r
-    /** \r
-     * Creates a new instance of ComboBox \r
-     * \r
-     * @param items set of items placed into the combo box model\r
-     */\r
-    public ComboBox(Vector items) {\r
-        this(new DefaultListModel(items));\r
-    }\r
-\r
-    /** \r
-     * Creates a new instance of ComboBox \r
-     * \r
-     * @param items set of items placed into the combo box model\r
-     */\r
-    public ComboBox(Object[] items) {\r
-        this(new DefaultListModel(items));\r
-    }\r
-\r
-    /** \r
-     * Constructs an empty combo box\r
-     */\r
-    public ComboBox() {\r
-        this(new DefaultListModel());\r
-    }\r
-\r
-    /**\r
-     * Creates a new instance of ComboBox \r
-     * \r
-     * @param model the model for the combo box elements and selection\r
-     */\r
-    public ComboBox(ListModel model) {\r
-        super(model);\r
-        ((DefaultListCellRenderer)super.getRenderer()).setShowNumbers(false);\r
-        setInputOnFocus(false);\r
-        setIsScrollVisible(false);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected String getUIID() {\r
-        return id;\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void setSelectedIndex(int selection) {\r
-        super.setSelectedIndex(selection, false);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void setSelectedIndex(int selection, boolean scroll) {\r
-        super.setSelectedIndex(selection, false);\r
-    }\r
-    \r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void setModel(ListModel m) {\r
-        super.setModel(m);\r
-        if (contained != null) {\r
-            contained.setModel(m);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void setHandlesInput(boolean handlesInput) {\r
-        super.setHandlesInput(handlesInput);\r
-        getPopup().setVisible(handlesInput);\r
-        if (isSmoothScrolling()) {\r
-            if (handlesInput) {\r
-                getComponentForm().registerAnimated(((Container) popupContent).getComponentAt(0));\r
-            } else {\r
-                getComponentForm().deregisterAnimated(((Container) popupContent).getComponentAt(0));\r
-            }\r
-        }\r
-    }\r
-\r
-    private Component getPopupContent() {\r
-\r
-        contained = new List(getModel());\r
-        contained.setFixedSelection(FIXED_NONE_CYCLIC);\r
-        contained.setListCellRenderer(getRenderer());\r
-        contained.addActionListener(new ActionListener() {\r
-\r
-            public void actionPerformed(ActionEvent evt) {\r
-                setHandlesInput(!handlesInput());\r
-                fireActionEvent();\r
-            }\r
-        });\r
-        Container cnt = new Container(new BorderLayout());\r
-        cnt.addComponent(BorderLayout.CENTER, contained);\r
-        contained.setStyle(UIManager.getInstance().getComponentStyle("ComboBoxPopup"));\r
-\r
-        popupContent = cnt;\r
-        return popupContent;\r
-    }\r
-\r
-    private Popup getPopup() {\r
-        if (popup == null) {\r
-            popup = new Popup(getComponentForm(), getPopupContent());\r
-        } else {\r
-            contained.setListCellRenderer(getRenderer());\r
-            contained.setModel(getModel());\r
-        }\r
-        int y = getAbsoluteY() + getHeight();\r
-        int height = Math.min(getComponentForm().getHeight() - y, popupContent.getPreferredSize().getHeight());\r
-        \r
-        // if there is not enough room to popup, open the popup upwards.\r
-        if(getComponentForm().getHeight() - y < contained.getElementSize(true).getHeight() * 3) {\r
-            height = contained.getElementSize(true).getHeight() * 3;\r
-            y = getAbsoluteY() - height;\r
-        }\r
-        popupContent.setHeight(height);\r
-        popupContent.setX(getAbsoluteX());\r
-        popupContent.setY(y);\r
-        popupContent.setWidth(getWidth());\r
-        popupContent.setFixedPosition(true);\r
-        Style s = popupContent.getStyle();\r
-        s.merge(getStyle());\r
-        s.setBgTransparency(0xFF);\r
-        s.setBorder(null);\r
-        s.setMargin(0, 0, 0, 0);\r
-        s.setPadding(0, 0, 0, 0);\r
-        return popup;\r
-    }\r
-\r
-    /**\r
-     * Reset popup data on model change to allow the popup to refresh with the \r
-     * right details\r
-     * \r
-     * @param status the model status\r
-     */\r
-    protected void modelChanged(int status) {\r
-        popup = null;\r
-        popupContent = null;\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void pointerReleased(int x, int y) {\r
-        setHandlesInput(true);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void paint(Graphics g) {\r
-        UIManager.getInstance().getLookAndFeel().drawComboBox(g, this);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected Dimension calcPreferredSize() {\r
-        return UIManager.getInstance().getLookAndFeel().getComboBoxPreferredSize(this);\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/Command.java b/core/java/com/sun/lwuit/Command.java
deleted file mode 100644 (file)
index 6caf66f..0000000
+++ /dev/null
@@ -1,213 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.events.ActionEvent;\r
-import com.sun.lwuit.events.ActionListener;\r
-\r
-/**\r
- * The action placed on the soft buttons and in the Menu on devices, similar to the\r
- * MIDP command abstraction and Swing's Actions. Unlike the MIDP abstraction this class \r
- * can be derived to implement the right behavior\r
- * \r
- * @author Nir Shabi\r
- */\r
-public class Command implements ActionListener{\r
-    private boolean disposesDialog = true;\r
-    private Image icon;\r
-    private String command;\r
-    \r
-    /**\r
-     * Simplifies code dealing with commands allowing them to be used in switch statements\r
-     * more easily\r
-     */\r
-    private int commandId;\r
-    \r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     */\r
-    public Command(String command) {\r
-        this.command = command;\r
-    }\r
-\r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     * @param icon the icon representing the command\r
-     */\r
-    public Command(String command, Image icon) {\r
-        this.command = command;\r
-        this.icon = icon;\r
-    }\r
-\r
-\r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     * @param id user defined ID for a command simplifying switch statement code\r
-     * working with a command\r
-     */\r
-    public Command(String command, int id) {\r
-        this.command = command;\r
-        this.commandId = id;\r
-    }\r
-    \r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     * @param icon the icon representing the command\r
-     * @param id user defined ID for a command simplifying switch statement code\r
-     * working with a command\r
-     */\r
-    public Command(String command, Image icon, int id) {\r
-        this.command = command;\r
-        this.commandId = id;\r
-        this.icon = icon;\r
-    }\r
-    \r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     * @param id user defined ID for a command simplifying switch statement code\r
-     * working with a command\r
-     * @param defaultAction Indicates that this action should occur by default \r
-     * on fire action event\r
-     * @deprecated this funcitionality is no longer supported use Form.setDefaultCommand() instead\r
-     */\r
-    public Command(String command, int id, boolean defaultAction) {\r
-        this.command = command;\r
-        this.commandId = id;\r
-    }\r
-\r
-    /**\r
-     * Creates a new instance of Command\r
-     * \r
-     * @param command the string that will be placed on the Soft buttons\Menu\r
-     * @param defaultAction Indicates that this action should occur by default \r
-     * on fire action event\r
-     * @deprecated this funcitionality is no longer supported use Form.setDefaultCommand() instead\r
-     */\r
-    public Command(String command, boolean defaultAction) {\r
-        this.command = command;\r
-    }\r
-\r
-    /**\r
-     * Return the command ID\r
-     * \r
-     * @return the command ID\r
-     */\r
-    public int getId() {\r
-        return commandId;\r
-    }\r
-    \r
-    /**\r
-     * gets the Command Name\r
-     * \r
-     * @return the Command name\r
-     */\r
-    public String getCommandName() {\r
-        return command;\r
-    }\r
-    \r
-    /**\r
-     * Returns the icon representing the command\r
-     * \r
-     * @return an icon representing the command\r
-     */\r
-    public Image getIcon() {\r
-        return icon;\r
-    }\r
-    \r
-    /**\r
-     * Returns a string representation of the object\r
-     * \r
-     * @return Returns a string representation of the object\r
-     */\r
-    public String toString() {\r
-        return command;\r
-    }\r
-    \r
-    /**\r
-     * compare two commands\r
-     * \r
-     * @param obj a Command Object to compare\r
-     * @return true if the obj has the same command name\r
-     */\r
-    public boolean equals(Object obj) {\r
-        return (obj != null) && obj.getClass() == getClass() && ((Command)obj).command == command && ((Command)obj).commandId == commandId;\r
-    }\r
-\r
-    public int hashCode() {\r
-        return getClass().hashCode() + commandId;\r
-    }\r
-    \r
-    /**\r
-     * This method is called when the soft button/Menu item is clicked\r
-     * \r
-     * @param evt the Event Object\r
-     */\r
-    public void actionPerformed(ActionEvent evt) {\r
-    }\r
-\r
-    /**\r
-     * Indicates that this action should occur by default on fire action event\r
-     * \r
-     * @return true if it is the default action event\r
-     * @deprecated this funcitionality is no longer supported use Form.setDefaultCommand() instead\r
-     */\r
-    public boolean isDefaultAction() {\r
-        return false;\r
-    }\r
-\r
-    /**\r
-     * Setting the default action event\r
-     * \r
-     * @param defaultAction the default action event\r
-     * @deprecated this funcitionality is no longer supported use Form.setDefaultCommand() instead\r
-     */\r
-    public void setDefaultAction(boolean defaultAction) {\r
-    }\r
-    \r
-    /**\r
-     * Indicates whether this command causes the dialog to dispose implicitly\r
-     */\r
-    void setDisposesDialog(boolean disposesDialog) {\r
-        this.disposesDialog = disposesDialog;\r
-    }\r
-    \r
-    /**\r
-     * Indicates whether this command causes the dialog to dispose implicitly\r
-     */\r
-    boolean isDisposesDialog() {\r
-        return disposesDialog;\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/Component.java b/core/java/com/sun/lwuit/Component.java
deleted file mode 100644 (file)
index 22448ee..0000000
+++ /dev/null
@@ -1,2044 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.geom.Rectangle;\r
-import com.sun.lwuit.geom.Dimension;\r
-import com.sun.lwuit.plaf.Style;\r
-import com.sun.lwuit.animations.Animation;\r
-import com.sun.lwuit.animations.Motion;\r
-import com.sun.lwuit.events.FocusListener;\r
-import com.sun.lwuit.events.StyleListener;\r
-import com.sun.lwuit.plaf.Border;\r
-import com.sun.lwuit.plaf.LookAndFeel;\r
-import com.sun.lwuit.plaf.UIManager;\r
-import java.util.Hashtable;\r
-import java.util.Vector;\r
-\r
-/**\r
- * Base class for all the widgets in the toolkit using the composite pattern in \r
- * a similar way to the AWT Container/Component relationship. All components are\r
- * potentially animated (need to be registered in {@link Display}). \r
- * \r
- * @author Chen Fishbein\r
- */\r
-public class Component implements Animation, StyleListener {\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the down key\r
-     */\r
-    private Component nextFocusDown;\r
-    private Component nextFocusUp;\r
-    /**\r
-     * Indicates whether component is enabled or disabled\r
-     */\r
-    private boolean enabled = true;\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the right key\r
-     */\r
-    private Component nextFocusRight;\r
-    private Component nextFocusLeft;\r
-    /**\r
-     * Baseline resize behavior constant used to properly align components. \r
-     * Indicates as the size of the component\r
-     * changes the baseline remains a fixed distance from the top of the\r
-     * component.\r
-     * @see #getBaselineResizeBehavior\r
-     */\r
-    public static final int BRB_CONSTANT_ASCENT = 1;\r
-    /**\r
-     * Baseline resize behavior constant used to properly align components. Indicates as the size of the component\r
-     * changes the baseline remains a fixed distance from the bottom of the \r
-     * component.\r
-     * @see #getBaselineResizeBehavior\r
-     */\r
-    public static final int BRB_CONSTANT_DESCENT = 2;\r
-    /**\r
-     * Baseline resize behavior constant used to properly align components. Indicates as the size of the component\r
-     * changes the baseline remains a fixed distance from the center of the\r
-     * component.\r
-     * @see #getBaselineResizeBehavior\r
-     */\r
-    public static final int BRB_CENTER_OFFSET = 3;\r
-    /**\r
-     * Baseline resize behavior constant used to properly align components. Indicates as the size of the component\r
-     * changes the baseline can not be determined using one of the other\r
-     * constants.\r
-     * @see #getBaselineResizeBehavior\r
-     */\r
-    public static final int BRB_OTHER = 4;\r
-    private boolean visible = true;\r
-    /**\r
-     * Used as an optimization to mark that this component is currently being\r
-     * used as a cell renderer\r
-     */\r
-    private boolean cellRenderer;\r
-    /**\r
-     * Indicates that this component is fixed into place and not affected by\r
-     * scrolling of the parent container. This is applicable for components such as\r
-     * menus etc...\r
-     */\r
-    private boolean fixedPosition;\r
-    private Rectangle bounds = new Rectangle(0, 0, new Dimension(0, 0));\r
-    private int scrollX;\r
-    private int scrollY;\r
-    private Dimension preferredSize;\r
-    private Style style;\r
-    private Container parent;\r
-    private boolean focused = false;\r
-    private boolean focusPainted = true;\r
-    private EventDispatcher focusListeners = new EventDispatcher();\r
-    private boolean handlesInput = false;\r
-    private boolean shouldCalcPreferredSize = true;\r
-    private boolean focusable = true;\r
-    private boolean isScrollVisible = true;\r
-    /**\r
-     * Indicates that moving through the component should work as an animation\r
-     */\r
-    private boolean smoothScrolling;\r
-    /**\r
-     * Animation speed in milliseconds allowing a developer to slow down or accelerate\r
-     * the smooth animation mode\r
-     */\r
-    private int animationSpeed;\r
-    private Motion animationMotion;\r
-    private Motion draggedMotion;\r
-    /**\r
-     * Allows us to flag a drag operation in action thus preventing the mouse pointer\r
-     * release event from occuring.\r
-     */\r
-    private boolean dragActivated;\r
-    private int initialScrollY = -1;\r
-    private int destScrollY = -1;\r
-    private int lastScrollY;\r
-    private int beforeLastScrollY;\r
-    private long[] lastTime = new long[2];\r
-    private int[] lastDragged = new int[2];\r
-    private int pLastDragged = 0;\r
-    /**\r
-     * Indicates if the component is in the initalized state, a component is initialized\r
-     * when its initComponent() method was invoked. The initMethod is invoked before showing the\r
-     * component to the user.\r
-     */\r
-    private boolean initialized;\r
-    /**\r
-     * Indicates a Component center alignment\r
-     */\r
-    public static final int CENTER = 4;\r
-    /** \r
-     * Box-orientation constant used to specify the top of a box.\r
-     */\r
-    public static final int TOP = 0;\r
-    /** \r
-     * Box-orientation constant used to specify the left side of a box.\r
-     */\r
-    public static final int LEFT = 1;\r
-    /** \r
-     * Box-orientation constant used to specify the bottom of a box.\r
-     */\r
-    public static final int BOTTOM = 2;\r
-    /** \r
-     * Box-orientation constant used to specify the right side of a box.\r
-     */\r
-    public static final int RIGHT = 3;\r
-    private Hashtable clientProperties;\r
-    private Rectangle dirtyRegion = null;\r
-\r
-    /** \r
-     * Creates a new instance of Component \r
-     */\r
-    protected Component() {\r
-        style = UIManager.getInstance().getComponentStyle(getUIID());\r
-        if (style != null) {\r
-            style.addStyleListener(this);\r
-            style.setBgPainter(new BGPainter());\r
-        }\r
-        LookAndFeel laf = UIManager.getInstance().getLookAndFeel();\r
-        animationSpeed = laf.getDefaultSmoothScrollingSpeed();\r
-        setSmoothScrolling(laf.isDefaultSmoothScrolling());\r
-    }\r
-\r
-    /**\r
-     * Returns the current component x location relatively to its parent container\r
-     * \r
-     * @return the current x coordinate of the components origin\r
-     */\r
-    public int getX() {\r
-        return bounds.getX();\r
-    }\r
-\r
-    /**\r
-     * Returns the component y location relatively to its parent container\r
-     * \r
-     * @return the current y coordinate of the components origin\r
-     */\r
-    public int getY() {\r
-        return bounds.getY();\r
-    }\r
-\r
-    /**\r
-     * Returns whether the component is visible or not\r
-     * \r
-     * @return true if component is visible; otherwise false \r
-     */\r
-    public boolean isVisible() {\r
-        return visible;\r
-    }\r
-\r
-    /**\r
-     * Client properties allow the association of meta-data with a component, this\r
-     * is useful for some applications that construct GUI's on the fly and need\r
-     * to track the connection between the UI and the data. \r
-     * \r
-     * @param key the key used for putClientProperty\r
-     * @return the value set to putClientProperty or null if no value is set to the property\r
-     */\r
-    public Object getClientProperty(String key) {\r
-        if (clientProperties == null) {\r
-            return null;\r
-        }\r
-        return clientProperties.get(key);\r
-    }\r
-\r
-    /**\r
-     * Client properties allow the association of meta-data with a component, this\r
-     * is useful for some applications that construct GUI's on the fly and need\r
-     * to track the connection between the UI and the data. Setting the value to\r
-     * null will remove the client property from the component.\r
-     * \r
-     * @param key arbitrary key for the property\r
-     * @param value the value assigned to the given client property\r
-     */\r
-    public void putClientProperty(String key, Object value) {\r
-        if (clientProperties == null) {\r
-            if (value == null) {\r
-                return;\r
-            }\r
-            clientProperties = new Hashtable();\r
-        }\r
-        if (value == null) {\r
-            clientProperties.remove(key);\r
-            if (clientProperties.size() == 0) {\r
-                clientProperties = null;\r
-            }\r
-        } else {\r
-            clientProperties.put(key, value);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * gets the Component dirty region\r
-     * \r
-     * @return\r
-     */\r
-    Rectangle getDirtyRegion() {\r
-        return dirtyRegion;\r
-    }\r
-\r
-    /**\r
-     * sets the Component dirty region\r
-     * \r
-     * @param dirty\r
-     */\r
-    void setDirtyRegion(Rectangle dirty) {\r
-        this.dirtyRegion = dirty;\r
-    }\r
-\r
-    /**\r
-     * Toggles visibility of the component\r
-     * \r
-     * @param visible true if component is visible; otherwise false \r
-     */\r
-    public void setVisible(boolean visible) {\r
-        this.visible = visible;\r
-    }\r
-\r
-    /**\r
-     * Returns the component width\r
-     * \r
-     * @return the component width\r
-     */\r
-    public int getWidth() {\r
-        return bounds.getSize().getWidth();\r
-    }\r
-\r
-    /**\r
-     * Returns the component height\r
-     * \r
-     * @return the component height\r
-     */\r
-    public int getHeight() {\r
-        return bounds.getSize().getHeight();\r
-    }\r
-\r
-    /**\r
-     * Sets the Component x location relative to the parent container, this method\r
-     * is exposed for the purpose of external layout managers and should not be invoked\r
-     * directly.\r
-     * \r
-     * @param x the current x coordinate of the components origin\r
-     */\r
-    public void setX(int x) {\r
-        bounds.setX(x);\r
-    }\r
-\r
-    /**\r
-     * Sets the Component y location relative to the parent container, this method\r
-     * is exposed for the purpose of external layout managers and should not be invoked\r
-     * directly.\r
-     * \r
-     * @param y the current y coordinate of the components origin\r
-     */\r
-    public void setY(int y) {\r
-        bounds.setY(y);\r
-    }\r
-\r
-    /**\r
-     * The baseline for the component text according to which it should be aligned\r
-     * with other components for best visual look.\r
-     * \r
-     * \r
-     * @param width the component width\r
-     * @param height the component height\r
-     * @return baseline value from the top of the component\r
-     */\r
-    public int getBaseline(int width, int height) {\r
-        return getHeight() - getStyle().getPadding(BOTTOM);\r
-    }\r
-\r
-    /**\r
-     * Returns a constant indicating how the baseline varies with the size\r
-     * of the component.\r
-     *\r
-     * @return one of BRB_CONSTANT_ASCENT, BRB_CONSTANT_DESCENT,\r
-     *         BRB_CENTER_OFFSET or BRB_OTHER\r
-     */\r
-    public int getBaselineResizeBehavior() {\r
-        return BRB_OTHER;\r
-    }\r
-\r
-    /**\r
-     * Sets the Component Preferred Size, there is no garuntee the Component will \r
-     * be sized at its Preferred Size. The final size of the component may be\r
-     * smaller than its preferred size or even larger than the size.<br>\r
-     * The Layout manager can take this value into consideration, but there is\r
-     * no guarantee or requirement.\r
-     * \r
-     * @param d the component dimension\r
-     */\r
-    public void setPreferredSize(Dimension d) {\r
-        preferredSize().setWidth(d.getWidth());\r
-        preferredSize().setHeight(d.getHeight());\r
-        sizeRequestedByUser = true;\r
-    }\r
-\r
-    /**\r
-     * Returns the Component Preferred Size, there is no garuntee the Component will \r
-     * be sized at its Preferred Size. The final size of the component may be\r
-     * smaller than its preferred size or even larger than the size.<br>\r
-     * The Layout manager can take this value into consideration, but there is\r
-     * no guarantee or requirement.\r
-     * \r
-     * @return the component preferred size\r
-     */\r
-    public Dimension getPreferredSize() {\r
-        return preferredSize();\r
-    }\r
-\r
-    /**\r
-     * Helper method to set the preferred width of the component.\r
-     * \r
-     * @param preferredW the preferred width of the component\r
-     * @see #setPreferredSize\r
-     * @deprecated see setPreferredSize this method won't behave as you expect!\r
-     */\r
-    public void setPreferredW(int preferredW) {\r
-        setPreferredSize(new Dimension(preferredW, getPreferredH()));\r
-    }\r
-\r
-    /**\r
-     * Helper method to set the preferred height of the component.\r
-     * \r
-     * @param preferredH the preferred height of the component\r
-     * @see #setPreferredSize\r
-     * @deprecated see setPreferredSize this method won't behave as you expect!\r
-     */\r
-    public void setPreferredH(int preferredH) {\r
-        setPreferredSize(new Dimension(getPreferredW(), preferredH));\r
-    }\r
-\r
-    /**\r
-     * Helper method to retrieve the preferred width of the component.\r
-     * \r
-     * @return preferred width of the component\r
-     * @see #getPreferredSize\r
-     */\r
-    public int getPreferredW() {\r
-        return getPreferredSize().getWidth();\r
-    }\r
-\r
-    /**\r
-     * Helper method to retrieve the preferred height of the component.\r
-     * \r
-     * @return preferred height of the component\r
-     * @see #getPreferredSize\r
-     */\r
-    public int getPreferredH() {\r
-        return getPreferredSize().getHeight();\r
-    }\r
-\r
-    /**\r
-     * Sets the Component width, this method is exposed for the purpose of \r
-     * external layout managers and should not be invoked directly.<br>\r
-     * If a user wishes to effect the component size setPreferredSize should\r
-     * be used.\r
-     * \r
-     * @param width the width of the component\r
-     * @see #setPreferredSize\r
-     */\r
-    public void setWidth(int width) {\r
-        bounds.getSize().setWidth(width);\r
-    }\r
-\r
-    /**\r
-     * Sets the Component height, this method is exposed for the purpose of \r
-     * external layout managers and should not be invoked directly.<br>\r
-     * If a user wishes to effect the component size setPreferredSize should\r
-     * be used.\r
-     * \r
-     * @param height the height of the component\r
-     * @see #setPreferredSize\r
-     */\r
-    public void setHeight(int height) {\r
-        bounds.getSize().setHeight(height);\r
-    }\r
-\r
-    /**\r
-     * Sets the Component size, this method is exposed for the purpose of \r
-     * external layout managers and should not be invoked directly.<br>\r
-     * If a user wishes to effect the component size setPreferredSize should\r
-     * be used.\r
-     * \r
-     * @param d the component dimension\r
-     * @see #setPreferredSize\r
-     */\r
-    public void setSize(Dimension d) {\r
-        Dimension d2 = bounds.getSize();\r
-        d2.setWidth(d.getWidth());\r
-        d2.setHeight(d.getHeight());\r
-    }\r
-\r
-    /**\r
-     * Unique identifier for a component, must be overriden for a component so\r
-     * a style can be applied to the component\r
-     * \r
-     * @return unique string identifying this component for the style sheet\r
-     */\r
-    protected String getUIID() {\r
-        return null;\r
-    }\r
-\r
-    /**\r
-     * Returns the container in which this component is contained\r
-     * \r
-     * @return the parent container in which this component is contained\r
-     */\r
-    public Container getParent() {\r
-        return parent;\r
-    }\r
-\r
-    /**\r
-     * Sets the Component Parent.\r
-     * This method should not be called by the user.\r
-     * \r
-     * @param parent the parent container\r
-     */\r
-    void setParent(Container parent) {\r
-        this.parent = parent;\r
-    }\r
-\r
-    /**\r
-     * Registers interest in receiving callbacks for focus gained events, a focus event \r
-     * is invoked when the component accepts the focus. A special case exists for the\r
-     * Form which sends a focus even for every selection within the form.\r
-     * \r
-     * @param l listener interface implementing the observable pattern\r
-     */\r
-    public void addFocusListener(FocusListener l) {\r
-        focusListeners.addListener(l);\r
-    }\r
-\r
-    /**\r
-     * Deregisters interest in receiving callbacks for focus gained events\r
-     * \r
-     * @param l listener interface implementing the observable pattern\r
-     */\r
-    public void removeFocusListener(FocusListener l) {\r
-        focusListeners.removeListener(l);\r
-    }\r
-\r
-    /**\r
-     * When working in 3 softbutton mode "fire" key (center softbutton) is sent to this method\r
-     * in order to allow 3 button devices to work properly. When overriding this method\r
-     * you should also override isSelectableInteraction to indicate that a command is placed\r
-     * appropriately on top of the fire key for 3 soft button phones. \r
-     */\r
-    protected void fireClicked() {\r
-    }\r
-\r
-    /**\r
-     * This method allows a component to indicate that it is interested in an "implicit" select\r
-     * command to appear in the "fire" button when 3 softbuttons are defined in a device.\r
-     */\r
-    protected boolean isSelectableInteraction() {\r
-        return false;\r
-    }\r
-\r
-    /**\r
-     * Fired when component gains focus\r
-     */\r
-    void fireFocusGained() {\r
-        fireFocusGained(this);\r
-    }\r
-\r
-    /**\r
-     * Fired when component lost focus\r
-     */\r
-    void fireFocusLost() {\r
-        fireFocusLost(this);\r
-    }\r
-\r
-    /**\r
-     * Fired when component gains focus\r
-     */\r
-    void fireFocusGained(Component cmp) {\r
-        if (cmp.isCellRenderer()) {\r
-            return;\r
-        }\r
-\r
-        focusListeners.fireFocus(cmp);\r
-        focusGainedInternal();\r
-        if (isSelectableInteraction()) {\r
-            Form f = getComponentForm();\r
-            if (f != null) {\r
-                f.addSelectCommand();\r
-            }\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Fired when component lost focus\r
-     */\r
-    void fireFocusLost(Component cmp) {\r
-        if (cmp.isCellRenderer()) {\r
-            return;\r
-        }\r
-        if (isSelectableInteraction()) {\r
-            Form f = getComponentForm();\r
-            if (f != null) {\r
-                f.removeSelectCommand();\r
-            }\r
-        }\r
-\r
-        focusListeners.fireFocus(cmp);\r
-        focusLostInternal();\r
-    }\r
-\r
-    /**\r
-     * This method allows us to detect an action event internally without \r
-     * implementing the action listener interface.\r
-     */\r
-    void fireActionEvent() {\r
-    }\r
-\r
-    /**\r
-     * This method is useful since it is not a part of the public API yet\r
-     * allows a component within this package to observe focus events\r
-     * without implementing a public interface or creating a new class\r
-     */\r
-    void focusGainedInternal() {\r
-    }\r
-\r
-    /**\r
-     * This method is useful since it is not a part of the public API yet\r
-     * allows a component within this package to observe focus events\r
-     * without implementing a public interface or creating a new class\r
-     */\r
-    void focusLostInternal() {\r
-    }\r
-\r
-    /**\r
-     * This method paints all the parents Components Background.\r
-     * \r
-     * @param g the graphics object\r
-     */\r
-    public void paintBackgrounds(Graphics g) {\r
-        Rectangle bounds = new Rectangle(getAbsoluteX(), getAbsoluteY(),\r
-                getWidth(), getHeight());\r
-        drawPainters(g, this.getParent(), this, bounds);\r
-    }\r
-\r
-    /**\r
-     * Returns the absolute X location based on the component hierarchy, this method\r
-     * calculates a location on the screen for the component rather than a relative\r
-     * location as returned by getX()\r
-     * \r
-     * @return the absolute x location of the component\r
-     * @see #getX\r
-     */\r
-    public int getAbsoluteX() {\r
-        int x = getX() - getScrollX();\r
-        Container parent = getParent();\r
-        if (parent != null) {\r
-            x += parent.getAbsoluteX();\r
-        }\r
-        return x;\r
-    }\r
-\r
-    /**\r
-     * Returns the absolute Y location based on the component hierarchy, this method\r
-     * calculates a location on the screen for the component rather than a relative\r
-     * location as returned by getX()\r
-     * \r
-     * @return the absolute y location of the component\r
-     * @see #getY\r
-     */\r
-    public int getAbsoluteY() {\r
-        int y = getY() - getScrollY();\r
-        Container parent = getParent();\r
-        if (parent != null) {\r
-            y += parent.getAbsoluteY();\r
-        }\r
-        return y;\r
-    }\r
-\r
-    /**\r
-     * This method performs the paint of the component internally including drawing\r
-     * the scrollbars and scrolling the component. This functionality is hidden\r
-     * from developers to prevent errors\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    final void paintInternal(Graphics g) {\r
-        paintInternal(g, true);\r
-    }\r
-\r
-    final void paintInternal(Graphics g, boolean paintIntersects) {\r
-        if (!isVisible()) {\r
-            return;\r
-        }\r
-        int oX = g.getClipX();\r
-        int oY = g.getClipY();\r
-        int oWidth = g.getClipWidth();\r
-        int oHeight = g.getClipHeight();\r
-        if (bounds.intersects(oX, oY, oWidth, oHeight)) {\r
-            g.clipRect(getX(), getY(), getWidth(), getHeight());\r
-            paintBackground(g);\r
-\r
-            if (isScrollable()) {\r
-                int scrollX = getScrollX();\r
-                int scrollY = getScrollY();\r
-                g.translate(-scrollX, -scrollY);\r
-                paint(g);\r
-                g.translate(scrollX, scrollY);\r
-                if (isScrollVisible) {\r
-                    paintScrollbars(g);\r
-                }\r
-            } else {\r
-                paint(g);\r
-            }\r
-            if (isBorderPainted()) {\r
-                paintBorder(g);\r
-            }\r
-\r
-            //paint all the intersecting Components above the Component\r
-            if (paintIntersects && parent != null) {\r
-                paintIntersectingComponentsAbove(g);\r
-            }\r
-\r
-            g.setClip(oX, oY, oWidth, oHeight);\r
-        }\r
-    }\r
-\r
-    private void paintIntersectingComponentsAbove(Graphics g) {\r
-        Container parent = getParent();\r
-        Component component = this;\r
-        Rectangle bounds = new Rectangle(getAbsoluteX(), getAbsoluteY(),\r
-                getWidth(), getHeight());\r
-        int tx = g.getTranslateX();\r
-        int ty = g.getTranslateY();\r
-\r
-        g.translate(-tx, -ty);\r
-        while (parent != null) {\r
-            g.translate(parent.getAbsoluteX() + parent.getScrollX(), \r
-                    parent.getAbsoluteY() + parent.getScrollY());\r
-            parent.paintIntersecting(g, component, bounds, true);\r
-            g.translate(-parent.getAbsoluteX() - parent.getScrollX(), \r
-                    -parent.getAbsoluteY() - parent.getScrollY());\r
-            component = parent;\r
-            parent = parent.getParent();\r
-        }\r
-        g.translate(tx, ty);\r
-\r
-    }\r
-\r
-    /**\r
-     * Paints the UI for the scrollbars on the component, this will be invoked only\r
-     * for scrollable components. This method invokes the appropriate X/Y versions\r
-     * to do all the work.\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    protected void paintScrollbars(Graphics g) {\r
-        if (isScrollableX()) {\r
-            paintScrollbarX(g);\r
-        }\r
-        if (isScrollableY()) {\r
-            paintScrollbarY(g);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Paints the UI for the scrollbar on the X axis, this method allows component\r
-     * subclasses to customize the look of a scrollbar\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    protected void paintScrollbarX(Graphics g) {\r
-        float offset = ((float) getScrollX()) / ((float) getPreferredW());\r
-        float block = ((float) getWidth()) / ((float) getPreferredW());\r
-        UIManager.getInstance().getLookAndFeel().drawHorizontalScroll(g, this, offset, block);\r
-    }\r
-\r
-    /**\r
-     * Paints the UI for the scrollbar on the Y axis, this method allows component\r
-     * subclasses to customize the look of a scrollbar\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    protected void paintScrollbarY(Graphics g) {\r
-        float offset = ((float) getScrollY()) / ((float) getPreferredH());\r
-        float block = ((float) getHeight()) / ((float) getPreferredH());\r
-        UIManager.getInstance().getLookAndFeel().drawVerticalScroll(g, this, offset, block);\r
-    }\r
-\r
-    /**\r
-     * Paints this component as a root by going to all the parent components and\r
-     * setting the absolute translation based on coordinates and scroll status.\r
-     * Restores translation when the painting is finished.\r
-     * \r
-     * @param g the graphics to paint this Component on\r
-     */\r
-    final public void paintComponent(Graphics g) {\r
-        paintComponent(g, true);\r
-    }\r
-\r
-    /**\r
-     * Paints this component as a root by going to all the parent components and\r
-     * setting the absolute translation based on coordinates and scroll status.\r
-     * Restores translation when the painting is finished.\r
-     * \r
-     * @param g the graphics to paint this Component on\r
-     * @param background if true paints all parents background\r
-     */\r
-    final public void paintComponent(Graphics g, boolean background) {\r
-        int clipX = g.getClipX();\r
-        int clipY = g.getClipX();\r
-        int clipW = g.getClipWidth();\r
-        int clipH = g.getClipHeight();\r
-        Container parent = getParent();\r
-        int translateX = 0;\r
-        int translateY = 0;\r
-        if (!isFixedPosition()) {\r
-            while (parent != null) {\r
-                translateX += parent.getX();\r
-                translateY += parent.getY();\r
-                //if (parent.isScrollable()) {\r
-                if (parent.isScrollableX()) {\r
-                    translateX -= parent.getScrollX();\r
-                }\r
-                if (parent.isScrollableY()) {\r
-                    translateY -= parent.getScrollY();\r
-                }\r
-                // since scrollability can translate everything... we should clip based on the\r
-                // current scroll\r
-                g.clipRect(parent.getAbsoluteX() + parent.getScrollX(), parent.getAbsoluteY() + parent.getScrollY(), parent.getWidth(), parent.getHeight());\r
-                //}\r
-                // restore the position for fixed components\r
-                if (parent.isFixedPosition()) {\r
-                    translateX = parent.getX();\r
-                    translateY = parent.getY();\r
-                    g.clipRect(parent.getX(), parent.getY(), parent.getWidth(), parent.getHeight());\r
-                    break;\r
-                }\r
-                parent = parent.getParent();\r
-            }\r
-        }\r
-        g.clipRect(translateX + getX(), translateY + getY(), getWidth(), getHeight());\r
-        if (background) {\r
-            paintBackgrounds(g);\r
-        }\r
-\r
-        g.translate(translateX, translateY);\r
-        paintInternal(g);\r
-        g.translate(-translateX, -translateY);\r
-\r
-        Form parentForm = getComponentForm();\r
-        if (parentForm != null) {\r
-            Painter glass = parentForm.getGlassPane();\r
-            if (glass != null) {\r
-                glass.paint(g, parentForm.getBounds());\r
-            }\r
-        }\r
-\r
-        g.setClip(clipX, clipY, clipW, clipH);\r
-    }\r
-\r
-    private void drawPainters(com.sun.lwuit.Graphics g, Component par, Component c,\r
-            Rectangle bounds) {\r
-        if (par == null) {\r
-            return;\r
-        } else {\r
-            if (par.getStyle().getBgTransparency() != ((byte) 0xFF)) {\r
-                drawPainters(g, par.getParent(), par, bounds);\r
-            }\r
-        }\r
-\r
-        int transX = par.getAbsoluteX() + par.getScrollX();\r
-        int transY = par.getAbsoluteY() + par.getScrollY();\r
-\r
-        g.translate(transX, transY);\r
-\r
-        ((Container) par).paintIntersecting(g, c, bounds, false);\r
-\r
-        if (par.isBorderPainted()) {\r
-            Border b = par.getBorder();\r
-            if (b != null && b.isBackgroundPainter()) {\r
-                g.translate(-par.getX(), -par.getY());\r
-                b.paintBorderBackground(g, par);\r
-                b.paint(g, par);\r
-                g.translate(par.getX() - transX, par.getY() - transY);\r
-            }\r
-        } else {\r
-            Painter p = par.getStyle().getBgPainter();\r
-            if (p != null) {\r
-                p.paint(g, new Rectangle(0, 0, par.getWidth(), par.getHeight()));\r
-            }\r
-            g.translate(-transX, -transY);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Normally returns getStyle().getBorder() but some subclasses might use this \r
-     * to programmatically replace the border in runtime e.g. for a pressed border effect\r
-     * \r
-     * @return the borde that is drawn according to the current component state\r
-     */\r
-    protected Border getBorder() {\r
-        Border b = getStyle().getBorder();\r
-        if (hasFocus()) {\r
-            if (b != null) {\r
-                return b.getFocusedInstance();\r
-            }\r
-            return b;\r
-        } else {\r
-            return b;\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Paints the background of the component, invoked with the clipping region\r
-     * and appropriate scroll translation.\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    protected void paintBackground(Graphics g) {\r
-        if (isBorderPainted()) {\r
-            Border b = getBorder();\r
-            if (b != null && b.isBackgroundPainter()) {\r
-                b.paintBorderBackground(g, this);\r
-                return;\r
-            }\r
-        }\r
-        if (getStyle().getBgPainter() != null) {\r
-            getStyle().getBgPainter().paint(g, new Rectangle(getX(), getY(), getWidth(), getHeight()));\r
-        }\r
-    }\r
-\r
-    /**\r
-     * This method paints the Component on the screen, it should be overriden\r
-     * by subclasses to perform custom drawing or invoke the UI API's to let\r
-     * the PLAF perform the rendering.\r
-     * \r
-     * @param g the component graphics\r
-     */\r
-    public void paint(Graphics g) {\r
-    }\r
-\r
-    /**\r
-     * Indicates whether the component should/could scroll by default a component\r
-     * is not scrollable.\r
-     * \r
-     * @return whether the component is scrollable\r
-     */\r
-    protected boolean isScrollable() {\r
-        return isScrollableX() || isScrollableY();\r
-    }\r
-\r
-    /**\r
-     * Indicates whether the component should/could scroll on the X axis\r
-     * \r
-     * @return whether the component is scrollable on the X axis\r
-     */\r
-    public boolean isScrollableX() {\r
-        return false;\r
-    }\r
-\r
-    /**\r
-     * Indicates whether the component should/could scroll on the Y axis\r
-     * \r
-     * @return whether the component is scrollable on the X axis\r
-     */\r
-    public boolean isScrollableY() {\r
-        return false;\r
-    }\r
-\r
-    /**\r
-     * Indicates the X position of the scrolling, this number is relative to the\r
-     * component position and so a position of 0 would indicate the x position\r
-     * of the component.\r
-     * \r
-     * @return the X position of the scrolling\r
-     */\r
-    public int getScrollX() {\r
-        return scrollX;\r
-    }\r
-\r
-    /**\r
-     * Indicates the Y position of the scrolling, this number is relative to the\r
-     * component position and so a position of 0 would indicate the x position\r
-     * of the component.\r
-     * \r
-     * @return the Y position of the scrolling\r
-     */\r
-    public int getScrollY() {\r
-        return scrollY;\r
-    }\r
-\r
-    /**\r
-     * Indicates the X position of the scrolling, this number is relative to the\r
-     * component position and so a position of 0 would indicate the x position\r
-     * of the component.\r
-     * \r
-     * @param scrollX the X position of the scrolling\r
-     */\r
-    protected void setScrollX(int scrollX) {\r
-        if (isScrollableX()) {\r
-            this.scrollX = scrollX;\r
-            repaint();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Indicates the X position of the scrolling, this number is relative to the\r
-     * component position and so a position of 0 would indicate the x position\r
-     * of the component.\r
-     * \r
-     * @param scrollY the Y position of the scrolling\r
-     */\r
-    protected void setScrollY(int scrollY) {\r
-        if (isScrollableY()) {\r
-            this.scrollY = scrollY;\r
-            repaint();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Returns the gap to be left for the bottom scrollbar on the X axis. This\r
-     * method is used by layout managers to determine the room they should\r
-     * leave for the scrollbar\r
-     * \r
-     * @return the gap to be left for the bottom scrollbar on the X axis\r
-     */\r
-    public int getBottomGap() {\r
-        if (isScrollableX()) {\r
-            return UIManager.getInstance().getLookAndFeel().getHorizontalScrollHeight();\r
-        }\r
-        return 0;\r
-    }\r
-\r
-    /**\r
-     * Returns the gap to be left for the side scrollbar on the Y axis. This\r
-     * method is used by layout managers to determine the room they should\r
-     * leave for the scrollbar. (note: side scrollbar rather than left scrollbar\r
-     * is used for a future version that would support bidi).\r
-     * \r
-     * @return the gap to be left for the side scrollbar on the Y axis\r
-     */\r
-    public int getSideGap() {\r
-        if (isScrollableY()) {\r
-            return UIManager.getInstance().getLookAndFeel().getVerticalScrollWidth();\r
-        }\r
-        return 0;\r
-    }\r
-\r
-    /**\r
-     * Retuns true if the given absolute cordinate is contained in the Component\r
-     * \r
-     * @param x the given absolute x cordinate\r
-     * @param y the given absolute y cordinate\r
-     * @return true if the given absolute cordinate is contained in the \r
-     * Component; otherwise false\r
-     */\r
-    public boolean contains(int x, int y) {\r
-        int absX = getAbsoluteX() + getScrollX();\r
-        int absY = getAbsoluteY() + getScrollY();\r
-        return (x >= absX && x < absX + getWidth() && y >= absY && y < absY + getHeight());\r
-    }\r
-\r
-    /**\r
-     * Calculates the preferred size based on component content. This method is\r
-     * invoked lazily by getPreferred size.\r
-     * \r
-     * @return the calculated preferred size based on component content\r
-     */\r
-    protected Dimension calcPreferredSize() {\r
-        Dimension d = new Dimension(0, 0);\r
-        return d;\r
-    }\r
-    private boolean sizeRequestedByUser = false;\r
-\r
-    private Dimension preferredSize() {\r
-\r
-        if (!sizeRequestedByUser && (shouldCalcPreferredSize || preferredSize == null)) {\r
-            shouldCalcPreferredSize = false;\r
-            preferredSize = calcPreferredSize();\r
-        }\r
-        return preferredSize;\r
-\r
-    }\r
-\r
-    /**\r
-     * Returns the component bounds which is sometimes more convenient than invoking\r
-     * getX/Y/Width/Height. Bounds are relative to parent container.<br>\r
-     * Changing values within the bounds can lead to unpredicted behavior.\r
-     * \r
-     * @see #getX\r
-     * @see #getY\r
-     * @return the component bounds\r
-     */\r
-    protected Rectangle getBounds() {\r
-        return bounds;\r
-    }\r
-\r
-    /**\r
-     * Returns true if this component can receive focus and is enabled\r
-     * \r
-     * @return true if this component can receive focus; otherwise false\r
-     */\r
-    public boolean isFocusable() {\r
-        return focusable && enabled && isVisible();\r
-    }\r
-\r
-    /**\r
-     * A simple setter to determine if this Component can get focused\r
-     * \r
-     * @param focusable indicate whether this component can get focused\r
-     */\r
-    public void setFocusable(boolean focusable) {\r
-        this.focusable = focusable;\r
-        Form p = getComponentForm();\r
-        if (p != null) {\r
-            p.clearFocusVectors();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Indicates the values within the component have changed and preferred \r
-     * size should be recalculated\r
-     * \r
-     * @param shouldCalcPreferredSize indicate whether this component need to \r
-     * recalculate his preferred size\r
-     */\r
-    protected void setShouldCalcPreferredSize(boolean shouldCalcPreferredSize) {\r
-        if (shouldCalcPreferredSize != this.shouldCalcPreferredSize) {\r
-            this.shouldCalcPreferredSize = shouldCalcPreferredSize;\r
-            if (shouldCalcPreferredSize && getParent() != null) {\r
-                this.shouldCalcPreferredSize = shouldCalcPreferredSize;\r
-                getParent().setShouldCalcPreferredSize(shouldCalcPreferredSize);\r
-            }\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Indicates whether focus should be drawn around the component or whether \r
-     * it will handle its own focus painting\r
-     * \r
-     * @return true if focus should be drawn around the component\r
-     * ; otherwise false\r
-     */\r
-    public boolean isFocusPainted() {\r
-        return focusPainted;\r
-    }\r
-\r
-    /**\r
-     * Indicates whether focus should be drawn around the component or whether \r
-     * it will handle its own focus painting\r
-     * \r
-     * @param focusPainted indicates whether focus should be drawn around the \r
-     * component\r
-     */\r
-    public void setFocusPainted(boolean focusPainted) {\r
-        this.focusPainted = focusPainted;\r
-    }\r
-\r
-    /**\r
-     * Prevents key events from being grabbed for focus traversal. E.g. a list component\r
-     * might use the arrow keys for internal navigation so it will switch this flag to\r
-     * true in order to prevent the focus manager from moving to the next component.\r
-     * \r
-     * @return true if key events are being used for focus traversal\r
-     * ; otherwise false\r
-     */\r
-    public boolean handlesInput() {\r
-        return handlesInput;\r
-    }\r
-\r
-    /**\r
-     * Prevents key events from being grabbed for focus traversal. E.g. a list component\r
-     * might use the arrow keys for internal navigation so it will switch this flag to\r
-     * true in order to prevent the focus manager from moving to the next component.\r
-     * \r
-     * @param handlesInput indicates whether key events can be grabbed for \r
-     * focus traversal\r
-     */\r
-    public void setHandlesInput(boolean handlesInput) {\r
-        this.handlesInput = handlesInput;\r
-    }\r
-\r
-    /**\r
-     * Returns true if the componet has focus\r
-     * \r
-     * @return true if the componet has focus; otherwise false\r
-     * @see #setFocus\r
-     */\r
-    public boolean hasFocus() {\r
-        return focused;\r
-    }\r
-\r
-    /**\r
-     * This flag doesn't really give focus, its a state that determines\r
-     * what colors from the Style should be used when painting the component.\r
-     * Actual focus is determined by the parent form\r
-     * \r
-     * @param focused sets the state that determines what colors from the \r
-     * Style should be used when painting a focused component\r
-     * \r
-     * @see #requestFocus\r
-     */\r
-    public void setFocus(boolean focused) {\r
-        this.focused = focused;\r
-    }\r
-\r
-    /**\r
-     * Returns the Component Form or null if this Component\r
-     * is not added yet to a form\r
-     * \r
-     * @return the Component Form\r
-     */\r
-    public Form getComponentForm() {\r
-        Form retVal = null;\r
-        Component parent = getParent();\r
-        if (parent != null) {\r
-            retVal = parent.getComponentForm();\r
-        }\r
-        return retVal;\r
-    }\r
-\r
-    /**\r
-     * Repaint the given component to the screen\r
-     * \r
-     * @param cmp the given component on the screen\r
-     */\r
-    void repaint(Component cmp) {\r
-        if (isCellRenderer() || cmp.getWidth() <= 0 || cmp.getHeight() <= 0) {\r
-            return;\r
-        }\r
-        // null parent repaint can happen when a component is removed and modified which\r
-        // is common ofr a popup\r
-        Component parent = getParent();\r
-        if (parent != null) {\r
-            parent.repaint(cmp);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Repaint this Component, the repaint call causes a callback of the paint\r
-     * method on the event dispatch thread.\r
-     * \r
-     * @see Display\r
-     */\r
-    public void repaint() {\r
-        dirtyRegion = null;\r
-        repaint(this);\r
-    }\r
-\r
-    public void repaint(int x, int y, int w, int h) {\r
-        if (dirtyRegion == null) {\r
-            dirtyRegion = new Rectangle(x, y, w, h);\r
-        } else {\r
-            Dimension size = dirtyRegion.getSize();\r
-\r
-            int x1 = Math.min(dirtyRegion.getX(), x);\r
-            int y1 = Math.min(dirtyRegion.getY(), y);\r
-\r
-            int x2 = Math.max(x + w, dirtyRegion.getX() + size.getWidth());\r
-            int y2 = Math.max(y + h, dirtyRegion.getY() + size.getHeight());\r
-\r
-            dirtyRegion.setX(x1);\r
-            dirtyRegion.setY(y1);\r
-            size.setWidth(x2 - x1);\r
-            size.setHeight(y2 - y1);\r
-\r
-        }\r
-        repaint(this);\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the key pressed event\r
-     * will call this method\r
-     * \r
-     * @param keyCode the key code value to indicate a physical key.\r
-     */\r
-    public void keyPressed(int keyCode) {\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the key released event\r
-     * will call this method\r
-     * \r
-     * @param keyCode the key code value to indicate a physical key.\r
-     */\r
-    public void keyReleased(int keyCode) {\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the key repeat event\r
-     * will call this method. Calls key pressed/released by default\r
-     * \r
-     * @param keyCode the key code value to indicate a physical key.\r
-     */\r
-    public void keyRepeated(int keyCode) {\r
-        int game = Display.getInstance().getGameAction(keyCode);\r
-        if (game == Display.GAME_DOWN || game == Display.GAME_UP || game == Display.GAME_LEFT || game == Display.GAME_RIGHT) {\r
-            keyPressed(keyCode);\r
-            keyReleased(keyCode);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Allows defining the physics for the animation motion behavior directly \r
-     * by plugging in an alternative motion object\r
-     * \r
-     * @param motion new motion object\r
-     */\r
-    private void setAnimationMotion(Motion motion) {\r
-        animationMotion = motion;\r
-    }\r
-\r
-    /**\r
-     * Allows defining the physics for the animation motion behavior directly \r
-     * by plugging in an alternative motion object\r
-     * \r
-     * @return the component motion object\r
-     */\r
-    private Motion getAnimationMotion() {\r
-        return animationMotion;\r
-    }\r
-\r
-    /**\r
-     * Scroll animation speed in milliseconds allowing a developer to slow down or accelerate\r
-     * the smooth animation mode\r
-     * \r
-     * @return scroll animation speed in milliseconds\r
-     */\r
-    public int getScrollAnimationSpeed() {\r
-        return animationSpeed;\r
-    }\r
-\r
-    /**\r
-     * Scroll animation speed in milliseconds allowing a developer to slow down or accelerate\r
-     * the smooth animation mode\r
-     * \r
-     * @param animationSpeed scroll animation speed in milliseconds\r
-     */\r
-    public void setScrollAnimationSpeed(int animationSpeed) {\r
-        this.animationSpeed = animationSpeed;\r
-    }\r
-\r
-    /**\r
-     * Indicates that scrolling through the component should work as an animation\r
-     * \r
-     * @return whether this component use smooth scrolling\r
-     */\r
-    public boolean isSmoothScrolling() {\r
-        return smoothScrolling;\r
-    }\r
-\r
-    /**\r
-     * Indicates that scrolling through the component should work as an animation\r
-     * \r
-     * @param smoothScrolling indicates if a component uses smooth scrolling\r
-     */\r
-    public void setSmoothScrolling(boolean smoothScrolling) {\r
-        this.smoothScrolling = smoothScrolling;\r
-        Form f = getComponentForm();\r
-        if (f != null) {\r
-            if (smoothScrolling) {\r
-                f.registerAnimated(this);\r
-            } else {\r
-                f.deregisterAnimated(this);\r
-            }\r
-        }\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the pointer dragged event\r
-     * will call this method\r
-     * \r
-     * @param x the pointer x coordinate\r
-     * @param y the pointer y coordinate\r
-     */\r
-    public void pointerDragged(int x, int y) {\r
-        if (isScrollable() && isSmoothScrolling()) {\r
-            int axisValue;\r
-            if (isScrollableY()) {\r
-                axisValue = y;\r
-            } else {\r
-                axisValue = x;\r
-            }\r
-\r
-            if (!dragActivated) {\r
-                dragActivated = true;\r
-                beforeLastScrollY = axisValue;\r
-                lastScrollY = axisValue;\r
-            }\r
-            //save time and locations to create velocity when the \r
-            //pointer is released\r
-            long currentTime = System.currentTimeMillis();\r
-            if (currentTime != lastTime[(pLastDragged + lastTime.length + 1) % lastTime.length]) {\r
-                lastTime[pLastDragged] = System.currentTimeMillis();\r
-                lastDragged[pLastDragged] = axisValue;\r
-                pLastDragged = (++pLastDragged) % lastTime.length;\r
-            }\r
-\r
-            beforeLastScrollY = lastScrollY;\r
-            lastScrollY = axisValue;\r
-\r
-            // we drag inversly to get a feel of grabbing a physical screen\r
-            // and pulling it in the reverse direction of the drag\r
-            if (isScrollableY()) {\r
-                int scroll = getScrollY() + (beforeLastScrollY - axisValue);\r
-                if (scroll >= 0 && scroll < getPreferredH() - getHeight()) {\r
-                    setScrollY(scroll);\r
-                }\r
-            } else {\r
-                int scroll = getScrollX() + (beforeLastScrollY - axisValue);\r
-                if (scroll >= 0 && scroll < getPreferredW() - getWidth()) {\r
-                    setScrollX(scroll);\r
-                }\r
-            }\r
-        } else {\r
-            //try to find a scrollable element until you reach the Form\r
-            Component parent = getParent();\r
-            if (!(parent instanceof Form)) {\r
-                parent.pointerDragged(x, y);\r
-            }\r
-        }\r
-    }\r
-\r
-    private void initScrollMotion() {\r
-        Motion m = Motion.createLinearMotion(initialScrollY, destScrollY, getScrollAnimationSpeed());\r
-        setAnimationMotion(m);\r
-        m.start();\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the pointer pressed event\r
-     * will call this method\r
-     * \r
-     * @param x the pointer x coordinate\r
-     * @param y the pointer y coordinate\r
-     */\r
-    public void pointerPressed(int x, int y) {\r
-//        if(draggedMotion != null){\r
-        draggedMotion = null;\r
-//        }\r
-    }\r
-\r
-    /**\r
-     * If this Component is focused, the pointer released event\r
-     * will call this method\r
-     * \r
-     * @param x the pointer x coordinate\r
-     * @param y the pointer y coordinate\r
-     */\r
-    public void pointerReleased(int x, int y) {\r
-        if (dragActivated) {\r
-            long currentTime = System.currentTimeMillis();\r
-\r
-            // replace x and y if this is an x scrolling container\r
-            if (!isScrollableY()) {\r
-                y = x;\r
-            }\r
-\r
-            if (currentTime != lastTime[(pLastDragged + lastTime.length + 1) % lastTime.length]) {\r
-                lastTime[pLastDragged] = System.currentTimeMillis();\r
-                lastDragged[pLastDragged] = y;\r
-                pLastDragged = (++pLastDragged) % lastTime.length;\r
-            }\r
-            float velocity = (float) (lastDragged[pLastDragged] - lastDragged[(pLastDragged + lastDragged.length + 1) % lastDragged.length]) / (lastTime[pLastDragged] - lastTime[(pLastDragged + lastTime.length + 1) % lastTime.length]);\r
-            velocity = velocity * -1;\r
-\r
-            if (isScrollableY()) {\r
-                draggedMotion = Motion.createFrictionMotion(scrollY, velocity, 0.0004f);\r
-            } else {\r
-                draggedMotion = Motion.createFrictionMotion(scrollX, velocity, 0.0004f);\r
-            }\r
-            draggedMotion.start();\r
-            dragActivated = false;\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Returns the Component Style allowing us to manipulate the look of the \r
-     * component\r
-     * \r
-     * @return the component Style object\r
-     */\r
-    public Style getStyle() {\r
-        return style;\r
-    }\r
-\r
-    /**\r
-     * Changes the Component Style by replacing the Component Style with the given Style\r
-     * \r
-     * @param style the component Style object\r
-     */\r
-    public void setStyle(Style style) {\r
-        if (this.style != null) {\r
-            this.style.removeStyleListener(this);\r
-        }\r
-        this.style = style;\r
-        this.style.addStyleListener(this);\r
-        if (this.style.getBgPainter() == null) {\r
-            this.style.setBgPainter(new BGPainter());\r
-        }\r
-        setShouldCalcPreferredSize(true);\r
-        checkAnimation();\r
-    }\r
-\r
-    /**\r
-     * Changes the current component to the focused component, will work only\r
-     * for a component that belongs to a parent form.\r
-     */\r
-    public void requestFocus() {\r
-        Form rootForm = getComponentForm();\r
-        if (rootForm != null) {\r
-            rootForm.requestFocus(this);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Overriden to return a useful value for debugging purposes\r
-     * \r
-     * @return a string representation of this component\r
-     */\r
-    public String toString() {\r
-        String className = getClass().getName();\r
-        className = className.substring(className.lastIndexOf('.') + 1);\r
-        return className + "[" + paramString() + "]";\r
-    }\r
-\r
-    /**\r
-     * Returns a string representing the state of this component. This \r
-     * method is intended to be used only for debugging purposes, and the \r
-     * content and format of the returned string may vary between \r
-     * implementations. The returned string may be empty but may not be \r
-     * <code>null</code>.\r
-     * \r
-     * @return  a string representation of this component's state\r
-     */\r
-    protected String paramString() {\r
-        return "x=" + getX() + " y=" + getY() + " width=" + getWidth() + " height=" + getHeight();\r
-    }\r
-\r
-    /**\r
-     * Makes sure the component is up to date with the current style object\r
-     */\r
-    public void refreshTheme() {\r
-        refreshTheme(getUIID());\r
-    }\r
-\r
-    /**\r
-     * Makes sure the component is up to date with the given UIID\r
-     * \r
-     * @param id The Style Id to update the Component with\r
-     */\r
-    protected void refreshTheme(String id) {\r
-        if (style.isModified()) {\r
-            style.merge(UIManager.getInstance().getComponentStyle(id));\r
-        } else {\r
-            setStyle(UIManager.getInstance().getComponentStyle(id));\r
-        }\r
-        checkAnimation();\r
-        UIManager.getInstance().getLookAndFeel().bind(this);\r
-    }\r
-\r
-    /**\r
-     * Internal method indicating whether we are in the middle of a drag\r
-     * \r
-     * @return true if we are in the middle of a drag; otherwise false\r
-     */\r
-    boolean isDragActivated() {\r
-        return dragActivated;\r
-    }\r
-\r
-    void checkAnimation() {\r
-        Image bgImage = getStyle().getBgImage();\r
-        if (bgImage != null && bgImage.isAnimation()) {\r
-            Form parent = getComponentForm();\r
-\r
-            if (parent != null) {\r
-                parent.registerAnimated(this);\r
-            }\r
-        }\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public boolean animate() {\r
-        Image bgImage = getStyle().getBgImage();\r
-        boolean animateBackground = bgImage != null && bgImage.isAnimation() && ((Animation) bgImage).animate();\r
-        Motion m = getAnimationMotion();\r
-        //preform regular scrolling\r
-        if (m != null && destScrollY != -1 && destScrollY != getScrollY()) {\r
-            // change the variable directly for efficiency both in removing redundant\r
-            // repaints and scroll checks\r
-            scrollY = m.getValue();\r
-\r
-            if (destScrollY == scrollY) {\r
-                destScrollY = -1;\r
-            }\r
-            return true;\r
-        }\r
-\r
-        //preform the dragging motion if exists\r
-        if (draggedMotion != null && !draggedMotion.isFinished()) {\r
-            // change the variable directly for efficiency both in removing redundant\r
-            // repaints and scroll checks\r
-            int dragVal = draggedMotion.getValue();\r
-            if (isScrollableY()) {\r
-                if (dragVal >= 0 && dragVal <= (getPreferredH() - getHeight())) {\r
-                    scrollY = dragVal;\r
-                    return true;\r
-                }\r
-            } else {\r
-                if (dragVal >= 0 && dragVal <= (getPreferredW() - getWidth())) {\r
-                    scrollX = dragVal;\r
-                    return true;\r
-                }\r
-            }\r
-        }\r
-        if (animateBackground && bgImage instanceof StaticAnimation) {\r
-            Rectangle dirty = ((StaticAnimation) bgImage).getDirtyRegion();\r
-            if (dirty != null) {\r
-                dirty.setX(getAbsoluteX());\r
-                dirty.setY(getAbsoluteY() + dirty.getY());\r
-            }\r
-            setDirtyRegion(dirty);\r
-        }\r
-        return animateBackground;\r
-    }\r
-\r
-    /**\r
-     * Indicates that this component is fixed into place and not affected by\r
-     * scrolling of the parent container. This is applicable for components such as\r
-     * menus etc...\r
-     * \r
-     * @return true is this component is fixed into place and not affected by\r
-     * scrolling of the parent container; othewise false\r
-     */\r
-    boolean isFixedPosition() {\r
-        return fixedPosition;\r
-    }\r
-\r
-    /**\r
-     * Indicates that this component is fixed into place and not affected by\r
-     * scrolling of the parent container. This is applicable for components such as\r
-     * menus etc...\r
-     * \r
-     * @param fixedPosition whether this component is fixed into place and not \r
-     * affected by scrolling of the parent container\r
-     */\r
-    void setFixedPosition(boolean fixedPosition) {\r
-        this.fixedPosition = fixedPosition;\r
-    }\r
-\r
-    /**\r
-     * Makes sure the component is visible in the scroll if this container \r
-     * is scrollable\r
-     * \r
-     * @param rect the rectangle that need to be visible\r
-     * @param coordinateSpace the component according to whose coordinates \r
-     * rect is defined. Rect's x/y are relative to that component \r
-     * (they are not absolute).\r
-     */\r
-    protected void scrollRectToVisible(Rectangle rect, Component coordinateSpace) {\r
-        if (isScrollable()) {\r
-\r
-            int scrollPosition = getScrollY();\r
-            int w = getWidth() - getStyle().getPadding(LEFT) - getStyle().getPadding(RIGHT);\r
-            int h = getHeight() - getStyle().getPadding(TOP) - getStyle().getPadding(BOTTOM);\r
-\r
-            Rectangle view = new Rectangle(getScrollX(), getScrollY(), w, h);\r
-\r
-            int relativeX = rect.getX();\r
-            int relativeY = rect.getY();\r
-\r
-            // component needs to be in absolute coordinates...\r
-            Container parent = null;\r
-            if (coordinateSpace != null) {\r
-                parent = coordinateSpace.getParent();\r
-            }\r
-            if (parent == this) {\r
-                if (view.contains(rect)) {\r
-                    return;\r
-                }\r
-            } else {\r
-                while (parent != this) {\r
-                    // mostly a special case for list\r
-                    if (parent == null) {\r
-                        relativeX = rect.getX();\r
-                        relativeY = rect.getY();\r
-                        break;\r
-                    }\r
-                    relativeX += parent.getX();\r
-                    relativeY += parent.getY();\r
-                    parent = parent.getParent();\r
-                }\r
-                if (view.contains(relativeX, relativeY, rect.getSize().getWidth(), rect.getSize().getHeight())) {\r
-                    return;\r
-                }\r
-            }\r
-            if (getScrollX() > relativeX) {\r
-                setScrollX(relativeX);\r
-            }\r
-            if (getScrollY() > relativeY) {\r
-                scrollPosition = relativeY;\r
-            }\r
-            int rightX = relativeX + rect.getSize().getWidth();\r
-            int bottomY = relativeY + rect.getSize().getHeight();\r
-            if (getScrollX() + w < rightX) {\r
-                setScrollX(getScrollX() + (rightX - (getScrollX() + w)));\r
-            } else {\r
-                if (getScrollX() > relativeX) {\r
-                    setScrollX(relativeX);\r
-                }\r
-            }\r
-            if (getScrollY() + h < bottomY) {\r
-                scrollPosition = getScrollY() + (bottomY - (getScrollY() + h));\r
-            } else {\r
-                if (getScrollY() > relativeY) {\r
-                    scrollPosition = relativeY;\r
-                }\r
-            }\r
-            if (isSmoothScrolling()) {\r
-                initialScrollY = getScrollY();\r
-                destScrollY = scrollPosition;\r
-                initScrollMotion();\r
-            } else {\r
-                setScrollY(scrollPosition);\r
-            }\r
-            repaint();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Indicates whether a border should be painted\r
-     * \r
-     * @param b true would cause the paintBorder method to be invoked false\r
-     * allows us to hide the border of the component without deriving the class\r
-     * @deprecated use getStyle().setBorder() to null to disable borders or install\r
-     * a different border\r
-     */\r
-    public void setBorderPainted(boolean b) {\r
-        if (!b) {\r
-            getStyle().setBorder(null);\r
-        } else {\r
-            getStyle().setBorder(Border.getDefaultBorder());\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Indicates whether a border should be painted\r
-     *\r
-     * @return if the border will be painted\r
-     * @deprecated use getStyle().getBorder() != null \r
-     */\r
-    public boolean isBorderPainted() {\r
-        return getStyle().getBorder() != null;\r
-    }\r
-\r
-    /**\r
-     * Draws the component border if such a border exists. The border unlike the content\r
-     * of the component will not be affected by scrolling for a scrollable component.\r
-     * \r
-     * @param g graphics context on which the border is painted\r
-     */\r
-    protected void paintBorder(Graphics g) {\r
-        Border b = getBorder();\r
-        if (b != null) {\r
-            if (isFocusPainted() && hasFocus()) {\r
-                g.setColor(getStyle().getFgSelectionColor());\r
-            } else {\r
-                g.setColor(getStyle().getFgColor());\r
-            }\r
-            b.paint(g, this);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Used as an optimization to mark that this component is currently being\r
-     * used as a cell renderer\r
-     * \r
-     * @param cellRenderer indicate whether this component is currently being\r
-     * used as a cell renderer\r
-     */\r
-    public void setCellRenderer(boolean cellRenderer) {\r
-        this.cellRenderer = cellRenderer;\r
-    }\r
-\r
-    /**\r
-     * Used as an optimization to mark that this component is currently being\r
-     * used as a cell renderer\r
-     * \r
-     * @return rtue is this component is currently being used as a cell renderer\r
-     */\r
-    boolean isCellRenderer() {\r
-        return cellRenderer;\r
-    }\r
-\r
-    /**\r
-     * Indicate whether this component scroll is visible\r
-     * \r
-     * @return true is this component scroll is visible; otherwise false\r
-     */\r
-    public boolean isScrollVisible() {\r
-        return isScrollVisible;\r
-    }\r
-\r
-    /**\r
-     * Set whether this component scroll is visible\r
-     * \r
-     * @param isScrollVisible Indicate whether this component scroll is visible\r
-     */\r
-    public void setIsScrollVisible(boolean isScrollVisible) {\r
-        this.isScrollVisible = isScrollVisible;\r
-    }\r
-\r
-    /**\r
-     * Invoked internally to initialize and bind the component\r
-     */\r
-    void initComponentImpl() {\r
-        if (!initialized) {\r
-            initialized = true;\r
-            UIManager.getInstance().getLookAndFeel().bind(this);\r
-            checkAnimation();\r
-            initComponent();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Cleansup the initialization flags in the hierachy, notice that paint calls might\r
-     * still occur after deinitilization mostly to perform transitions etc.\r
-     * <p>However interactivity, animation and event tracking code can and probably\r
-     * should be removed by this method.\r
-     */\r
-    void deinitializeImpl() {\r
-        if (isInitialized()) {\r
-            Form f = getComponentForm();\r
-            if (f != null) {\r
-                f.deregisterAnimated(this);\r
-            }\r
-            setInitialized(false);\r
-            setDirtyRegion(null);\r
-            deinitialize();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Invoked to indicate that the component initialization is being reversed\r
-     * since the component was detached from the container hierarchy. This allows\r
-     * the component to deregister animators and cleanup after itself. This\r
-     * method is the opposite of the initComponent() method.\r
-     */\r
-    protected void deinitialize() {\r
-    }\r
-\r
-    /**\r
-     * Allows subclasses to bind functionality that relies on fully initialized and\r
-     * "ready for action" component state\r
-     */\r
-    protected void initComponent() {\r
-    }\r
-\r
-    /**\r
-     * Indicates if the component is in the initalized state, a component is initialized\r
-     * when its initComponent() method was invoked. The initMethod is invoked before showing the\r
-     * component to the user.\r
-     * \r
-     * @return true if the component is in the initalized state\r
-     */\r
-    protected boolean isInitialized() {\r
-        return initialized;\r
-    }\r
-\r
-    /**\r
-     * Indicates if the component is in the initalized state, a component is initialized\r
-     * when its initComponent() method was invoked. The initMethod is invoked before showing the\r
-     * component to the user.\r
-     * \r
-     * @param initialized Indicates if the component is in the initalized state\r
-     */\r
-    protected void setInitialized(boolean initialized) {\r
-        this.initialized = initialized;\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void styleChanged(String propertyName, Style source) {\r
-        //changing the Font, Padding, Margin may casue the size of the Component to Change\r
-        //therefore we turn on the shouldCalcPreferredSize flag\r
-        if (!shouldCalcPreferredSize &&\r
-                propertyName.equals(Style.FONT) ||\r
-                propertyName.equals(Style.MARGIN) ||\r
-                propertyName.equals(Style.PADDING)) {\r
-            setShouldCalcPreferredSize(true);\r
-            Container parent = getParent();\r
-            if (parent != null) {\r
-                parent.revalidate();\r
-            }\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the down key\r
-     */\r
-    public Component getNextFocusDown() {\r
-        return nextFocusDown;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the down key\r
-     */\r
-    public void setNextFocusDown(Component nextFocusDown) {\r
-        this.nextFocusDown = nextFocusDown;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the up key. \r
-     */\r
-    public Component getNextFocusUp() {\r
-        return nextFocusUp;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the up key, this method doesn't affect the generl focus beavior.\r
-     */\r
-    public void setNextFocusUp(Component nextFocusUp) {\r
-        this.nextFocusUp = nextFocusUp;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the left key. \r
-     */\r
-    public Component getNextFocusLeft() {\r
-        return nextFocusLeft;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the left key, this method doesn't affect the generl focus beavior.\r
-     */\r
-    public void setNextFocusLeft(Component nextFocusLeft) {\r
-        this.nextFocusLeft = nextFocusLeft;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the right key\r
-     */\r
-    public Component getNextFocusRight() {\r
-        return nextFocusRight;\r
-    }\r
-\r
-    /**\r
-     * Allows us to determine which component will receive focus next when travering \r
-     * with the right key\r
-     */\r
-    public void setNextFocusRight(Component nextFocusRight) {\r
-        this.nextFocusRight = nextFocusRight;\r
-    }\r
-\r
-    /**\r
-     * Indicates whether component is enabled or disabled thus allowing us to prevent\r
-     * a component from receiving input events and indicate so visually\r
-     */\r
-    public boolean isEnabled() {\r
-        return enabled;\r
-    }\r
-\r
-    /**\r
-     * Used to reduce coupling between the TextArea component and display/implementation\r
-     * classes thus reduce the size of the hello world MIDlet\r
-     * \r
-     * @param text text after editing is completed\r
-     */\r
-    void onEditComplete(String text) {\r
-    }\r
-\r
-    /**\r
-     * Indicates whether component is enabled or disabled thus allowing us to prevent\r
-     * a component from receiving input events and indicate so visually\r
-     */\r
-    public void setEnabled(boolean enabled) {\r
-        this.enabled = enabled;\r
-        Form f = getComponentForm();\r
-        if (f != null) {\r
-            f.clearFocusVectors();\r
-            repaint();\r
-        }\r
-    }\r
-\r
-    class BGPainter implements Painter {\r
-\r
-        private Form parent;\r
-        private Form previousTint;\r
-        private boolean ignorCoordinates;\r
-        private Painter painter;\r
-\r
-        public BGPainter() {\r
-        }\r
-\r
-        public BGPainter(Form parent, Painter p) {\r
-            this.painter = p;\r
-            this.parent = parent;\r
-        }\r
-\r
-        public void setIgnorCoordinates(boolean ignorCoordinates) {\r
-            this.ignorCoordinates = ignorCoordinates;\r
-        }\r
-\r
-        public void setPreviousForm(Form previous) {\r
-            previousTint = previous;\r
-        }\r
-\r
-        public void paint(Graphics g, Rectangle rect) {\r
-            if (painter != null) {\r
-                if (previousTint != null) {\r
-                    previousTint.paint(g);\r
-                }\r
-                Dimension d = rect.getSize();\r
-                int width = d.getWidth();\r
-                int height = d.getHeight();\r
-                int x = rect.getX();\r
-                int y = rect.getY();\r
-\r
-                if (ignorCoordinates) {\r
-                    // this is a special case for dialogs since they are "pushed" to\r
-                    // a position in the screen and can't draw behind their title\r
-                    // we need to still "pretend" that they own the screen... \r
-                    x = 0;\r
-                    y = 0;\r
-                    width = parent.getWidth();\r
-                    height = parent.getHeight();\r
-                    int transY = g.getTranslateY();\r
-                    g.translate(0, -transY);\r
-\r
-                    painter.paint(g, new Rectangle(x, y, width, height));\r
-                    g.translate(0, transY);\r
-                } else {\r
-                    painter.paint(g, new Rectangle(x, y, width, height));\r
-                }\r
-            } else {\r
-                Style s = getStyle();\r
-                int x = rect.getX();\r
-                int y = rect.getY();\r
-                int width = rect.getSize().getWidth();\r
-                int height = rect.getSize().getHeight();\r
-                if (width <= 0 || height <= 0) {\r
-                    return;\r
-                }\r
-                Image bgImage = s.getBgImage();\r
-                if (bgImage == null) {\r
-                    if (hasFocus() && isFocusPainted()) {\r
-                        g.setColor(s.getBgSelectionColor());\r
-                        g.fillRect(x, y, width, height, s.getBgTransparency());\r
-                    } else {\r
-                        g.setColor(s.getBgColor());\r
-                        g.fillRect(x, y, width, height, s.getBgTransparency());\r
-                    }\r
-                } else {\r
-                    if (getStyle().isScaleImage()) {\r
-                        if (bgImage.getWidth() != width || bgImage.getHeight() != height) {\r
-                            bgImage = bgImage.scaled(width, height);\r
-                            s.setBgImage(bgImage, true);\r
-                        }\r
-                    } else {\r
-                        int iW = bgImage.getWidth();\r
-                        int iH = bgImage.getHeight();\r
-                        for (int xPos = 0; xPos < width; xPos += iW) {\r
-                            for (int yPos = 0; yPos < height; yPos += iH) {\r
-                                g.drawImage(s.getBgImage(), x + xPos, y + yPos);\r
-                            }\r
-                        }\r
-                        return;\r
-                    }\r
-                    g.drawImage(s.getBgImage(), x, y);\r
-                }\r
-            }\r
-        }\r
-    }\r
-}\r
diff --git a/core/java/com/sun/lwuit/Container.java b/core/java/com/sun/lwuit/Container.java
deleted file mode 100644 (file)
index 1e5039c..0000000
+++ /dev/null
@@ -1,758 +0,0 @@
-/*\r
- * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.\r
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\r
- *\r
- * This code is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License version 2 only, as\r
- * published by the Free Software Foundation.  Sun designates this\r
- * particular file as subject to the "Classpath" exception as provided\r
- * by Sun in the LICENSE file that accompanied this code.\r
- *\r
- * This code is distributed in the hope that it will be useful, but WITHOUT\r
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * version 2 for more details (a copy is included in the LICENSE file that\r
- * accompanied this code).\r
- *\r
- * You should have received a copy of the GNU General Public License version\r
- * 2 along with this work; if not, write to the Free Software Foundation,\r
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,\r
- * CA 95054 USA or visit www.sun.com if you need additional information or\r
- * have any questions.\r
- */\r
-package com.sun.lwuit;\r
-\r
-import com.sun.lwuit.animations.Animation;\r
-import com.sun.lwuit.animations.Transition;\r
-import com.sun.lwuit.layouts.BorderLayout;\r
-import com.sun.lwuit.layouts.FlowLayout;\r
-import com.sun.lwuit.layouts.Layout;\r
-import com.sun.lwuit.plaf.UIManager;\r
-import java.util.Enumeration;\r
-import com.sun.lwuit.geom.Dimension;\r
-import com.sun.lwuit.geom.Rectangle;\r
-import java.util.Vector;\r
-\r
-/**\r
- * A composite pattern with {@link Component}, allows nesting and arranging multiple\r
- * components using a pluggable layout manager architecture. Containers can be nested\r
- * one within the other to form elaborate UI's.\r
- *\r
- * @see com.sun.lwuit.layouts\r
- * @see Component\r
- * @author Chen Fishbein\r
- */\r
-public class Container extends Component {\r
-\r
-    private Layout layout;\r
-    private java.util.Vector components = new java.util.Vector();\r
-    private boolean shouldLayout = true;\r
-    private boolean scrollableX;\r
-    private boolean scrollableY;\r
-\r
-    /**\r
-     * Constructs a new Container with a new layout manager.\r
-     * \r
-     * @param layout the specified layout manager\r
-     */\r
-    public Container(Layout layout) {\r
-        super();\r
-        this.layout = layout;\r
-        setFocusable(false);\r
-    }\r
-\r
-    /** \r
-     * Constructs a new Container, with a {@link FlowLayout}. \r
-     */\r
-    public Container() {\r
-        this(new FlowLayout());\r
-    }\r
-\r
-    /**\r
-     * Returns the layout manager responsible for arranging this container\r
-     * \r
-     * @return the container layout manager\r
-     */\r
-    public Layout getLayout() {\r
-        return layout;\r
-    }\r
-\r
-    /**\r
-     * Sets the layout manager responsible for arranging this container\r
-     * \r
-     * @param layout the specified layout manager\r
-     */\r
-    public void setLayout(Layout layout) {\r
-        this.layout = layout;\r
-    }\r
-\r
-    /**\r
-     * Same as setShouldCalcPreferredSize(true) but made accessible for \r
-     * layout managers\r
-     */\r
-    public void invalidate() {\r
-        setShouldCalcPreferredSize(true);\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    protected void setShouldCalcPreferredSize(boolean shouldCalcPreferredSize) {\r
-        super.setShouldCalcPreferredSize(shouldCalcPreferredSize);\r
-        shouldLayout = shouldCalcPreferredSize;\r
-        Enumeration enums = components.elements();\r
-        if (shouldLayout) {\r
-            while (enums.hasMoreElements()) {\r
-                Component cmp = (Component) enums.nextElement();\r
-                if (cmp instanceof Container) {\r
-                    ((Container) cmp).setShouldCalcPreferredSize(shouldCalcPreferredSize);\r
-                }\r
-            }\r
-        }\r
-        Form f = getComponentForm();\r
-        if (f != null) {\r
-            f.clearFocusVectors();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Returns the width for layout manager purposes, this takes scrolling\r
-     * into consideration unlike the getWidth method.\r
-     * \r
-     * @return the layout width\r
-     */\r
-    public int getLayoutWidth() {\r
-        if (isScrollableX()) {\r
-            int scrollH = UIManager.getInstance().getLookAndFeel().getHorizontalScrollHeight();\r
-            return Math.max(getWidth() + scrollH, getPreferredW() + scrollH);\r
-        } else {\r
-            Container parent = getScrollableParent();\r
-            if (parent != null && parent.isScrollableX()) {\r
-                return Math.max(getWidth(), getPreferredW());\r
-            }\r
-            int width = getWidth();\r
-            if (width <= 0) {\r
-                return getPreferredW();\r
-            }\r
-            return width;\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Returns the height for layout manager purposes, this takes scrolling\r
-     * into consideration unlike the getWidth method.\r
-     * \r
-     * @return the layout height\r
-     */\r
-    public int getLayoutHeight() {\r
-        if (isScrollableY()) {\r
-            int scrollW = UIManager.getInstance().getLookAndFeel().getVerticalScrollWidth();\r
-            return Math.max(getHeight() + scrollW, getPreferredH() + scrollW);\r
-        } else {\r
-            Container parent = getScrollableParent();\r
-            if (parent != null && parent.isScrollableY()) {\r
-                return Math.max(getHeight(), getPreferredH());\r
-            }\r
-            int height = getHeight();\r
-            if (height <= 1) {\r
-                return getPreferredH();\r
-            }\r
-            return height;\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Returns a parent container that is scrollable or null if no parent is \r
-     * scrollable.\r
-     * \r
-     * @return a parent container that is scrollable or null if no parent is \r
-     * scrollable.\r
-     */\r
-    private Container getScrollableParent() {\r
-        Container parent = getParent();\r
-        while (parent != null) {\r
-            if (parent.isScrollable()) {\r
-                return parent;\r
-            }\r
-            parent = parent.getParent();\r
-        }\r
-        return null;\r
-    }\r
-\r
-    /**\r
-     * Adds a Component to the Container\r
-     * \r
-     * @param cmp the component to be added\r
-     */\r
-    public void addComponent(Component cmp) {\r
-        // helper check for a common mistake...\r
-        if (layout instanceof BorderLayout) {\r
-            throw new IllegalArgumentException("Cannot add component to BorderLayout Container without constraint parameter");\r
-        }\r
-\r
-        insertComponentAt(components.size(), cmp);\r
-    }\r
-\r
-    /**\r
-     * Adds a Component to the Container\r
-     * \r
-     * @param constraints this method is useful when the Layout requires a constraint\r
-     * such as the BorderLayout.\r
-     * In this case you need to specify an additional data when you add a Component,\r
-     * such as "CENTER", "NORTH"...\r
-     *\r
-     * @param cmp component to add\r
-     */\r
-    public void addComponent(Object constraints, Component cmp) {\r
-        layout.addLayoutComponent(constraints, cmp, this);\r
-        insertComponentAt(components.size(), cmp);\r
-    }\r
-\r
-    private void insertComponentAt(int index, Component cmp) {\r
-        if (cmp.getParent() != null) {\r
-            throw new IllegalArgumentException("Component is already contained in Container: " + cmp.getParent());\r
-        }\r
-        if (cmp instanceof Form) {\r
-            throw new IllegalArgumentException("A form cannot be added to a container");\r
-        }\r
-        cmp.setParent(this);\r
-        components.insertElementAt(cmp, index);\r
-        setShouldCalcPreferredSize(true);\r
-        if (isInitialized()) {\r
-            cmp.initComponentImpl();\r
-        }\r
-        Form f = getComponentForm();\r
-        if (f != null) {\r
-            f.clearFocusVectors();\r
-        }\r
-    //repaint();\r
-    }\r
-\r
-    /**\r
-     * This method adds the Component at a specific index location in the Conatiner\r
-     * Components array.\r
-     * \r
-     * @param index location to insert the Component\r
-     * @param cmp the Component to add\r
-     * @throws ArrayIndexOutOfBoundsException if index is out of bounds\r
-     * @throws IllegalArgumentException if Component is already contained or\r
-     * the cmp is a Form Component\r
-     */\r
-    public void addComponent(int index, Component cmp) {\r
-        insertComponentAt(index, cmp);\r
-    }\r
-\r
-    /**\r
-     * This method replaces the current Component with the next Component.\r
-     * Current Component must be contained in this Container.\r
-     * This method return immediately.\r
-     * \r
-     * @param current a Component to remove from the Container\r
-     * @param next a Component that replaces the current Component\r
-     * @param t a Transition between the add and removal of the Components\r
-     *  a Transition can be null\r
-     */\r
-    public void replace(final Component current, final Component next, final Transition t) {\r
-        if (!contains(current)) {\r
-            throw new IllegalArgumentException("Component " + current + " is not contained in this Container");\r
-        }\r
-        if (t == null) {\r
-            replace(current, next);\r
-            return;\r
-        }\r
-\r
-        next.setX(current.getX());\r
-        next.setY(current.getY());\r
-        next.setWidth(current.getWidth());\r
-        next.setHeight(current.getHeight());\r
-        next.setParent(this);\r
-        if (next instanceof Container) {\r
-            ((Container) next).layoutContainer();\r
-        }\r
-\r
-        Animation anim = new Anim(this, current, next, t);\r
-\r
-        // block events as long as the transition is animating\r
-        Display.getInstance().blockEvents(true);\r
-\r
-        // register the transition animation\r
-        getComponentForm().registerAnimated(anim);\r
-    }\r
-\r
-    void replace(final Component current, final Component next) {\r
-        int index = components.indexOf(current);\r
-        boolean currentFocused = false;\r
-        if (current.getComponentForm() != null && current.getComponentForm().getFocused() == current) {\r
-            currentFocused = true;\r
-        }\r
-        if (layout instanceof BorderLayout) {\r
-            Object constraint = layout.getComponentConstraint(current);\r
-            removeComponent(current);\r
-            layout.addLayoutComponent(constraint, next, Container.this);\r
-        } else {\r
-            removeComponent(current);\r
-        }\r
-        next.setParent(null);\r
-        if (index < 0) {\r
-            index = 0;\r
-        }\r
-        insertComponentAt(index, next);\r
-        if (currentFocused && next.isFocusable()) {\r
-            next.requestFocus();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    void initComponentImpl() {\r
-        if (!isInitialized()) {\r
-            if (isSmoothScrolling()) {\r
-                getComponentForm().registerAnimated(this);\r
-            }\r
-            super.initComponentImpl();\r
-        }\r
-        Enumeration e = components.elements();\r
-        while (e.hasMoreElements()) {\r
-            ((Component) e.nextElement()).initComponentImpl();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * removes a Component from the Container\r
-     * \r
-     * @param cmp the removed component\r
-     */\r
-    public void removeComponent(Component cmp) {\r
-        Form parentForm = cmp.getComponentForm();\r
-        layout.removeLayoutComponent(cmp);\r
-        cmp.deinitializeImpl();\r
-        components.removeElement(cmp);\r
-        cmp.setParent(null);\r
-        cmp.setShouldCalcPreferredSize(true);\r
-        if (parentForm != null) {\r
-            if (parentForm.getFocused() == cmp || cmp instanceof Container && ((Container) cmp).contains(parentForm.getFocused())) {\r
-                parentForm.setFocused(null);\r
-            }\r
-            parentForm.clearFocusVectors();\r
-            if (cmp.isSmoothScrolling()) {\r
-                parentForm.deregisterAnimated(cmp);\r
-            }\r
-        }\r
-        setShouldCalcPreferredSize(true);\r
-    }\r
-\r
-    /**\r
-     * Cleansup the initialization flags in the hierachy\r
-     */\r
-    void deinitializeImpl() {\r
-        super.deinitializeImpl();\r
-        int size = components.size();\r
-        for (int iter = 0; iter < size; iter++) {\r
-            ((Component) components.elementAt(iter)).deinitializeImpl();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * remove all Components from container\r
-     */\r
-    public void removeAll() {\r
-        Form parentForm = getComponentForm();\r
-        if (parentForm != null) {\r
-            Component focus = parentForm.getFocused();\r
-            if (focus != null && contains(focus)) {\r
-                parentForm.setFocused(null);\r
-            }\r
-        }\r
-        Object[] arr = new Object[components.size()];\r
-        components.copyInto(arr);\r
-\r
-        for (int i = 0; i < arr.length; i++) {\r
-            removeComponent((Component) arr[i]);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Re-layout the container, this is useful when we modify the container hierarchy and\r
-     * need to redo the layout\r
-     */\r
-    public void revalidate() {\r
-        setShouldCalcPreferredSize(true);\r
-        Form root = getComponentForm();\r
-        if (root != null) {\r
-            root.layoutContainer();\r
-            root.repaint();\r
-        } else {\r
-            layoutContainer();\r
-            repaint();\r
-        }\r
-    }\r
-\r
-    /**\r
-     * @inheritDoc\r
-     */\r
-    public void paint(Graphics g) {\r
-        layoutContainer();\r
-        g.translate(getX(), getY());\r
-        Enumeration enums = components.elements();\r
-        while (enums.hasMoreElements()) {\r
-            Component cmp = (Component) enums.nextElement();\r
-            cmp.paintInternal(g);\r
-        }\r
-\r
-        g.translate(-getX(), -getY());\r
-    }\r
-\r
-    void paintIntersecting(Graphics g, Component cmp, Rectangle bounds, boolean above) {\r
-        \r
-        if (layout.isOverlapSupported() && components.contains(cmp)) {\r
-            int indexOfComponent = components.indexOf(cmp);\r
-            int startIndex;\r
-            int endIndex;\r
-            if (above) {\r
-                startIndex = indexOfComponent + 1;\r
-                endIndex = components.size();\r
-            } else {\r
-                startIndex = 0;\r
-                endIndex = indexOfComponent;\r
-            }\r
-