Creates a position.
Position parent.
Position offset.
module:engine/view/editableelement~ViewEditableElement ViewEditableElement instance that contains this position, or null if
position is not inside an editable element.
Is true if position is at the end of its module:engine/view/position~ViewPosition#parent parent, false otherwise.
Is true if position is at the beginning of its module:engine/view/position~ViewPosition#parent parent, false otherwise.
Node directly after the position. Equals null when there is no node after position or position is located
inside text node.
Node directly before the position. Equals null when there is no node before position or position is located
inside text node.
Position's root, that is the root of the position's parent element.
Clones this position.
Checks whether this position is before, after or in same position that other position. Two positions may be also different when they are located in separate roots.
Position to compare with.
Returns ancestors array of this position, that is this position's parent and it's ancestors.
Array with ancestors.
Returns a module:engine/view/node~ViewNode or module:engine/view/documentfragment~ViewDocumentFragment which is a common ancestor of both positions.
Gets the farthest position which matches the callback using module:engine/view/treewalker~ViewTreeWalker TreeWalker.
For example:
getLastMatchingPosition( value => value.type == 'text' ); // <p>{}foo</p> -> <p>foo[]</p>
getLastMatchingPosition( value => value.type == 'text', { direction: 'backward' } ); // <p>foo[]</p> -> <p>{}foo</p>
getLastMatchingPosition( value => false ); // Do not move the position.
Callback function. Gets module:engine/view/treewalker~ViewTreeWalkerValue and should
return true if the value should be skipped or false if not.
Optionaloptions: ViewTreeWalkerOptionsObject with configuration options. See module:engine/view/treewalker~ViewTreeWalker.
The position after the last item which matches the skip callback test.
Returns a new instance of Position with offset incremented by shift value.
How position offset should get changed. Accepts negative values.
Shifted position.
Creates a module:engine/view/treewalker~ViewTreeWalker TreeWalker instance with this positions as a start position.
Optionaloptions: ViewTreeWalkerOptionsObject with configuration options. See module:engine/view/treewalker~ViewTreeWalker
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.
Checks whether this position is located after given position. When method returns false it does not mean that
this position is before give one. Two positions may be located inside separate roots and in that situation this
method will still return false.
Position to compare with.
Returns true if this position is after given position.
Checks whether this position is located before given position. When method returns false it does not mean that
this position is after give one. Two positions may be located inside separate roots and in that situation this
method will still return false.
Position to compare with.
Returns true if this position is before given position.
Checks whether this position equals given position.
Position to compare with.
True if positions are same.
Converts ViewPosition instance to plain object and returns it.
ViewPosition instance converted to plain object.
Static_InternalCreates a new position after given view item.
View item after which the position should be located.
Static_InternalCreates position at the given location. The location can be specified as:
0),'end' (sets position at the end of that element),'before' or 'after' (sets position before or after given view item).This method is a shortcut to other constructors such as:
Optionaloffset: ViewPositionOffsetOffset or one of the flags. Used only when first parameter is a module:engine/view/item~ViewItem view item.
Static_InternalCreates a new position before given view item.
View item before which the position should be located.
Position in the view tree. Position is represented by its parent node and an offset in this parent.
In order to create a new position instance use the
createPosition*()factory methods available in: