ProtectedCreates an attribute element.
The document instance to which this element belongs.
Node name.
Optionalattrs: ViewElementAttributesCollection of attributes.
Optionalchildren: ViewNode | Iterable<ViewNode, any, any>A list of nodes to be inserted into created element.
Readonly Internal_Element identifier. If set, it is used by module:engine/view/element~ViewElement#isSimilar,
and then two elements are considered similar if, and only if they have the same _id.
Readonly Internal_Element priority. Decides in what order elements are wrapped by module:engine/view/downcastwriter~ViewDowncastWriter.
Readonly Internal_A list of attribute names that should be rendered in the editing pipeline even though filtering mechanisms implemented in the module:engine/view/domconverter~ViewDomConverter (for instance, module:engine/view/domconverter~ViewDomConverter#shouldRenderAttribute) would filter them out.
These attributes can be specified as an option when the element is created by the module:engine/view/downcastwriter~ViewDowncastWriter. To check whether an unsafe an attribute should be permitted, use the #shouldRenderUnsafeAttribute method.
ReadonlydocumentThe document instance to which this node belongs.
ReadonlynameName of the element.
ReadonlyparentParent element. Null by default. Set by module:engine/view/element~ViewElement#_insertChild.
Static ReadonlyDEFAULT_Number of element's children.
Element identifier. If set, it is used by module:engine/view/element~ViewElement#isSimilar,
and then two elements are considered similar if, and only if they have the same id.
Index of the node in the parent element or null if the node has no parent.
Accessing this property throws an error if this node's parent element does not contain it. This means that view tree got broken.
Is true if there are no nodes inside this element, false otherwise.
Node's next sibling, or null if it is the last child.
Node's previous sibling, or null if it is the first child.
Element priority. Decides in what order elements are wrapped by module:engine/view/downcastwriter~ViewDowncastWriter.
Top-most ancestor of the node. If the node has no parent it is the root itself.
InternalAdds specified class.
element._addClass( 'foo' ); // Adds 'foo' class.
element._addClass( [ 'foo', 'bar' ] ); // Adds 'foo' and 'bar' classes.
Internalmodule:engine/view/element~ViewElement#_insertChild Insert a child node or a list of child nodes at the end of this node and sets the parent of these nodes to this element.
Number of appended nodes.
InternalUsed by module:engine/view/element~ViewElement#_mergeAttributesFrom to verify if the given element can be merged without conflicts into this element.
InternalUsed by module:engine/view/element~ViewElement#_subtractAttributesOf to verify if the given element attributes can be fully subtracted from this element.
InternalClones provided element with priority.
Optionaldeep: booleanIf set to true clones element and all its children recursively. When set to false,
element will be cloned without any children.
Clone of this element.
InternalUsed by the module:engine/view/matcher~Matcher Matcher to collect matching attribute tuples (attribute name and optional token).
Normalized patterns can be used in following ways:
patterns: [
[ true, true ]
]
patterns: [
[ 'required', true ]
]
patterns: [
[ /h[1-6]/, true ]
]
- to match a specific attribute with the exact value:
patterns: [
[ 'rel', 'nofollow' ]
]
- to match a specific attribute with a value matching a RegExp:
patterns: [
[ 'src', /^https/ ]
]
- to match an attribute name with a RegExp and the exact value:
patterns: [
[ /^data-property-/, 'foobar' ],
]
- to match an attribute name with a RegExp and match a value with another RegExp:
patterns: [
[ /^data-property-/, /^foo/ ]
]
- to match a specific style property with the value matching a RegExp:
patterns: [
[ 'style', 'font-size', /px$/ ]
]
- to match a specific class (class attribute is tokenized so it matches tokens individually):
patterns: [
[ 'class', 'foo' ]
]
An array of normalized patterns (tuples of 2 or 3 items depending on if tokenized attribute value match is needed).
An array to populate with matching tuples.
Optionalexclude: string[]Array of attribute names to exclude from match.
true if element matches all patterns. The matching tuples are pushed to the match array.
InternalType of the change.
Changed node.
Optionaldata: { index: number }Additional data.
InternalUsed by the module:engine/conversion/viewconsumable~ViewConsumable to collect the module:engine/view/element~ViewNormalizedConsumables for the element.
When key and token parameters are provided the output is filtered for the specified attribute and it's tokens and related tokens.
Optionalkey: stringAttribute name.
Optionaltoken: stringReference token to collect all related tokens.
InternalMerges attributes of a given element into the element. This includes also tokenized attributes like style and class.
Note that you should make sure there are no conflicts before merging (see #_canMergeAttributesFrom).
This method is used by the module:engine/view/downcastwriter~ViewDowncastWriter while down-casting an module:engine/view/attributeelement~ViewAttributeElement to merge it with other ViewAttributeElement.
InternalRemoves node from parent.
InternalRemoves attribute from the element.
Attribute key.
Optionaltokens: ArrayOrItem<string>Attribute value tokens to remove. The whole attribute is removed if not specified.
Returns true if an attribute existed and has been removed.
InternalRemoves number of child nodes starting at the given index and set the parent of these nodes to null.
Number of the first node to remove.
OptionalhowMany: numberNumber of nodes to remove.
The array of removed nodes.
InternalRemoves specified class.
element._removeClass( 'foo' ); // Removes 'foo' class.
element._removeClass( [ 'foo', 'bar' ] ); // Removes both 'foo' and 'bar' classes.
InternalRemoves specified style.
element._removeStyle( 'color' ); // Removes 'color' style.
element._removeStyle( [ 'color', 'border-top' ] ); // Removes both 'color' and 'border-top' styles.
Note: This method can work with normalized style names if
module:engine/controller/datacontroller~DataController#addStyleProcessorRules a particular style processor rule is enabled.
See module:engine/view/stylesmap~StylesMap#remove StylesMap#remove() for details.
InternalAdds or overwrite attribute with a specified key and value.
Attribute key.
Attribute value.
Optionaloverwrite: booleanWhether tokenized attribute should override the attribute value or just add a token.
InternalAdds style to the element.
element._setStyle( 'color', 'red' );
Note: This method can work with normalized style names if
module:engine/controller/datacontroller~DataController#addStyleProcessorRules a particular style processor rule is enabled.
See module:engine/view/stylesmap~StylesMap#set StylesMap#set() for details.
Property name.
Value to set.
InternalAdds style to the element.
element._setStyle( {
color: 'red',
position: 'fixed'
} );
Note: This method can work with normalized style names if
module:engine/controller/datacontroller~DataController#addStyleProcessorRules a particular style processor rule is enabled.
See module:engine/view/stylesmap~StylesMap#set StylesMap#set() for details.
Object with key - value pairs.
InternalRemoves (subtracts) corresponding attributes of the given element from the element. This includes also tokenized attributes like style and class. All attributes, classes and styles from given element should be present inside the element being unwrapped.
Note that you should make sure all attributes could be subtracted before subtracting them (see #_canSubtractAttributesOf).
This method is used by the module:engine/view/downcastwriter~ViewDowncastWriter while down-casting an module:engine/view/attributeelement~ViewAttributeElement to unwrap the ViewAttributeElement.
Delegates selected events to another module:utils/emittermixin~Emitter. For instance:
emitterA.delegate( 'eventX' ).to( emitterB );
emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
then eventX is delegated (fired by) emitterB and emitterC along with data:
emitterA.fire( 'eventX', data );
and eventY is delegated (fired by) emitterC along with data:
emitterA.fire( 'eventY', data );
Event names that will be delegated to another emitter.
Returns ancestor element that match specified pattern. Provided patterns should be compatible with module:engine/view/matcher~Matcher Matcher as it is used internally.
Patterns used to match correct ancestor. See module:engine/view/matcher~Matcher.
Found element or null if no matching ancestor was found.
Fires an event, executing all callbacks registered for it.
The first parameter passed to callbacks is an module:utils/eventinfo~EventInfo object,
followed by the optional args provided in the fire() method call.
The type describing the event. See module:utils/emittermixin~BaseEvent.
The name of the event or EventInfo object if event is delegated.
Additional arguments to be passed to the callbacks.
By default the method returns undefined. However, the return value can be changed by listeners
through modification of the module:utils/eventinfo~EventInfo#return evt.return's property (the event info
is the first param of every callback).
Returns ancestors array of this node.
Optionaloptions: { includeSelf?: boolean; parentFirst?: boolean }Options object.
OptionalincludeSelf?: booleanWhen set to true this node will be also included in parent's array.
OptionalparentFirst?: booleanWhen set to true, array will be sorted from node's parent to root element,
otherwise root element will be the first item in the array.
Array with ancestors.
Gets attribute by key. If attribute is not present - returns undefined.
Attribute key.
Attribute value.
Returns an iterator that contains the keys for attributes. Order of inserting attributes is not preserved.
Keys for attributes.
Returns iterator that iterates over this element's attributes.
Attributes are returned as arrays containing two items. First one is attribute key and second is attribute value.
This format is accepted by native Map object and also can be passed in Node constructor.
Gets index of the given child node. Returns -1 if child node is not found.
Child node.
Index of the child node.
Returns iterator that contains all class names.
Returns a module:engine/view/element~ViewElement or module:engine/view/documentfragment~ViewDocumentFragment which is a common ancestor of both nodes.
The second node.
Optionaloptions: { includeSelf?: boolean }Options object.
OptionalincludeSelf?: booleanWhen set to true both nodes will be considered "ancestors" too.
Which means that if e.g. node A is inside B, then their common ancestor will be B.
Returns an iterator which iterates over this element's custom properties.
Iterator provides [ key, value ] pairs for each stored property.
Returns the custom property value for the given key.
Returns all module:engine/view/attributeelement~ViewAttributeElement attribute elements that has the same module:engine/view/attributeelement~ViewAttributeElement#id id and are in the view tree (were not removed).
Note: If this element has been removed from the tree, returned set will not include it.
Throws module:utils/ckeditorerror~CKEditorError attribute-element-get-elements-with-same-id-no-id
if this element has no id.
Set containing all the attribute elements
with the same id that were added and not removed from the view tree.
OptionalgetReturns block module:engine/view/filler filler offset or null if block filler is not needed.
Returns identity string based on element's name, styles, classes and other attributes. Two elements that #isSimilar are similar will have same identity string. It has the following format:
'name class="class1,class2" style="style1:value1;style2:value2" attr1="val1" attr2="val2"'
For example:
const element = writer.createContainerElement( 'foo', {
banana: '10',
apple: '20',
style: 'color: red; border-color: white;',
class: 'baz'
} );
// returns 'foo class="baz" style="border-color:white;color:red" apple="20" banana="10"'
element.getIdentity();
Note: Classes, styles and other attributes are sorted alphabetically.
Returns a normalized style object or single style value.
For an element with style set to: margin:1px 2px 3em;
element.getNormalizedStyle( 'margin' ) );
will return:
{
top: '1px',
right: '2px',
bottom: '3em',
left: '2px' // a normalized value from margin shorthand
}
and reading for single style value:
styles.getNormalizedStyle( 'margin-left' );
Will return a 2px string.
Note: This method will return normalized values only if
module:engine/controller/datacontroller~DataController#addStyleProcessorRules a particular style processor rule is enabled.
See module:engine/view/stylesmap~StylesMap#getNormalized StylesMap#getNormalized() for details.
Name of CSS property
Gets a path to the node. The path is an array containing indices of consecutive ancestors of this node, beginning from module:engine/view/node~ViewNode#root root, down to this node's index.
const abc = downcastWriter.createText( 'abc' );
const foo = downcastWriter.createText( 'foo' );
const h1 = downcastWriter.createElement( 'h1', null, downcastWriter.createText( 'header' ) );
const p = downcastWriter.createElement( 'p', null, [ abc, foo ] );
const div = downcastWriter.createElement( 'div', null, [ h1, p ] );
foo.getPath(); // Returns [ 1, 3 ]. `foo` is in `p` which is in `div`. `p` starts at offset 1, while `foo` at 3.
h1.getPath(); // Returns [ 0 ].
div.getPath(); // Returns [].
The path.
Returns style value for the given property name.
If the style does not exist undefined is returned.
Note: This method can work with normalized style names if
module:engine/controller/datacontroller~DataController#addStyleProcessorRules a particular style processor rule is enabled.
See module:engine/view/stylesmap~StylesMap#getAsString StylesMap#getAsString() for details.
For an element with style set to 'margin:1px':
// Enable 'margin' shorthand processing:
editor.data.addStyleProcessorRules( addMarginStylesRules );
const element = view.change( writer => {
const element = writer.createElement();
writer.setStyle( 'margin', '1px' );
writer.setStyle( 'margin-bottom', '3em' );
return element;
} );
element.getStyle( 'margin' ); // -> 'margin: 1px 1px 3em;'
Returns an array that contains all style names.
Optionalexpand: booleanExpand shorthand style properties and return all equivalent style representations.
Returns a boolean indicating whether an attribute with the specified key exists in the element.
Attribute key.
Optionaltoken: stringtrue if attribute with the specified key exists in the element, false otherwise.
Returns true if class is present. If more then one class is provided - returns true only when all classes are present.
element.hasClass( 'foo' ); // Returns true if 'foo' class is present.
element.hasClass( 'foo', 'bar' ); // Returns true if 'foo' and 'bar' classes are both present.
Returns true if style keys are present. If more then one style property is provided - returns true only when all properties are present.
element.hasStyle( 'color' ); // Returns true if 'border-top' style is present.
element.hasStyle( 'color', 'border-top' ); // Returns true if 'color' and 'border-top' styles are both present.
Checks whether this object is of type module:engine/view/node~ViewNode or its subclass.
This method is useful when processing view objects that are of unknown type. For example, a function may return a module:engine/view/documentfragment~ViewDocumentFragment or a module:engine/view/node~ViewNode that can be either a text node or an element. This method can be used to check what kind of object is returned.
someObject.is( 'element' ); // -> true if this is an element
someObject.is( 'node' ); // -> true if this is a node (a text node or an element)
someObject.is( 'documentFragment' ); // -> true if this is a document fragment
Since this method is also available on a range of model objects, you can prefix the type of the object with
model: or view: to check, for example, if this is the model's or view's element:
viewElement.is( 'view:element' ); // -> true
viewElement.is( 'model:element' ); // -> false
By using this method it is also possible to check a name of an element:
imgElement.is( 'element', 'img' ); // -> true
imgElement.is( 'view:element', 'img' ); // -> same as above, but more precise
Checks whether this object is of type module:engine/view/element~ViewElement or its subclass.
element.is( 'element' ); // -> true
element.is( 'node' ); // -> true
element.is( 'view:element' ); // -> true
element.is( 'view:node' ); // -> true
element.is( 'model:element' ); // -> false
element.is( 'documentSelection' ); // -> false
Assuming that the object being checked is an element, you can also check its module:engine/view/element~ViewElement#name name:
element.is( 'element', 'img' ); // -> true if this is an <img> element
text.is( 'element', 'img' ); -> false
Checks whether this object is of type module:engine/view/attributeelement~ViewAttributeElement.
attributeElement.is( 'attributeElement' ); // -> true
attributeElement.is( 'element' ); // -> true
attributeElement.is( 'node' ); // -> true
attributeElement.is( 'view:attributeElement' ); // -> true
attributeElement.is( 'view:element' ); // -> true
attributeElement.is( 'view:node' ); // -> true
attributeElement.is( 'model:element' ); // -> false
attributeElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is an attribute element, you can also check its module:engine/view/attributeelement~ViewAttributeElement#name name:
attributeElement.is( 'element', 'b' ); // -> true if this is a bold element
attributeElement.is( 'attributeElement', 'b' ); // -> same as above
text.is( 'element', 'b' ); -> false
Checks whether this object is of type module:engine/view/containerelement~ViewContainerElement or its subclass.
containerElement.is( 'containerElement' ); // -> true
containerElement.is( 'element' ); // -> true
containerElement.is( 'node' ); // -> true
containerElement.is( 'view:containerElement' ); // -> true
containerElement.is( 'view:element' ); // -> true
containerElement.is( 'view:node' ); // -> true
containerElement.is( 'model:element' ); // -> false
containerElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is a container element, you can also check its module:engine/view/containerelement~ViewContainerElement#name name:
containerElement.is( 'element', 'div' ); // -> true if this is a div container element
containerElement.is( 'contaienrElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
Checks whether this object is of type module:engine/view/editableelement~ViewEditableElement or its subclass.
editableElement.is( 'editableElement' ); // -> true
editableElement.is( 'element' ); // -> true
editableElement.is( 'node' ); // -> true
editableElement.is( 'view:editableElement' ); // -> true
editableElement.is( 'view:element' ); // -> true
editableElement.is( 'view:node' ); // -> true
editableElement.is( 'model:element' ); // -> false
editableElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is an editbale element, you can also check its module:engine/view/editableelement~ViewEditableElement#name name:
editableElement.is( 'element', 'div' ); // -> true if this is a div element
editableElement.is( 'editableElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
Checks whether this object is of type module:engine/view/emptyelement~ViewEmptyElement.
emptyElement.is( 'emptyElement' ); // -> true
emptyElement.is( 'element' ); // -> true
emptyElement.is( 'node' ); // -> true
emptyElement.is( 'view:emptyElement' ); // -> true
emptyElement.is( 'view:element' ); // -> true
emptyElement.is( 'view:node' ); // -> true
emptyElement.is( 'model:element' ); // -> false
emptyElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is an empty element, you can also check its module:engine/view/emptyelement~ViewEmptyElement#name name:
emptyElement.is( 'element', 'img' ); // -> true if this is a img element
emptyElement.is( 'emptyElement', 'img' ); // -> same as above
text.is( 'element', 'img' ); -> false
Checks whether this object is of type module:engine/view/rawelement~ViewRawElement.
rawElement.is( 'rawElement' ); // -> true
rawElement.is( 'element' ); // -> true
rawElement.is( 'node' ); // -> true
rawElement.is( 'view:rawElement' ); // -> true
rawElement.is( 'view:element' ); // -> true
rawElement.is( 'view:node' ); // -> true
rawElement.is( 'model:element' ); // -> false
rawElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is a raw element, you can also check its module:engine/view/rawelement~ViewRawElement#name name:
rawElement.is( 'img' ); // -> true if this is an img element
rawElement.is( 'rawElement', 'img' ); // -> same as above
text.is( 'img' ); -> false
Checks whether this object is of type module:engine/view/rooteditableelement~ViewRootEditableElement.
rootEditableElement.is( 'rootElement' ); // -> true
rootEditableElement.is( 'editableElement' ); // -> true
rootEditableElement.is( 'element' ); // -> true
rootEditableElement.is( 'node' ); // -> true
rootEditableElement.is( 'view:editableElement' ); // -> true
rootEditableElement.is( 'view:element' ); // -> true
rootEditableElement.is( 'view:node' ); // -> true
rootEditableElement.is( 'model:element' ); // -> false
rootEditableElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is a root editable element, you can also check its module:engine/view/rooteditableelement~ViewRootEditableElement#name name:
rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element
rootEditableElement.is( 'rootElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
Checks whether this object is of type module:engine/view/uielement~ViewUIElement.
uiElement.is( 'uiElement' ); // -> true
uiElement.is( 'element' ); // -> true
uiElement.is( 'node' ); // -> true
uiElement.is( 'view:uiElement' ); // -> true
uiElement.is( 'view:element' ); // -> true
uiElement.is( 'view:node' ); // -> true
uiElement.is( 'model:element' ); // -> false
uiElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is an ui element, you can also check its module:engine/view/uielement~ViewUIElement#name name:
uiElement.is( 'element', 'span' ); // -> true if this is a span ui element
uiElement.is( 'uiElement', 'span' ); // -> same as above
text.is( 'element', 'span' ); -> false
Checks whether this object is of type module:engine/view/text~ViewText.
text.is( '$text' ); // -> true
text.is( 'node' ); // -> true
text.is( 'view:$text' ); // -> true
text.is( 'view:node' ); // -> true
text.is( 'model:$text' ); // -> false
text.is( 'element' ); // -> false
text.is( 'range' ); // -> false
hecks whether this object is of type module:engine/view/documentfragment~ViewDocumentFragment.
docFrag.is( 'documentFragment' ); // -> true
docFrag.is( 'view:documentFragment' ); // -> true
docFrag.is( 'model:documentFragment' ); // -> false
docFrag.is( 'element' ); // -> false
docFrag.is( 'node' ); // -> false
Checks whether this object is of type module:engine/view/textproxy~ViewTextProxy.
textProxy.is( '$textProxy' ); // -> true
textProxy.is( 'view:$textProxy' ); // -> true
textProxy.is( 'model:$textProxy' ); // -> false
textProxy.is( 'element' ); // -> false
textProxy.is( 'range' ); // -> false
Note: Until version 20.0.0 this method wasn't accepting '$textProxy' type. The legacy 'textProxy' type is still
accepted for backward compatibility.
Checks whether this object is of type module:engine/view/position~ViewPosition.
position.is( 'position' ); // -> true
position.is( 'view:position' ); // -> true
position.is( 'model:position' ); // -> false
position.is( 'element' ); // -> false
position.is( 'range' ); // -> false
Checks whether this object is of type module:engine/view/range~ViewRange.
range.is( 'range' ); // -> true
range.is( 'view:range' ); // -> true
range.is( 'model:range' ); // -> false
range.is( 'element' ); // -> false
range.is( 'selection' ); // -> false
Checks whether this object is of type module:engine/view/selection~ViewSelection or module:engine/view/documentselection~ViewDocumentSelection.
selection.is( 'selection' ); // -> true
selection.is( 'view:selection' ); // -> true
selection.is( 'model:selection' ); // -> false
selection.is( 'element' ); // -> false
selection.is( 'range' ); // -> false
Checks whether this object is of type module:engine/view/documentselection~ViewDocumentSelection.
`docSelection.is( 'selection' ); // -> true
docSelection.is( 'documentSelection' ); // -> true
docSelection.is( 'view:selection' ); // -> true
docSelection.is( 'view:documentSelection' ); // -> true
docSelection.is( 'model:documentSelection' ); // -> false
docSelection.is( 'element' ); // -> false
docSelection.is( 'node' ); // -> false
Checks whether the object is of type module:engine/view/element~ViewElement or its subclass and has the specified name.
Checks whether the object is of type module:engine/view/attributeelement~ViewAttributeElement and has the specified name.
Checks whether the object is of type module:engine/view/containerelement~ViewContainerElement
or its subclass and has the specified name.
Checks whether the object is of type module:engine/view/editableelement~ViewEditableElement
or its subclass and has the specified name.
Checks whether the object is of type module:engine/view/emptyelement~ViewEmptyElement has the specified name.
Checks whether the object is of type module:engine/view/rawelement~ViewRawElement and has the specified name.
Checks whether the object is of type module:engine/view/rooteditableelement~ViewRootEditableElement
and has the specified name.
Checks whether the object is of type module:engine/view/uielement~ViewUIElement and has the specified name.
Returns whether this node is after given node. false is returned if nodes are in different trees (for example,
in different module:engine/view/documentfragment~ViewDocumentFragments).
Node to compare with.
Returns true if the node is in a tree rooted in the document (is a descendant of one of its roots).
Returns whether this node is before given node. false is returned if nodes are in different trees (for example,
in different module:engine/view/documentfragment~ViewDocumentFragments).
Node to compare with.
Checks if this element is similar to other element.
If none of elements has set module:engine/view/attributeelement~ViewAttributeElement#id, then both elements should have the same name, attributes and priority to be considered as similar. Two similar elements can contain different set of children nodes.
If at least one element has module:engine/view/attributeelement~ViewAttributeElement#id set, then both elements have to have the same module:engine/view/attributeelement~ViewAttributeElement#id value to be considered similar.
Similarity is important for module:engine/view/downcastwriter~ViewDowncastWriter. For example:
Registers a callback function to be executed when an event is fired in a specific (emitter) object.
Events can be grouped in namespaces using :.
When namespaced event is fired, it additionally fires all callbacks for that namespace.
// myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
myEmitter.on( 'myGroup', genericCallback );
myEmitter.on( 'myGroup:myEvent', specificCallback );
// genericCallback is fired.
myEmitter.fire( 'myGroup' );
// both genericCallback and specificCallback are fired.
myEmitter.fire( 'myGroup:myEvent' );
// genericCallback is fired even though there are no callbacks for "foo".
myEmitter.fire( 'myGroup:foo' );
An event callback can module:utils/eventinfo~EventInfo#stop stop the event and set the module:utils/eventinfo~EventInfo#return return value of the #fire method.
The type describing the event. See module:utils/emittermixin~BaseEvent.
The object that fires the event.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
Stops executing the callback on the given event.
Shorthand for #stopListening this.stopListening( this, event, callback ).
The name of the event.
The function to stop being called.
Registers a callback function to be executed when an event is fired.
Shorthand for #listenTo this.listenTo( this, event, callback, options ) (it makes the emitter
listen on itself).
The type descibing the event. See module:utils/emittermixin~BaseEvent.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
Registers a callback function to be executed on the next time the event is fired only. This is similar to calling #on followed by #off in the callback.
The type descibing the event. See module:utils/emittermixin~BaseEvent.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
Decides whether an unsafe attribute is whitelisted and should be rendered in the editing pipeline even though filtering mechanisms like module:engine/view/domconverter~ViewDomConverter#shouldRenderAttribute say it should not.
Unsafe attribute names can be specified when creating an element via module:engine/view/downcastwriter~ViewDowncastWriter.
The name of the attribute to be checked.
Stops delegating events. It can be used at different levels:
Optionalevent: stringThe name of the event to stop delegating. If omitted, stops it all delegations.
Optionalemitter: Emitter(requires event) The object to stop delegating a particular event to.
If omitted, stops delegation of event to all emitters.
Stops listening for events. It can be used at different levels:
Optionalemitter: EmitterThe object to stop listening to. If omitted, stops it for all objects.
Optionalevent: string(Requires the emitter) The name of the event to stop listening to. If omitted, stops it
for all events from emitter.
Optionalcallback: Function(Requires the event) The function to be removed from the call list for the given
event.
Converts ViewAttributeElement instance to plain object and returns it.
ViewAttributeElement instance converted to plain object.
Attribute elements are used to represent formatting elements in the view (think –
<b>,<span style="font-size: 2em">, etc.). Most often they are created when downcasting model text attributes.Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various types (container element, module:engine/view/attributeelement~ViewAttributeElement attribute element, module:engine/view/emptyelement~ViewEmptyElement empty element, etc) when developing a feature.
To create a new attribute element instance use the module:engine/view/downcastwriter~ViewDowncastWriter#createAttributeElement
ViewDowncastWriter#createAttributeElement()method.