InternalCreates a new instance of a raw element.
Throws the view-rawelement-cannot-add module:utils/ckeditorerror~CKEditorError CKEditorError when the children
parameter is passed to inform that the usage of ViewRawElement is incorrect (adding child nodes to ViewRawElement is forbidden).
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_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.
Number of element's children.
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.
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.
InternalVerify if the given element can be merged without conflicts into the element.
Note that this method is extended by the module:engine/view/attributeelement~ViewAttributeElement implementation.
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.
Returns true if elements can be merged.
InternalVerify if the given element attributes can be fully subtracted from the element.
Note that this method is extended by the module:engine/view/attributeelement~ViewAttributeElement implementation.
This method is used by the module:engine/view/downcastwriter~ViewDowncastWriter while down-casting an module:engine/view/attributeelement~ViewAttributeElement to unwrap the ViewAttributeElement.
Returns true if elements attributes can be fully subtracted.
InternalClones provided element.
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.
InternalOverrides the module:engine/view/element~ViewElement#_insertChild method.
Throws the view-rawelement-cannot-add module:utils/ckeditorerror~CKEditorError CKEditorError to prevent
adding any child nodes to a raw element.
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.
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. Both elements should have the same name and attributes to be considered as similar. Two similar elements can contain different set of children nodes.
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.
This allows rendering the children of a module:engine/view/rawelement~ViewRawElement on the DOM level. This method is called by the module:engine/view/domconverter~ViewDomConverter with the raw DOM element passed as an argument, leaving the number and shape of the children up to the integrator.
This method must be defined for the raw element to work:
const myRawElement = downcastWriter.createRawElement( 'div' );
myRawElement.render = function( domElement, domConverter ) {
domConverter.setContentOf( domElement, '<b>This is the raw content of myRawElement.</b>' );
};
The native DOM element representing the raw view element.
Instance of the ViewDomConverter used to optimize the output.
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 ViewRawElement instance to plain object and returns it.
ViewRawElement instance converted to plain object.
The raw element class.
The raw elements work as data containers ("wrappers", "sandboxes") but their children are not managed or even recognized by the editor. This encapsulation allows integrations to maintain custom DOM structures in the editor content without, for instance, worrying about compatibility with other editor features. Raw elements are a perfect tool for integration with external frameworks and data sources.
Unlike module:engine/view/uielement~ViewUIElement UI elements, raw elements act like real editor content (similar to module:engine/view/containerelement~ViewContainerElement or module:engine/view/emptyelement~ViewEmptyElement), they are considered by the editor selection and module:widget/utils~toWidget they can work as widgets.
To create a new raw element, use the module:engine/view/downcastwriter~ViewDowncastWriter#createRawElement
downcastWriter#createRawElement()method.