Move old TextField to compatibility package

Change-Id: Ic1e8d3f9859f5e496c0e27e2fece4b5a9da74f01

9 files changed, 704 insertions, 16 deletions

diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VOptionGroupBase.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VOptionGroupBase.java
index 596828ecd5..94a92e2980 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VOptionGroupBase.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VOptionGroupBase.java
@@ -35,7 +35,6 @@ import com.vaadin.client.Focusable;
 import com.vaadin.client.UIDL;
 import com.vaadin.client.ui.Field;
 import com.vaadin.client.ui.VNativeButton;
-import com.vaadin.client.v7.ui.VLegacyTextField;
 
 public abstract class VOptionGroupBase extends Composite implements Field,
         ClickHandler, ChangeHandler, KeyPressHandler, Focusable, HasEnabled {
@@ -86,7 +85,7 @@ public abstract class VOptionGroupBase extends Composite implements Field,
     public final Panel container;
 
     /** For internal use only. May be removed or replaced in the future. */
-    public VLegacyTextField newItemField;
+    public VTextField newItemField;
 
     /** For internal use only. May be removed or replaced in the future. */
     public VNativeButton newItemButton;
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VPasswordField.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VPasswordField.java
new file mode 100644
index 0000000000..f565b8a9a0
--- /dev/null
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VPasswordField.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.v7.client.ui;
+
+import com.google.gwt.user.client.DOM;
+
+/**
+ * This class represents a password field.
+ *
+ * @author Vaadin Ltd.
+ *
+ */
+@Deprecated
+public class VPasswordField extends VTextField {
+
+    public VPasswordField() {
+        super(DOM.createInputPassword());
+    }
+
+}
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VScrollTable.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VScrollTable.java
index d15ae0b9fa..252f78ca86 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VScrollTable.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VScrollTable.java
@@ -111,7 +111,6 @@ import com.vaadin.client.ui.dd.VDragAndDropManager;
 import com.vaadin.client.ui.dd.VDragEvent;
 import com.vaadin.client.ui.dd.VHasDropHandler;
 import com.vaadin.client.ui.dd.VTransferable;
-import com.vaadin.client.v7.ui.VLegacyTextField;
 import com.vaadin.shared.AbstractComponentState;
 import com.vaadin.shared.MouseEventDetails;
 import com.vaadin.shared.ui.dd.VerticalDropLocation;
@@ -6494,8 +6493,8 @@ public class VScrollTable extends FlowPanel
 
                     if (!(widget instanceof VLabel)
                             && !(widget instanceof VEmbedded)
-                            && !(widget instanceof VLegacyTextField
-                                    && ((VLegacyTextField) widget)
+                            && !(widget instanceof VTextField
+                                    && ((VTextField) widget)
                                             .isReadOnly())) {
                         return null;
                     }
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextArea.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextArea.java
index 38f538fbdf..c5d229e153 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextArea.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextArea.java
@@ -33,7 +33,6 @@ import com.google.gwt.user.client.Event;
 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.dd.DragImageModifier;
-import com.vaadin.client.v7.ui.VLegacyTextField;
 
 /**
  * This class represents a multiline textfield (textarea).
@@ -45,7 +44,7 @@ import com.vaadin.client.v7.ui.VLegacyTextField;
  *
  */
 @Deprecated
-public class VTextArea extends VLegacyTextField implements DragImageModifier {
+public class VTextArea extends VTextField implements DragImageModifier {
 
     public static final String CLASSNAME = "v-textarea";
     private boolean wordwrap = true;
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextField.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextField.java
new file mode 100644
index 0000000000..9fb529ff20
--- /dev/null
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/VTextField.java
@@ -0,0 +1,533 @@
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.v7.client.ui;
+
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.core.client.Scheduler.ScheduledCommand;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.event.dom.client.BlurEvent;
+import com.google.gwt.event.dom.client.BlurHandler;
+import com.google.gwt.event.dom.client.ChangeEvent;
+import com.google.gwt.event.dom.client.ChangeHandler;
+import com.google.gwt.event.dom.client.FocusEvent;
+import com.google.gwt.event.dom.client.FocusHandler;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+import com.google.gwt.event.dom.client.KeyDownHandler;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Timer;
+import com.google.gwt.user.client.ui.TextBoxBase;
+import com.vaadin.client.ApplicationConnection;
+import com.vaadin.client.BrowserInfo;
+import com.vaadin.client.WidgetUtil;
+import com.vaadin.client.ui.Field;
+import com.vaadin.shared.EventId;
+import com.vaadin.shared.v7.ui.textfield.LegacyTextFieldConstants;
+
+/**
+ * This class represents a basic text input field with one row.
+ *
+ * @author Vaadin Ltd.
+ *
+ */
+@Deprecated
+public class VTextField extends TextBoxBase implements Field, ChangeHandler,
+        FocusHandler, BlurHandler, KeyDownHandler {
+
+    /**
+     * The input node CSS classname.
+     */
+    public static final String CLASSNAME = "v-textfield";
+    /**
+     * This CSS classname is added to the input node on hover.
+     */
+    public static final String CLASSNAME_FOCUS = "focus";
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public String paintableId;
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public ApplicationConnection client;
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public String valueBeforeEdit = null;
+
+    /**
+     * Set to false if a text change event has been sent since the last value
+     * change event. This means that {@link #valueBeforeEdit} should not be
+     * trusted when determining whether a text change even should be sent.
+     */
+    private boolean valueBeforeEditIsSynced = true;
+
+    private boolean immediate = false;
+    private int maxLength = -1;
+
+    private static final String CLASSNAME_PROMPT = "prompt";
+    private static final String TEXTCHANGE_MODE_TIMEOUT = "TIMEOUT";
+
+    private String inputPrompt = null;
+    private boolean prompting = false;
+    private int lastCursorPos = -1;
+
+    // used while checking if FF has set input prompt as value
+    private boolean possibleInputError = false;
+
+    public VTextField() {
+        this(DOM.createInputText());
+    }
+
+    protected VTextField(Element node) {
+        super(node);
+        setStyleName(CLASSNAME);
+        addChangeHandler(this);
+        if (BrowserInfo.get().isIE() || BrowserInfo.get().isFirefox()) {
+            addKeyDownHandler(this);
+        }
+        addFocusHandler(this);
+        addBlurHandler(this);
+    }
+
+    /**
+     * For internal use only. May be removed or replaced in the future.
+     * <p>
+     * TODO When GWT adds ONCUT, add it there and remove workaround. See
+     * http://code.google.com/p/google-web-toolkit/issues/detail?id=4030
+     * <p>
+     * Also note that the cut/paste are not totally crossbrowsers compatible.
+     * E.g. in Opera mac works via context menu, but on via File->Paste/Cut.
+     * Opera might need the polling method for 100% working textchanceevents.
+     * Eager polling for a change is bit dum and heavy operation, so I guess we
+     * should first try to survive without.
+     */
+    public static final int TEXTCHANGE_EVENTS = Event.ONPASTE | Event.KEYEVENTS
+            | Event.ONMOUSEUP;
+
+    @Override
+    public void onBrowserEvent(Event event) {
+        super.onBrowserEvent(event);
+
+        if (listenTextChangeEvents
+                && (event.getTypeInt() & TEXTCHANGE_EVENTS) == event
+                        .getTypeInt()) {
+            deferTextChangeEvent();
+        }
+
+    }
+
+    /*
+     * TODO optimize this so that only changes are sent + make the value change
+     * event just a flag that moves the current text to value
+     */
+    private String lastTextChangeString = null;
+
+    private String getLastCommunicatedString() {
+        return lastTextChangeString;
+    }
+
+    private void communicateTextValueToServer() {
+        String text = getText();
+        if (prompting) {
+            // Input prompt visible, text is actually ""
+            text = "";
+        }
+        if (!text.equals(getLastCommunicatedString())) {
+            if (valueBeforeEditIsSynced && text.equals(valueBeforeEdit)) {
+                /*
+                 * Value change for the current text has been enqueued since the
+                 * last text change event was sent, but we can't know that it
+                 * has been sent to the server. Ensure that all pending changes
+                 * are sent now. Sending a value change without a text change
+                 * will simulate a TextChangeEvent on the server.
+                 */
+                client.sendPendingVariableChanges();
+            } else {
+                // Default case - just send an immediate text change message
+                client.updateVariable(paintableId,
+                        LegacyTextFieldConstants.VAR_CUR_TEXT, text, true);
+
+                // Shouldn't investigate valueBeforeEdit to avoid duplicate text
+                // change events as the states are not in sync any more
+                valueBeforeEditIsSynced = false;
+            }
+            lastTextChangeString = text;
+        }
+    }
+
+    private Timer textChangeEventTrigger = new Timer() {
+
+        @Override
+        public void run() {
+            if (isAttached()) {
+                updateCursorPosition();
+                communicateTextValueToServer();
+                scheduled = false;
+            }
+        }
+    };
+
+    private boolean scheduled = false;
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public boolean listenTextChangeEvents;
+    /** For internal use only. May be removed or replaced in the future. */
+    public String textChangeEventMode;
+    public int textChangeEventTimeout;
+
+    private void deferTextChangeEvent() {
+        if (textChangeEventMode.equals(TEXTCHANGE_MODE_TIMEOUT) && scheduled) {
+            return;
+        } else {
+            textChangeEventTrigger.cancel();
+        }
+        textChangeEventTrigger.schedule(getTextChangeEventTimeout());
+        scheduled = true;
+    }
+
+    private int getTextChangeEventTimeout() {
+        return textChangeEventTimeout;
+    }
+
+    @Override
+    public void setReadOnly(boolean readOnly) {
+        boolean wasReadOnly = isReadOnly();
+
+        if (readOnly) {
+            setTabIndex(-1);
+        } else if (wasReadOnly && !readOnly && getTabIndex() == -1) {
+            /*
+             * Need to manually set tab index to 0 since server will not send
+             * the tab index if it is 0.
+             */
+            setTabIndex(0);
+        }
+
+        super.setReadOnly(readOnly);
+    }
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public void updateFieldContent(final String text) {
+        setPrompting(inputPrompt != null && focusedTextField != this
+                && (text.equals("")));
+
+        String fieldValue;
+        if (prompting) {
+            fieldValue = isReadOnly() ? "" : inputPrompt;
+            addStyleDependentName(CLASSNAME_PROMPT);
+        } else {
+            fieldValue = text;
+            removeStyleDependentName(CLASSNAME_PROMPT);
+        }
+        setText(fieldValue);
+
+        lastTextChangeString = valueBeforeEdit = text;
+        valueBeforeEditIsSynced = true;
+    }
+
+    protected void onCut() {
+        if (listenTextChangeEvents) {
+            deferTextChangeEvent();
+        }
+    }
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public native void attachCutEventListener(Element el)
+    /*-{
+        var me = this;
+        el.oncut = $entry(function() {
+            me.@com.vaadin.v7.client.ui.VTextField::onCut()();
+        });
+    }-*/;
+
+    protected native void detachCutEventListener(Element el)
+    /*-{
+        el.oncut = null;
+    }-*/;
+
+    private void onDrop() {
+        if (focusedTextField == this) {
+            return;
+        }
+        updateText(false);
+    }
+
+    private void updateText(boolean blurred) {
+        String text = getText();
+        setPrompting(inputPrompt != null && (text == null || text.isEmpty()));
+        if (prompting) {
+            setText(isReadOnly() ? "" : inputPrompt);
+            if (blurred) {
+                addStyleDependentName(CLASSNAME_PROMPT);
+            }
+        }
+
+        valueChange(blurred);
+    }
+
+    private void scheduleOnDropEvent() {
+        Scheduler.get().scheduleDeferred(new ScheduledCommand() {
+            @Override
+            public void execute() {
+                onDrop();
+            }
+        });
+    }
+
+    private native void attachDropEventListener(Element el)
+    /*-{
+        var me = this;
+        el.ondrop = $entry(function() {
+            me.@com.vaadin.v7.client.ui.VTextField::scheduleOnDropEvent()();
+        });
+    }-*/;
+
+    private native void detachDropEventListener(Element el)
+    /*-{
+        el.ondrop = null;
+    }-*/;
+
+    @Override
+    protected void onDetach() {
+        super.onDetach();
+        detachCutEventListener(getElement());
+        if (focusedTextField == this) {
+            focusedTextField = null;
+        }
+        if (BrowserInfo.get().isFirefox()) {
+            removeOnInputListener(getElement());
+            detachDropEventListener(getElement());
+        }
+    }
+
+    @Override
+    protected void onAttach() {
+        super.onAttach();
+        if (listenTextChangeEvents) {
+            detachCutEventListener(getElement());
+        }
+        if (BrowserInfo.get().isFirefox()) {
+            // Workaround for FF setting input prompt as the value if esc is
+            // pressed while the field is focused and empty (#8051).
+            addOnInputListener(getElement());
+            // Workaround for FF updating component's internal value after
+            // having drag-and-dropped text from another element (#14056)
+            attachDropEventListener(getElement());
+        }
+    }
+
+    /** For internal use only. May be removed or replaced in the future. */
+    public void setMaxLength(int newMaxLength) {
+        if (newMaxLength == maxLength) {
+            return;
+        }
+        maxLength = newMaxLength;
+        updateMaxLength(maxLength);
+    }
+
+    /**
+     * This method is responsible for updating the DOM or otherwise ensuring
+     * that the given max length is enforced. Called when the max length for the
+     * field has changed.
+     *
+     * @param maxLength
+     *            The new max length
+     */
+    protected void updateMaxLength(int maxLength) {
+        if (maxLength >= 0) {
+            getElement().setPropertyInt("maxLength", maxLength);
+        } else {
+            getElement().removeAttribute("maxLength");
+
+        }
+        setMaxLengthToElement(maxLength);
+    }
+
+    protected void setMaxLengthToElement(int newMaxLength) {
+        if (newMaxLength >= 0) {
+            getElement().setPropertyInt("maxLength", newMaxLength);
+        } else {
+            getElement().removeAttribute("maxLength");
+        }
+    }
+
+    public int getMaxLength() {
+        return maxLength;
+    }
+
+    @Override
+    public void onChange(ChangeEvent event) {
+        valueChange(false);
+    }
+
+    /**
+     * Called when the field value might have changed and/or the field was
+     * blurred. These are combined so the blur event is sent in the same batch
+     * as a possible value change event (these are often connected).
+     *
+     * @param blurred
+     *            true if the field was blurred
+     */
+    public void valueChange(boolean blurred) {
+        if (client != null && paintableId != null) {
+            boolean sendBlurEvent = false;
+            boolean sendValueChange = false;
+
+            if (blurred && client.hasEventListeners(this, EventId.BLUR)) {
+                sendBlurEvent = true;
+                client.updateVariable(paintableId, EventId.BLUR, "", false);
+            }
+
+            String newText = prompting ? "" : getText();
+            if (newText != null && !newText.equals(valueBeforeEdit)) {
+                sendValueChange = immediate;
+                client.updateVariable(paintableId, "text", newText, false);
+                valueBeforeEdit = newText;
+                valueBeforeEditIsSynced = true;
+            }
+
+            /*
+             * also send cursor position, no public api yet but for easier
+             * extension
+             */
+            updateCursorPosition();
+
+            if (sendBlurEvent || sendValueChange) {
+                /*
+                 * Avoid sending text change event as we will simulate it on the
+                 * server side before value change events.
+                 */
+                textChangeEventTrigger.cancel();
+                scheduled = false;
+                client.sendPendingVariableChanges();
+            }
+        }
+    }
+
+    /**
+     * Updates the cursor position variable if it has changed since the last
+     * update.
+     *
+     * @return true iff the value was updated
+     */
+    protected boolean updateCursorPosition() {
+        if (WidgetUtil.isAttachedAndDisplayed(this)) {
+            int cursorPos = prompting ? 0 : getCursorPos();
+            if (lastCursorPos != cursorPos) {
+                client.updateVariable(paintableId,
+                        LegacyTextFieldConstants.VAR_CURSOR, cursorPos, false);
+                lastCursorPos = cursorPos;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static VTextField focusedTextField;
+
+    public static void flushChangesFromFocusedTextField() {
+        if (focusedTextField != null) {
+            focusedTextField.onChange(null);
+        }
+    }
+
+    @Override
+    public void onFocus(FocusEvent event) {
+        addStyleDependentName(CLASSNAME_FOCUS);
+        if (prompting) {
+            setText("");
+            removeStyleDependentName(CLASSNAME_PROMPT);
+            setPrompting(false);
+        }
+        focusedTextField = this;
+        if (client != null && client.hasEventListeners(this, EventId.FOCUS)) {
+            client.updateVariable(paintableId, EventId.FOCUS, "", true);
+        }
+    }
+
+    @Override
+    public void onBlur(BlurEvent event) {
+        // this is called twice on Chrome when e.g. changing tab while prompting
+        // field focused - do not change settings on the second time
+        if (focusedTextField != this) {
+            return;
+        }
+        removeStyleDependentName(CLASSNAME_FOCUS);
+        focusedTextField = null;
+        updateText(true);
+    }
+
+    private void setPrompting(boolean prompting) {
+        this.prompting = prompting;
+    }
+
+    public void setColumns(int columns) {
+        if (columns <= 0) {
+            return;
+        }
+
+        setWidth(columns + "em");
+    }
+
+    @Override
+    public void onKeyDown(KeyDownEvent event) {
+        if (BrowserInfo.get().isIE()
+                && event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+            // IE does not send change events when pressing enter in a text
+            // input so we handle it using a key listener instead
+            valueChange(false);
+        } else if (BrowserInfo.get().isFirefox()
+                && event.getNativeKeyCode() == KeyCodes.KEY_ESCAPE
+                && getText().equals("")) {
+            // check after onInput event if inputPrompt has appeared as the
+            // value of the field
+            possibleInputError = true;
+        }
+    }
+
+    public void setImmediate(boolean immediate) {
+        this.immediate = immediate;
+    }
+
+    public void setInputPrompt(String inputPrompt) {
+        this.inputPrompt = inputPrompt;
+    }
+
+    protected boolean isWordwrap() {
+        String wrap = getElement().getAttribute("wrap");
+        return !"off".equals(wrap);
+    }
+
+    private native void addOnInputListener(Element el)
+    /*-{
+        var self = this;
+        el.oninput = $entry(function() {
+            self.@com.vaadin.v7.client.ui.VTextField::checkForInputError()();
+        });
+    }-*/;
+
+    private native void removeOnInputListener(Element el)
+    /*-{
+        el.oninput = null;
+    }-*/;
+
+    private void checkForInputError() {
+        if (possibleInputError && getText().equals(inputPrompt)) {
+            setText("");
+        }
+        possibleInputError = false;
+    }
+}
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/optiongroup/OptionGroupBaseConnector.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/optiongroup/OptionGroupBaseConnector.java
index 483abbc32b..fdeb2e08dd 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/optiongroup/OptionGroupBaseConnector.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/optiongroup/OptionGroupBaseConnector.java
@@ -21,10 +21,10 @@ import com.vaadin.client.Paintable;
 import com.vaadin.client.StyleConstants;
 import com.vaadin.client.UIDL;
 import com.vaadin.client.ui.VNativeButton;
-import com.vaadin.client.v7.ui.VLegacyTextField;
 import com.vaadin.shared.ui.select.AbstractSelectState;
 import com.vaadin.v7.client.ui.AbstractFieldConnector;
 import com.vaadin.v7.client.ui.VOptionGroupBase;
+import com.vaadin.v7.client.ui.VTextField;
 
 public abstract class OptionGroupBaseConnector extends AbstractFieldConnector
         implements Paintable {
@@ -65,7 +65,7 @@ public abstract class OptionGroupBaseConnector extends AbstractFieldConnector
                 getWidget().newItemButton.addClickHandler(getWidget());
                 getWidget().newItemButton
                         .addStyleName(StyleConstants.UI_WIDGET);
-                getWidget().newItemField = new VLegacyTextField();
+                getWidget().newItemField = new VTextField();
                 getWidget().newItemField.client = getConnection();
                 getWidget().newItemField.paintableId = getConnectorId();
                 getWidget().newItemField.addKeyPressHandler(getWidget());
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/passwordfield/PasswordFieldConnector.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/passwordfield/PasswordFieldConnector.java
index 033e879ff2..295eda7fa6 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/passwordfield/PasswordFieldConnector.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/passwordfield/PasswordFieldConnector.java
@@ -16,17 +16,17 @@
 
 package com.vaadin.v7.client.ui.passwordfield;
 
-import com.vaadin.client.v7.ui.VLegacyPasswordField;
-import com.vaadin.client.v7.ui.textfield.LegacyTextFieldConnector;
 import com.vaadin.shared.ui.Connect;
+import com.vaadin.v7.client.ui.VPasswordField;
+import com.vaadin.v7.client.ui.textfield.TextFieldConnector;
 import com.vaadin.v7.ui.PasswordField;
 
 @Deprecated
 @Connect(PasswordField.class)
-public class PasswordFieldConnector extends LegacyTextFieldConnector {
+public class PasswordFieldConnector extends TextFieldConnector {
 
     @Override
-    public VLegacyPasswordField getWidget() {
-        return (VLegacyPasswordField) super.getWidget();
+    public VPasswordField getWidget() {
+        return (VPasswordField) super.getWidget();
     }
 }
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textarea/TextAreaConnector.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textarea/TextAreaConnector.java
index 61d86dee14..d183ec39c0 100644
--- a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textarea/TextAreaConnector.java
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textarea/TextAreaConnector.java
@@ -20,14 +20,14 @@ import com.google.gwt.dom.client.Element;
 import com.google.gwt.event.dom.client.MouseUpEvent;
 import com.google.gwt.event.dom.client.MouseUpHandler;
 import com.vaadin.client.WidgetUtil.CssSize;
-import com.vaadin.client.v7.ui.textfield.LegacyTextFieldConnector;
 import com.vaadin.shared.ui.Connect;
 import com.vaadin.v7.client.ui.VTextArea;
+import com.vaadin.v7.client.ui.textfield.TextFieldConnector;
 import com.vaadin.v7.shared.ui.textarea.TextAreaState;
 import com.vaadin.v7.ui.TextArea;
 
 @Connect(TextArea.class)
-public class TextAreaConnector extends LegacyTextFieldConnector {
+public class TextAreaConnector extends TextFieldConnector {
 
     @Override
     public TextAreaState getState() {
diff --git a/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textfield/TextFieldConnector.java b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textfield/TextFieldConnector.java
new file mode 100644
index 0000000000..34f6c7068a
--- /dev/null
+++ b/compatibility-client/src/main/java/com/vaadin/v7/client/ui/textfield/TextFieldConnector.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.v7.client.ui.textfield;
+
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.user.client.Command;
+import com.vaadin.client.ApplicationConnection;
+import com.vaadin.client.Paintable;
+import com.vaadin.client.UIDL;
+import com.vaadin.client.Util;
+import com.vaadin.client.ui.AbstractFieldConnector;
+import com.vaadin.shared.ui.Connect;
+import com.vaadin.shared.ui.Connect.LoadStyle;
+import com.vaadin.shared.v7.ui.textfield.LegacyAbstractTextFieldState;
+import com.vaadin.shared.v7.ui.textfield.LegacyTextFieldConstants;
+import com.vaadin.v7.client.ui.VTextField;
+import com.vaadin.v7.ui.TextField;
+
+@Deprecated
+@Connect(value = TextField.class, loadStyle = LoadStyle.EAGER)
+public class TextFieldConnector extends AbstractFieldConnector
+        implements Paintable {
+
+    @Override
+    public LegacyAbstractTextFieldState getState() {
+        return (LegacyAbstractTextFieldState) super.getState();
+    }
+
+    @Override
+    public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+        // Save details
+        getWidget().client = client;
+        getWidget().paintableId = uidl.getId();
+
+        if (!isRealUpdate(uidl)) {
+            return;
+        }
+
+        getWidget().setReadOnly(isReadOnly());
+
+        getWidget().setInputPrompt(getState().inputPrompt);
+        getWidget().setMaxLength(getState().maxLength);
+        getWidget().setImmediate(getState().immediate);
+
+        getWidget().listenTextChangeEvents = hasEventListener("ie");
+        if (getWidget().listenTextChangeEvents) {
+            getWidget().textChangeEventMode = uidl.getStringAttribute(
+                    LegacyTextFieldConstants.ATTR_TEXTCHANGE_EVENTMODE);
+            if (getWidget().textChangeEventMode
+                    .equals(LegacyTextFieldConstants.TEXTCHANGE_MODE_EAGER)) {
+                getWidget().textChangeEventTimeout = 1;
+            } else {
+                getWidget().textChangeEventTimeout = uidl.getIntAttribute(
+                        LegacyTextFieldConstants.ATTR_TEXTCHANGE_TIMEOUT);
+                if (getWidget().textChangeEventTimeout < 1) {
+                    // Sanitize and allow lazy/timeout with timeout set to 0 to
+                    // work as eager
+                    getWidget().textChangeEventTimeout = 1;
+                }
+            }
+            getWidget().sinkEvents(VTextField.TEXTCHANGE_EVENTS);
+            getWidget().attachCutEventListener(getWidget().getElement());
+        }
+        getWidget().setColumns(getState().columns);
+
+        String text = getState().text;
+        if (text == null) {
+            text = "";
+        }
+        /*
+         * We skip the text content update if field has been repainted, but text
+         * has not been changed (#6588). Additional sanity check verifies there
+         * is no change in the queue (in which case we count more on the server
+         * side value). <input> is updated only when it looses focus, so we
+         * force updating if not focused. Lost focus issue appeared in (#15144)
+         */
+        if (!(Util.getFocusedElement() == getWidget().getElement())
+                || !uidl.getBooleanAttribute(
+                        LegacyTextFieldConstants.ATTR_NO_VALUE_CHANGE_BETWEEN_PAINTS)
+                || getWidget().valueBeforeEdit == null
+                || !text.equals(getWidget().valueBeforeEdit)) {
+            getWidget().updateFieldContent(text);
+        }
+
+        if (uidl.hasAttribute("selpos")) {
+            final int pos = uidl.getIntAttribute("selpos");
+            final int length = uidl.getIntAttribute("sellen");
+            /*
+             * Gecko defers setting the text so we need to defer the selection.
+             */
+            Scheduler.get().scheduleDeferred(new Command() {
+                @Override
+                public void execute() {
+                    getWidget().setSelectionRange(pos, length);
+                }
+            });
+        }
+    }
+
+    @Override
+    public VTextField getWidget() {
+        return (VTextField) super.getWidget();
+    }
+
+    @Override
+    public void flush() {
+        getWidget().valueChange(false);
+    }
+
+}