goog.editor.plugins.LinkBubble

Adds an event listener to the event target. The same handler can only be added once per the type. Even if you add the same handler multiple times using the same type then it will only be called once when the event is dispatched.

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.

Cleans the contents of the node passed to it. The node contents are modified directly, and the modifications will subsequently be used, for operations such as saving the innerHTML of the editor etc. Since the plugins act on the DOM directly, this method can be very expensive.

This op is invoked even on disabled plugins.

Cleans the html contents of Trogedit. Both cleanContentsDom and and cleanContentsHtml will be called on contents extracted from Trogedit. The inverse of prepareContentsHtml.

This op is invoked even on disabled plugins.

Called when the bubble is closed or hidden. The default implementation does nothing.

Closes the bubble.

Creates and shows the property bubble.

Should be overriden by subclasses to add the type specific contents to the bubble.

Helper method that creates a link with text set to linkText and optionally wires up a listener for the CLICK event or the link. The link is navigable by tabs if enableKeyboardNavigation(true) was called.

Helper method to create a link to insert into the bubble. The link is navigable by tabs if enableKeyboardNavigation(true) was called.

Helper method that creates option links (such as edit, test, remove)

Disables this plugin for the specified, registered field object.

Dispatches an event (or event like object) and calls all listeners listening for events of this type. The type of the event is decided by the type property on the event object.

If any of the listeners returns false OR calls preventDefault then this function will return false. If one of the capture listeners calls stopPropagation, then the bubble listeners won't fire.

Disposes of the object and its resources.

Removes listeners from this object. Classes that extend EventTarget may need to override this method in order to remove references to DOM Elements and additional listeners.

Enables this plugin for the specified, registered field object. A field object should only be enabled when it is loaded.

Sets whether the bubble should support tabbing through elements.

Handles execCommand. This default implementation handles dispatching BEFORECHANGE, CHANGE, and SELECTIONCHANGE events, and calls execCommandInternal to perform the actual command. Plugins that want to do their own event dispatching should override execCommand, otherwise it is preferred to only override execCommandInternal.

This version of execCommand will only work for single field plugins. Multi-field plugins must override execCommand.

Handles execCommand. This default implementation does nothing, and is called by execCommand, which handles event dispatching. This method should be overriden by plugins that don't need to do their own event dispatching. If custom event dispatching is needed, execCommand shoul be overriden instead.

TODO(user): This pattern makes accurate typing impossible.

Fires all registered listeners in this listenable for the given type and capture mode, passing them the given eventObject. This does not perform actual capture/bubble. Only implementors of the interface should be using this.

Returns the bubble map. Subclasses may override to use a separate map.

Should be overriden by subclasses to return the bubble target element or null if an element of their required type isn't found.

Sets the field object for use with this plugin.

Gets the goog.events.ListenableKey for the event or null if no such listener is in use.

Gets all listeners in this listenable for the given type and capture mode.

Returns the parent of this event target to use for capture/bubble mechanism.

NOTE(chrishenry): The name reflects the original implementation of custom event target (goog.events.EventTarget). We decided that changing the name is not worth it.

Returns the element whose properties the bubble manipulates.

Returns the target element url for the bubble.

Returns the message to display for testing a link.

In case the keyboard navigation is enabled, this will set focus on the first tabbable element in the bubble when TAB is clicked.

Handles keypress. It is run before handleKeyboardShortcut and if it returns true handleKeyboardShortcut will not be called.

Handles keyup.

Handles keyboard shortcuts. Preferred to using handleKey* as it will use the proper event based on browser and will be more performant. If handleKeyPress/handleKeyDown returns true, this will not be called. If the plugin handles the shortcut, it is responsible for dispatching appropriate events (change, selection change at the time of this comment). If the plugin calls execCommand on the editable field, then execCommand already takes care of dispatching events. NOTE: For performance reasons this is only called when any key is pressed in conjunction with ctrl/meta keys OR when a small subset of keys (defined in goog.editor.Field.POTENTIAL_SHORTCUT_KEYCODES_) are pressed without ctrl/meta keys. We specifically don't invoke it when altKey is pressed since alt key is used in many i18n UIs to enter certain characters.

Pops up a property bubble for the given selection if appropriate and closes open property bubbles if no longer needed. This should not be overridden.

Pops up a property bubble for the given selection if appropriate and closes open property bubbles if no longer needed.

Whether there is any active listeners matching the specified signature. If either the type or capture parameters are unspecified, the function will match on the remaining criteria.

Returns whether this plugin is enabled for the field object.

Returns whether the URL should be considered invalid. This always returns false in the base class, and should be overridden by subclasses that wish to impose validity rules on URLs.

Whether the string corresponds to a command this plugin handles.

Adds an event listener. A listener can only be added once to an object and if it is added again the key for the listener is returned. Note that if the existing listener is a one-off listener (registered via listenOnce), it will no longer be a one-off listener after a call to listen().

Adds an event listener that is removed automatically after the listener fired once.

If an existing listener already exists, listenOnce will do nothing. In particular, if the listener was previously registered via listen(), listenOnce() will not turn the listener into a one-off listener. Similarly, if there is already an existing one-off listener, listenOnce does not modify the listeners (it is still a once listener).

Sets the proper state for the action links.

Prepares the given HTML for editing. Strips out content that should not appear in an editor, and normalizes content as appropriate. The inverse of cleanContentsHtml.

This op is invoked even on disabled plugins.

Gets the state of this command if this plugin serves that command.

Register the handler for the target's CLICK and ENTER key events.

Register the handler for the target's CLICK event.

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

Registers the field object for use with this plugin.

Removes all listeners from this listenable. If type is specified, it will only remove listeners of the particular type. otherwise all registered listeners will be removed.

Removes an event listener from the event target. The handler must be the same object as the one added. If the handler has not been added then nothing is done.

Reposition the property bubble.

Saves the field's scroll position. See b/7279077 for context. Currently only does anything in Edge, since all other browsers already seem to work correctly.

Set if this plugin should automatically be disposed when the registered field is disposed.

Tells the plugin whether to block URLs with schemes not in the whitelist. If blocking is enabled, this plugin will not linkify the link in the bubble popup.

Sets the instance bubble factory function. If set to a non-null value, this function will be used to create a bubble instead of the global factory function.

Sets the bubble parent.

Sets the field object for use with this plugin.

Sets the parent of this event target to use for capture/bubble mechanism.

Sets a whitelist of allowed URL schemes that are safe to open. Schemes should all be in lowercase. If the plugin is set to block opening unsafe schemes, user-entered URLs will be converted to lowercase and checked against this list. The whitelist has no effect if blocking is not enabled.

Makes the given element tabbable.

Elements created by createLink[Helper] are tabbable even without calling this method. Call it for other elements if needed.

If tabindex is not already set in the element, this function sets it to 0. You'll usually want to also call `enableKeyboardNavigation(true)`.

Sets the target to be used for event.target when firing event. Mainly used for testing. For example, see goog.testing.events.mixinListenable.

Set the optional function for getting the "test" link of a url.

Inserts a link in the given container if it is specified or removes the old link with this id and replaces it with the new link

Checks whether the plugin should open the given url in a new window.

Tells the plugin to stop leaking the page's url via the referrer header when the link text link is clicked. When the user clicks on a link, the browser makes a request for the link url, passing the url of the current page in the request headers. If the user wants the current url to be kept secret (e.g. an unpublished document), the owner of the url that was clicked will see the secret url in the request headers, and it will no longer be a secret. Calling this method will not send a referrer header in the request, just as if the user had opened a blank window and typed the url in themselves.

Tests the link by opening it in a new tab/window. Should be used as the click event handler for the test pseudo-link.

Removes an event listener which was added with listen() or listenOnce().

Removes an event listener which was added with listen() by the key returned by listen().

Unregisters and disables this plugin for the current field object.

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

Place to register events the plugin listens to.

The field object this plugin is attached to.

The logger for this plugin.

No information.

No information.

No information.

No information.

No information.