goog.ui.ac.RichInputHandler

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Attach an instance of an AutoComplete

Attaches the input handler to a target element. The target element should be a textarea, input box, or other focusable element with the same interface.

Attaches the input handler to multiple elements.

Detaches the input handler from the provided element.

Detaches the input handler from multuple elements.

Disposes of the object and its resources.

Performs appropriate cleanup. See description of goog.disposable.IDisposable for examples. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' disposeInternal method. Everywhere else the public dispose method must be used. For example:

 mypackage.MyClass = function() {
 mypackage.MyClass.base(this, 'constructor');
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     // Dispose logic specific to MyClass.
     ...
     // Call superclass's disposeInternal at the end of the subclass's, like
     // in C++, to avoid hard-to-catch issues.
     mypackage.MyClass.base(this, 'disposeInternal');
   };
 

Returns the current active element.

Returns the associated autocomplete instance.

Returns the current cursor position.

Gets the time to wait before updating the results. If the update during typing flag is switched on, this delay counts from the last update, otherwise from the last keypress.

Gets whether the result list is updated during typing.

Returns the value of the current active element.

Handles an element blurring.

Handles an element getting focus.

Handles a key event.

Handles the key up event. Registered only if needKeyUpListener returns true.

For subclasses to override to handle the mouse-down event.

Parses a text area or input box for the currently highlighted token.

Helper function that does the logic to handle an element blurring.

Registers handlers for the active element when it receives focus.

Associates a disposable object with this object so that they will be disposed together.

Selects the given rich row. The row's select(target) method is called.

Sets the cursor at the given position.

Sets the regular expression used to check whether the replacement (used to update the text area after a row is selected) ends with a separator. This can be set to null if the input handler should never automatically append a separator to the replacement string.

Sets whether new tokens should be generated from literals. That is, should hello'world be two tokens, assuming ' is a literal?

Sets whether we will prevent the default input behavior (moving focus to the next focusable element) on TAB.

Sets whether we will prevent highlighted item selection on TAB.

Sets whether a row has just been selected.

Sets whether separators perform autocomplete.

Sets whether separators perform autocomplete.

Sets the entry separator characters.

Sets the time to wait before updating the results.

Sets the text of the current token without updating the autocomplete choices.

Sets the regular expression used to trim the tokens before passing them to the matcher: every substring that matches the given regular expression will be removed. This can also be set to null to disable trimming.

Sets whether the result list should be updated during typing.

Sets whether to flip the orientation of up & down for hiliting next and previous autocomplete entries.

Sets the value of the current active element.

Sets whether auto-completed tokens should be wrapped with whitespace.

Checks if an update has occurred and notified the autocomplete of the new token.

The AutoComplete instance this inputhandler is associated with.

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.