Sets the widget's 'access key'. This key is used (in conjunction with a browser-specific modifier key) to automatically focus the widget.

@param key the widget's access key

void set accessKey(int key) {
 //Dom.setElementProperty(getElement(), "accessKey", "" + key);
}

    <code>LTR</code> if the directionality is left-to-right, or
    <code>DEFAULT</code> if the directionality is not explicitly specified

Direction get direction => BidiUtils.getDirectionOnElement(getElement());

             <code>LTR</code> if the directionality should be set to left-to-right
             <code>DEFAULT</code> if the directionality should not be explicitly set

void set direction(Direction val) {
 BidiUtils.setDirectionOnElement(getElement(), val);
}

Gets whether this widget is enabled.

@return <code>true</code> if the widget is enabled

bool get enabled => !Dom.getElementPropertyBoolean(getElement(), "disabled");

Sets whether this widget is enabled.

@param enabled <code>true</code> to enable the widget, <code>false</code>

     to disable it

void set enabled(bool value) {
 if (value && !enabled) {
   Dom.removeElementAttribute(getElement(), "disabled");
 } else if (!value && enabled) {
   Dom.setElementPropertyBoolean(getElement(), "disabled", true);
 }
}

Explicitly focus/unfocus this widget. Only one widget can have focus at a time, and the widget that does will receive all keyboard events.

@param focused whether this widget should take focus or release it

void set focus(bool focused) {
 if (focused) {
   impl.focus(getElement());
 } else {
   impl.blur(getElement());
 }
}

String get name => Dom.getElementProperty(getElement(), "name");

void set name(String val) {
 Dom.setElementProperty(getElement(), "name", val);
}

Gets the widget's position in the tab index.

@return the widget's tab index

int get tabIndex => impl.getTabIndex(getElement());

Sets the widget's position in the tab index. If more than one widget has the same tab index, each such widget will receive focus in an arbitrary order. Setting the tab index to <code>-1</code> will cause this widget to be removed from the tab order.

@param index the widget's tab index

void set tabIndex(int index) {
 impl.setTabIndex(getElement(), index);
}

String get text {
 // Because bug http://code.google.com/p/dart/issues/detail?id=9356
 // we can't read directly from attributes
 if (getElement() is dart_html.InputElement) {
   return (getElement() as dart_html.InputElement).value;
 } else if (getElement() is dart_html.TextAreaElement) {
   return (getElement() as dart_html.TextAreaElement).value;
 } else {
   return Dom.getElementProperty(getElement(), "value");
 }
}

Sets this object's text. Note that some browsers will manipulate the text before adding it to the widget. For example, most browsers will strip all <code>\r</code> from the text, except IE which will add a <code>\r</code> before each <code>\n</code>. Use {@link #getText()} to get the text directly from the widget.

@param text the object's new text

void set text(String val) {
 // Because bug http://code.google.com/p/dart/issues/detail?id=9356
 // we can't write directly into attributes
 if (getElement() is dart_html.InputElement) {
   (getElement() as dart_html.InputElement).value = val != null ? val : "";
 } else if (getElement() is dart_html.TextAreaElement) {
   (getElement() as dart_html.TextAreaElement).value = val != null ? val : "";
 } else {
   Dom.setElementProperty(getElement(), "value", val != null ? val : "");
 }
 _autoDirHandler.refreshDirection();
}

Gets the title associated with this object. The title is the 'tool-tip' displayed to users when they hover over the object.

@return the object's title

String get title => getElement().title;

Sets the element's title.

void set title(String value) {
 getElement().title = value;
}

Determines whether or not this object is visible. Note that this does not necessarily take into account whether or not the receiver's parent is visible, or even if it is attached to the Document. The default implementation of this trait in UIObject is based on the value of a dom element's style object's display attribute.

@return <code>true</code> if the object is visible

bool get visible => isVisible(getElement());

Sets whether this object is visible.

@param visible <code>true</code> to show the object, <code>false</code> to

     hide it

void set visible(bool visible) {
 setVisible(getElement(), visible);
}

Adds an AttachEvent handler.

@param handler the handler @return the handler registration

HandlerRegistration addAttachHandler(AttachEventHandler handler) {
 return addHandler(handler, AttachEvent.TYPE);
}

For <a href= "http://code.google.com/p/google-web-toolkit/wiki/UnderstandingMemoryLeaks"

browsers which do not leak</a>, adds a native event handler to the widget.

Note that, unlike the {@link #addDomHandler(EventHandler, com.google.gwt.event.dom.client.DomEvent.Type)} implementation, there is no need to attach the widget to the DOM in order to cause the event handlers to be attached.

@param <H> the type of handler to add @param type the event key @param handler the handler @return {@link HandlerRegistration} used to remove the handler

HandlerRegistration addBitlessDomHandler(EventHandler handler, DomEventType type) {
 assert (handler != null);; // : "handler must not be null";
 assert (type != null); // : "type must not be null";
 sinkBitlessEvent(type.eventName);
 return ensureHandlers().addHandler(type, handler);
}

HandlerRegistration addBlurHandler(BlurHandler handler) {
 return addDomHandler(handler, BlurEvent.TYPE);
}

HandlerRegistration addChangeHandler(ChangeHandler handler) {
 return addDomHandler(handler, ChangeEvent.TYPE);
}

Adds a {@link ClickEvent} handler.

@param handler the click handler @return {@link HandlerRegistration} used to remove this handler

HandlerRegistration addClickHandler(ClickHandler handler) {
 return addDomHandler(handler, ClickEvent.TYPE);
}

Adds a native event handler to the widget and sinks the corresponding native event. If you do not want to sink the native event, use the generic addHandler method instead.

@param <H> the type of handler to add @param type the event key @param handler the handler @return {@link HandlerRegistration} used to remove the handler

HandlerRegistration addDomHandler(EventHandler handler, DomEventType type) {
 assert (handler != null); // : "handler must not be null";
 assert (type != null); // : "type must not be null";
 int typeInt = IEvent.getTypeInt(type.eventName);
 if (typeInt == -1) {
   sinkBitlessEvent(type.eventName);
 } else {
   sinkEvents(typeInt);
 }
 return ensureHandlers().addHandler(type, handler);
}

HandlerRegistration addDoubleClickHandler(DoubleClickHandler handler) {
 return addDomHandler(handler, DoubleClickEvent.TYPE);
}

HandlerRegistration addDragEndHandler(DragEndHandler handler) {
 return addBitlessDomHandler(handler, DragEndEvent.TYPE);
}

HandlerRegistration addDragEnterHandler(DragEnterHandler handler) {
 return addBitlessDomHandler(handler, DragEnterEvent.TYPE);
}

HandlerRegistration addDragHandler(DragHandler handler) {
 return addBitlessDomHandler(handler, DragEvent.TYPE);
}

HandlerRegistration addDragLeaveHandler(DragLeaveHandler handler) {
 return addBitlessDomHandler(handler, DragLeaveEvent.TYPE);
}

HandlerRegistration addDragOverHandler(DragOverHandler handler) {
 return addBitlessDomHandler(handler, DragOverEvent.TYPE);
}

HandlerRegistration addDragStartHandler(DragStartHandler handler) {
 return addBitlessDomHandler(handler, DragStartEvent.TYPE);
}

HandlerRegistration addDropHandler(DropHandler handler) {
 return addBitlessDomHandler(handler, DropEvent.TYPE);
}

HandlerRegistration addFocusHandler(FocusHandler handler) {
 return addDomHandler(handler, FocusEvent.TYPE);
}

HandlerRegistration addGestureChangeHandler(GestureChangeHandler handler) {
 return addDomHandler(handler, GestureChangeEvent.TYPE);
}

HandlerRegistration addGestureEndHandler(GestureEndHandler handler) {
 return addDomHandler(handler, GestureEndEvent.TYPE);
}

HandlerRegistration addGestureStartHandler(GestureStartHandler handler) {
 return addDomHandler(handler, GestureStartEvent.TYPE);
}

Adds this handler to the widget.

@param <H> the type of handler to add @param type the event type @param handler the handler @return {@link HandlerRegistration} used to remove the handler

HandlerRegistration addHandler(EventHandler handler, EventType<EventHandler> type) {
 return ensureHandlers().addHandler(type, handler);
}

HandlerRegistration addKeyDownHandler(KeyDownHandler handler) {
 return addDomHandler(handler, KeyDownEvent.TYPE);
}

HandlerRegistration addKeyPressHandler(KeyPressHandler handler) {
 return addDomHandler(handler, KeyPressEvent.TYPE);
}

HandlerRegistration addKeyUpHandler(KeyUpHandler handler) {
 return addDomHandler(handler, KeyUpEvent.TYPE);
}

HandlerRegistration addMouseDownHandler(MouseDownHandler handler) {
 return addDomHandler(handler, MouseDownEvent.TYPE);
}

HandlerRegistration addMouseMoveHandler(MouseMoveHandler handler) {
 return addDomHandler(handler, MouseMoveEvent.TYPE);
}

HandlerRegistration addMouseOutHandler(MouseOutHandler handler) {
 return addDomHandler(handler, MouseOutEvent.TYPE);
}

HandlerRegistration addMouseOverHandler(MouseOverHandler handler) {
 return addDomHandler(handler, MouseOverEvent.TYPE);
}

HandlerRegistration addMouseUpHandler(MouseUpHandler handler) {
 return addDomHandler(handler, MouseUpEvent.TYPE);
}

HandlerRegistration addMouseWheelHandler(MouseWheelHandler handler) {
 return addDomHandler(handler, MouseWheelEvent.TYPE);
}

Adds a dependent style name by specifying the style name's suffix. The actual form of the style name that is added is:

getStylePrimaryName() + '-' + styleSuffix

@param styleSuffix the suffix of the dependent style to be added. @see #setStylePrimaryName(String) @see #removeStyleDependentName(String) @see #setStyleDependentName(String, boolean) @see #addStyleName(String)

void addStyleDependentName(String styleSuffix) {
 setStyleDependentName(styleSuffix, true);
}

Adds a secondary or dependent style name to this object. A secondary style name is an additional style name that is, in HTML/CSS terms, included as a space-separated token in the value of the CSS <code>class</code> attribute for this object's root element.

The most important use for this method is to add a special kind of secondary style name called a dependent style name. To add a dependent style name, use {@link #addStyleDependentName(String)}, which will prefix the 'style' argument with the result of {@link #k()} (followed by a '-'). For example, suppose the primary style name is gwt-TextBox. If the following method is called as obj.setReadOnly(true):

public void setReadOnly(boolean readOnly) {
  isReadOnlyMode = readOnly;
  // Create a dependent style name.
  String readOnlyStyle = "readonly";
  if (readOnly) {
addStyleDependentName(readOnlyStyle);

  } else {
removeStyleDependentName(readOnlyStyle);

  }
}</pre>

then both of the CSS style rules below will be applied:
// This rule is based on the primary style name and is always active.
.gwt-TextBox {
  font-size: 12pt;
}
// This rule is based on a dependent style name that is only active
// when the widget has called addStyleName(getStylePrimaryName() +
// "-readonly").
.gwt-TextBox-readonly {
  background-color: lightgrey;
  border: none;
}</pre>

The code can also be simplified with
{@link #setStyleDependentName(String, boolean)}:
public void setReadOnly(boolean readOnly) {
  isReadOnlyMode = readOnly;
  setStyleDependentName("readonly", readOnly);
}

Dependent style names are powerful because they are automatically updated
whenever the primary style name changes. Continuing with the example above,
if the primary style name changed due to the following call:
setStylePrimaryName("my-TextThingy");

then the object would be re-associated with following style rules, removing
those that were shown above.
.my-TextThingy {
  font-size: 20pt;
}
.my-TextThingy-readonly {
  background-color: red;
  border: 2px solid yellow;
}</pre>

Secondary style names that are not dependent style names are not
automatically updated when the primary style name changes.

@param style the secondary style name to be added
@see UIObject
@see #removeStyleName(String)
void addStyleName(String style) {
 setStyleName(style, true);
}

HandlerRegistration addTouchCancelHandler(TouchCancelHandler handler) {
 return addDomHandler(handler, TouchCancelEvent.TYPE);
}

HandlerRegistration addTouchEndHandler(TouchEndHandler handler) {
 return addDomHandler(handler, TouchEndEvent.TYPE);
}

HandlerRegistration addTouchMoveHandler(TouchMoveHandler handler) {
 return addDomHandler(handler, TouchMoveEvent.TYPE);
}

HandlerRegistration addTouchStartHandler(TouchStartHandler handler) {
 return addDomHandler(handler, TouchStartEvent.TYPE);
}

HandlerRegistration addValueChangeHandler(ValueChangeHandler<T> handler) {
 // Initialization code
 if (!_valueChangeHandlerInitialized) {
   _valueChangeHandlerInitialized = true;
   addChangeHandler(new ChangeHandlerAdapter((ChangeEvent event){
     ValueChangeEvent.fire(this, getValue());
   }));
 }
 return addHandler(handler, ValueChangeEvent.TYPE);
}

Returns an Editor that is backed by the ValueBoxBase. The default implementation returns {@link ValueBoxEditor#of(ValueBoxBase)}. Subclasses may override this method to provide custom error-handling when using the Editor framework.

ValueBoxEditor<T> asEditor() {
 if (_editor == null) {
   _editor = new ValueBoxEditor.of(this);
 }
 return _editor;
}

Returns the Widget aspect of the receiver.

Widget asWidget() {
 return this;
}

If a keyboard event is currently being handled on this text box, calling this method will suppress it. This allows listeners to easily filter keyboard input.

void cancelKey() {
 if (_currentEvent != null) {
   //DOM.eventPreventDefault(currentEvent);
   _currentEvent.preventDefault();
 }
}

Clears all of the object's style names and sets it to the given style. You should normally use {@link #setStylePrimaryName(String)} unless you wish to explicitly remove all existing styles.

@param style the new style name @see #setStylePrimaryName(String)

void clearAndSetStyleName(String style) {
 setElementStyleName(getStyleElement(), style);
}

Creates the SimpleEventBus used by this Widget. You can override this method to create a custom EventBus.

@return the EventBus you want to use.

EventBus createEventBus() {
 return new SimpleEventBus();
}

Fires an event on a child widget. Used to delegate the handling of an event from one widget to another.

@param event the event @param target fire the event on the given target

void delegateEvent(Widget target, DwtEvent event) {
 target.fireEvent(event);
}

If a widget contains one or more child widgets that are not in the logical widget hierarchy (the child is physically connected only on the DOM level), it must override this method and call {@link #onAttach()} for each of its child widgets.

@see #onAttach()

void doAttachChildren() {
}

If a widget contains one or more child widgets that are not in the logical widget hierarchy (the child is physically connected only on the DOM level), it must override this method and call {@link #onDetach()} for each of its child widgets.

@see #onDetach()

void doDetachChildren() {
}

Toggles on / off direction estimation.

void enableDefaultDirectionEstimator(bool enabled) {
 _autoDirHandler.enableDefaultDirectionEstimator(enabled);
}

Ensures the existence of the event bus.

@return the EventBus.

EventBus ensureHandlers() {
 return _eventBus == null ? _eventBus = createEventBus() : _eventBus;
}

Intended to be used to pull the value out of a CSS length. If the value is "auto" or "inherit", 0 will be returned.

@param s The CSS length string to extract @return The leading numeric portion of <code>s</code>, or 0 if "auto" or

    "inherit" are passed in.

double extractLengthValue(String s) {
 if (s == "auto" || s == "inherit" || s == "") {
   return 0.0;
 } else {
   // numberRegex divides the string into a leading numeric portion
   // followed by an arbitrary portion.
   if(numberRegex.hasMatch(s)) {
     // Extract the leading numeric portion of string
     s = numberRegex.firstMatch(s)[0];
   }
   return double.parse(s);
 }
}

Fires the given event to the handlers listening to the event's type.

Any exceptions thrown by handlers will be bundled into a UmbrellaException and then re-thrown after all handlers have completed. An exception thrown by a handler will not prevent other handlers from executing.

@param event the event

void fireEvent(DwtEvent event) {
//    if (_eventBus != null) {
//      _eventBus.fireEvent(event);
//    }
 if (_eventBus != null) {
   // If it not live we should revive it.
   if (!event.isLive()) {
     event.revive();
   }
   Object oldSource = event.getSource();
   event.overrideSource(getElement());
   try {

     // May throw an UmbrellaException.
     _eventBus.fireEventFromSource(event, getElement());
   } on UmbrellaException catch (e) {
     throw new UmbrellaException(e.causes);
   } finally {
     if (oldSource == null) {
       // This was my event, so I should kill it now that I'm done.
       event.kill();
     } else {
       // Restoring the source for the next handler to use.
       event.overrideSource(oldSource);
     }
   }
 }
}

Gets the object's absolute left position in pixels, as measured from the browser window's client area.

@return the object's absolute left position

int getAbsoluteLeft() {
 return Dom.getAbsoluteLeft(getElement());
}

Gets the object's absolute top position in pixels, as measured from the browser window's client area.

@return the object's absolute top position

int getAbsoluteTop() {
 return Dom.getAbsoluteTop(getElement());
}

Gets the current position of the cursor (this also serves as the beginning of the text selection).

@return the cursor's position

int getCursorPos() {
 return _impl.getCursorPos(getElement());
}

DirectionEstimator getDirectionEstimator() {
 return _autoDirHandler.getDirectionEstimator();
}

Gets this object's browser element.

dart_html.Element getElement() {
 assert (_element != null); // : MISSING_ELEMENT_ERROR;
 return _element;
}

Return EventBus.

EventBus getEventBus() {
 return _eventBus;
}

TextBoxImpl getImpl() {
 return _impl;
}

Gets the panel-defined layout data associated with this widget.

@return the widget's layout data @see #setLayoutData

Object getLayoutData() {
 return _layoutData;
}

Gets the maximum allowable length.

@return the maximum length, in characters

int getMaxLength() {
 return _getInputElement().maxLength;
}

Gets the object's offset height in pixels. This is the total height of the object, including decorations such as border and padding, but not margin.

@return the object's offset height

int getOffsetHeight() {
 return getElement().offset.height; // Dom.getElementPropertyInt(getElement(), "offsetHeight");
}

Gets the object's offset width in pixels. This is the total width of the object, including decorations such as border and padding, but not margin.

@return the object's offset width

int getOffsetWidth() {
 return getElement().offset.width; // Dom.getElementPropertyInt(getElement(), "offsetWidth");
}

Gets this widget's parent panel.

@return the widget's parent panel

Widget getParent() {
 return _parent;
}

Gets the text currently selected within this text box.

@return the selected text, or an empty string if none is selected

String getSelectedText() {
 int start = getCursorPos();
 if (start < 0) {
   return "";
 }
 int length = getSelectionLength();
 return text.substring(start, start + length);
}

Gets the length of the current text selection.

@return the text selection length

int getSelectionLength() {
 return _impl.getSelectionLength(getElement());
}

Template method that returns the element to which style names will be applied. By default it returns the root element, but this method may be overridden to apply styles to a child element.

@return the element to which style names will be applied

dart_html.Element getStyleElement() {
 return getElement();
}

Gets all of the object's style names, as a space-separated list. If you wish to retrieve only the primary style name, call {@link #getStylePrimaryName()}.

@return the objects's space-separated style names @see #getStylePrimaryName()

String getStyleName() {
 return getElementStyleName(getStyleElement());
}

Gets the primary style name associated with the object.

@return the object's primary style name @see #setStyleName(String) @see #addStyleName(String) @see #removeStyleName(String)

String getStylePrimaryName() {
 return getElementStylePrimaryName(getStyleElement());
}

Return the parsed value, or null if the field is empty or parsing fails.

T getValue() {
 try {
   return getValueOrThrow();
 } on Exception catch (e) {
   return null;
 }
}

Return the parsed value, or null if the field is empty.

@throws ParseException if the value cannot be parsed

T getValueOrThrow() {
 T parseResult = _parser.parse(text);

 if (text == "") {
   return null;
 }

 return parseResult;
}

Gets the number of visible characters.

@return the number of visible characters

int getVisibleLength() {
 return _getInputElement().size;
}

Returns whether or not the receiver is attached to the {@link com.google.gwt.dom.client.Document Document}'s {@link com.google.gwt.dom.client.BodyElement BodyElement}.

@return true if attached, false otherwise

bool isAttached() {
 return _attached;
}

Has this widget ever been attached?

@return true if this widget ever been attached to the DOM, false otherwise

bool isOrWasAttached() {
 return eventsToSink == -1;
}

Determines whether or not the widget is read-only.

@return <code>true</code> if the widget is currently read-only,

    <code>false</code> if the widget is currently editable

bool isReadOnly() {
 return Dom.getElementPropertyBoolean(getElement(), "readOnly");
}

This method is called when a widget is attached to the browser's document. To receive notification after a Widget has been added to the document, override the {@link #onLoad} method or use {@link #addAttachHandler}.

It is strongly recommended that you override {@link #onLoad()} or {@link #doAttachChildren()} instead of this method to avoid inconsistencies between logical and physical attachment states.

Subclasses that override this method must call super.onAttach() to ensure that the Widget has been attached to its underlying Element.

@throws IllegalStateException if this widget is already attached @see #onLoad() @see #doAttachChildren()

void onAttach() {
 super.onAttach();

 // Accessibility: setting tab index to be 0 by default, ensuring element
 // appears in tab sequence. We must ensure that the element doesn't already
 // have a tabIndex set. This is not a problem for normal widgets, but when
 // a widget is used to wrap an existing static element, it can already have
 // a tabIndex.
 if (-1 == tabIndex) {
   tabIndex = 0;
 }
}

void onBrowserEvent(dart_html.Event event) {
 int type = Dom.eventGetType(event);
 if ((type & IEvent.KEYEVENTS) != 0) {
   // Fire the keyboard event. Hang on to the current event object so that
   // cancelKey() and setKey() can be implemented.
   _currentEvent = event;
   // Call the superclass' onBrowserEvent as that includes the key event
   // handlers.
   super.onBrowserEvent(event);
   _currentEvent = null;
 } else {
   // Handles Focus and Click events.
   super.onBrowserEvent(event);
 }
}

This method is called when a widget is detached from the browser's document. To receive notification before a Widget is removed from the document, override the {@link #onUnload} method or use {@link #addAttachHandler}.

It is strongly recommended that you override {@link #onUnload()} or {@link #doDetachChildren()} instead of this method to avoid inconsistencies between logical and physical attachment states.

Subclasses that override this method must call super.onDetach() to ensure that the Widget has been detached from the underlying Element. Failure to do so will result in application memory leaks due to circular references between DOM Elements and JavaScript objects.

@throws IllegalStateException if this widget is already detached @see #onUnload() @see #doDetachChildren()

void onDetach() {
 if (!isAttached()) {
   throw new Exception("Should only call onDetach when the widget is attached to the browser's document");
 }

 try {
   // onUnload() gets called *before* everything else (the opposite of
   // onLoad()).
   onUnload();
   AttachEvent.fire(this, false);
 } finally {
   // Put this in a finally, just in case onUnload throws an exception.
   try {
     doDetachChildren();
   } finally {
     // Put this in a finally, in case doDetachChildren throws an exception.
     Dom.setEventListener(getElement(), null);
     _attached = false;
   }
 }
}

void onLoad() {
 super.onLoad();
 _autoDirHandler.refreshDirection();
}

This method is called immediately before a widget will be detached from the browser's document.

void onUnload() {
}

Removes this widget from its parent widget, if one exists.

If it has no parent, this method does nothing. If it is a "root" widget (meaning it's been added to the detach list via {@link RootPanel#detachOnWindowClose(Widget)}), it will be removed from the detached immediately. This makes it possible for Composites and Panels to adopt root widgets.

@throws IllegalStateException if this widget's parent does not support

      removal (e.g. {@link Composite})

void removeFromParent() {
 if (_parent == null) {
   // If the widget had no parent, check to see if it was in the detach list
   // and remove it if necessary.
   if (RootPanel.isInDetachList(this)) {
     RootPanel.detachNow(this);
   }
 } else if (_parent is HasWidgets) {
   (_parent as HasWidgets).remove(this);
 } else if (_parent != null) {
   throw new Exception("This widget's parent does not implement HasWidgets");
 }
}

Removes a dependent style name by specifying the style name's suffix.

@param styleSuffix the suffix of the dependent style to be removed @see #setStylePrimaryName(Element, String) @see #addStyleDependentName(String) @see #setStyleDependentName(String, boolean)

void removeStyleDependentName(String styleSuffix) {
 setStyleDependentName(styleSuffix, false);
}

Removes a style name. This method is typically used to remove secondary style names, but it can be used to remove primary stylenames as well. That use is not recommended.

@param style the secondary style name to be removed @see #addStyleName(String) @see #setStyleName(String, boolean)

void removeStyleName(String style) {
 setStyleName(style, false);
}

Replaces this object's browser element.

This method exists only to support a specific use-case in Image, and should not be used by other classes.

@param elem the object's new element

void replaceElement(dart_html.Element elem) {
 if (isAttached()) {
   // Remove old event listener to avoid leaking. onDetach will not do this
   // for us, because it is only called when the widget itself is detached
   // from the document.
   Dom.setEventListener(getElement(), null);
 }

 super.replaceElement(elem);

 if (isAttached()) {
   // Hook the event listener back up on the new element. onAttach will not
   // do this for us, because it is only called when the widget itself is
   // attached to the document.
   Dom.setEventListener(getElement(), this);
 }
}

Selects all of the text in the box.

This will only work when the widget is attached to the document and not hidden.

void selectAll() {
 int length = text.length;
 if (length > 0) {
   setSelectionRange(0, length);
 }
}

void setAlignment(TextAlignment align) {
 Dom.setStyleAttribute(getElement(), "textAlign", align.value);
}

Sets the cursor position.

This will only work when the widget is attached to the document and not hidden.

@param pos the new cursor position

void setCursorPos(int pos) {
 setSelectionRange(pos, 0);
}

Sets the direction estimation model of the auto-dir handler.

void setDirectionEstimator(DirectionEstimator directionEstimator) {
 _autoDirHandler.setDirectionEstimator(directionEstimator);
}

Sets this object's browser element. UIObject subclasses must call this method before attempting to call any other methods, and it may only be called once.

@param elem the object's element

void setElement(dart_html.Element elem) {
 assert (_element == null);
 this._element = elem;
}

Sets the object's height. This height does not include decorations such as border, margin, and padding.

@param height the object's new height, in CSS units (e.g. "10px", "1em")

void setHeight(String height) {
 // This exists to deal with an inconsistency in IE's implementation where
 // it won't accept negative numbers in length measurements
 assert (extractLengthValue(height.trim().toLowerCase()) >= 0); // : "CSS heights should not be negative";
 Dom.setStyleAttribute(getElement(), "height", height);
}

Sets the panel-defined layout data associated with this widget. Only the panel that currently contains a widget should ever set this value. It serves as a place to store layout bookkeeping data associated with a widget.

@param layoutData the widget's layout data

void setLayoutData(Object value) {
 this._layoutData = value;
}

Sets the maximum allowable length.

@param length the maximum length, in characters

void setMaxLength(int length) {
 _getInputElement().maxLength = length;
}

Sets this widget's parent. This method should only be called by {@link Panel} and {@link Composite}.

@param parent the widget's new parent @throws IllegalStateException if <code>parent</code> is non-null and the

      widget already has a parent

void setParent(Widget parent) {
 Widget oldParent = this._parent;
 if (parent == null) {
   try {
     if (oldParent != null && oldParent.isAttached()) {
       onDetach();
       assert (!isAttached()); // : "Failure of " + this.getClass().getName() + " to call super.onDetach()";
     }
   } finally {
     // Put this in a finally in case onDetach throws an exception.
     this._parent = null;
   }
 } else {
   if (oldParent != null) {
     throw new Exception("Cannot set a new parent without first clearing the old parent");
   }
   this._parent = parent;
   if (parent.isAttached()) {
     onAttach();
     assert (isAttached()); // : "Failure of " + this.getClass().getName() + " to call super.onAttach()";
   }
 }
}

Sets the object's size, in pixels, not including decorations such as border, margin, and padding.

@param width the object's new width, in pixels @param height the object's new height, in pixels

void setPixelSize(int width, int height) {
 if (width >= 0) {
   setWidth(width.toString() + "px");
 }
 if (height >= 0) {
   setHeight(height.toString() + "px");
 }
}

Turns read-only mode on or off.

@param readOnly if <code>true</code>, the widget becomes read-only; if

     <code>false</code> the widget becomes editable

void setReadOnly(bool readOnly) {
 Dom.setElementPropertyBoolean(getElement(), "readOnly", readOnly);
 String readOnlyStyle = "readonly";
 if (readOnly) {
   addStyleDependentName(readOnlyStyle);
 } else {
   removeStyleDependentName(readOnlyStyle);
 }
}

Sets the range of text to be selected.

This will only work when the widget is attached to the document and not hidden.

@param pos the position of the first character to be selected @param length the number of characters to be selected

void setSelectionRange(int pos, int length) {
 // Setting the selection range will not work for unattached elements.
 if (!isAttached()) {
   return;
 }

 if (length < 0) {
   throw new Exception("Length must be a positive integer. Length: ${length}");
 }
 if (pos < 0 || length + pos > text.length) {
   throw new Exception("From Index: $pos  To Index: ${pos + length}  Text Length: ${text.length}");
 }
 _impl.setSelectionRange(getElement(), pos, length);
}

Sets the object's size. This size does not include decorations such as border, margin, and padding.

@param width the object's new width, in CSS units (e.g. "10px", "1em") @param height the object's new height, in CSS units (e.g. "10px", "1em")

void setSize(String width, String height) {
 setWidth(width);
 setHeight(height);
}

Adds or removes a dependent style name by specifying the style name's suffix. The actual form of the style name that is added is:

getStylePrimaryName() + '-' + styleSuffix

@param styleSuffix the suffix of the dependent style to be added or removed @param add <code>true</code> to add the given style, <code>false</code> to

     remove it

@see #setStylePrimaryName(Element, String) @see #addStyleDependentName(String) @see #setStyleName(String, boolean) @see #removeStyleDependentName(String)

void setStyleDependentName(String styleSuffix, bool add) {
 setStyleName(getStylePrimaryName() + '-' + styleSuffix, add);
}

Adds or removes a style name. This method is typically used to remove secondary style names, but it can be used to remove primary stylenames as well. That use is not recommended.

@param style the style name to be added or removed @param add <code>true</code> to add the given style, <code>false</code> to

     remove it

@see #addStyleName(String) @see #removeStyleName(String)

void setStyleName(String style, bool add) {
 manageElementStyleName(getStyleElement(), style, add);
}

Sets the object's primary style name and updates all dependent style names.

@param style the new primary style name @see #addStyleName(String) @see #removeStyleName(String)

void setStylePrimaryName(String style) {
 setElementStylePrimaryName(getStyleElement(), style);
}

void setValue(T value, [bool fireEvents = false]) {
 T oldValue = getValue();
 text = _renderer.render(value);
 if (fireEvents) {
   ValueChangeEvent.fireIfNotEqual(this, oldValue, value);
 }
}

Sets the number of visible characters.

@param length the number of visible characters

void setVisibleLength(int length) {
 _getInputElement().size = length;
}

Sets the object's width. This width does not include decorations such as border, margin, and padding.

@param width the object's new width, in CSS units (e.g. "10px", "1em")

void setWidth(String width) {
 // This exists to deal with an inconsistency in IE's implementation where
 // it won't accept negative numbers in length measurements
 assert (extractLengthValue(width.trim().toLowerCase()) >= 0); // : "CSS widths should not be negative";
 Dom.setStyleAttribute(getElement(), "width", width);
}

Sinks a named event. Note that only {@link Widget widgets} may actually receive events, but can receive events from all objects contained within them.

@param eventTypeName name of the event to sink on this element @see com.google.gwt.user.client.Event

void sinkBitlessEvent(String eventTypeName) {
 Dom.sinkBitlessEvent(getElement(), eventTypeName);
}

Overridden to defer the call to super.sinkEvents until the first time this widget is attached to the dom, as a performance enhancement. Subclasses wishing to customize sinkEvents can preserve this deferred sink behavior by putting their implementation behind a check of <code>isOrWasAttached()</code>:

{@literal @}Override
public void sinkEvents(int eventBitsToAdd) {
  if (isOrWasAttached()) {
    /{@literal *} customized sink code goes here {@literal *}/
  } else {
    super.sinkEvents(eventBitsToAdd);
 }
} 

void sinkEvents(int eventBitsToAdd) {
 if (isOrWasAttached()) {
   super.sinkEvents(eventsToSink);
 } else {
   eventsToSink |= eventBitsToAdd;
 }
}

This method is overridden so that any object can be viewed in the debugger as an HTML snippet.

@return a string representation of the object

String toString() {
 if (_element == null) {
   return "(null handle)";
 }
 return getElement().toString();
}

Removes a set of events from this object's event list.

@param eventBitsToRemove a bitfield representing the set of events to be

     removed from this element's event set

@see #sinkEvents @see com.google.gwt.user.client.Event

void unsinkEvents(int eventBitsToRemove) {
 Dom.sinkEvents(getElement(), Dom.getEventsSunk(getElement()) & (~eventBitsToRemove));
}