Creates an instance of the menu view.
The localization services instance.
Protected_A collection of view instances, which have been added directly into the module:ui/template~Template#children.
Protected_Collections registered with #createCollection.
ReadonlybuttonButton of the menu view.
(Optional) The additional CSS class set on the menu #element.
An HTML element of the view. null until module:ui/view~View#render rendered
from the module:ui/view~View#template template. The class-level example above illustrates typical usage. The
full description, fenced examples, and assignment note are in the block comment immediately above the element field
in the source.
ReadonlyfocusTracks information about the DOM focus in the menu.
Controls whether the menu is enabled, i.e. its #buttonView can be clicked.
Controls whether the menu is open, i.e. shows or hides the #panelView panel.
ReadonlyisSet true when the view has already been module:ui/view~View#render rendered.
ReadonlykeystrokesInstance of the module:utils/keystrokehandler~KeystrokeHandler. It manages keystrokes of the menu.
ReadonlylocaleA set of tools to localize the user interface.
Also see module:core/editor/editor~Editor#locale.
The name of the position of the #panelView, relative to the menu.
Note: The value is updated each time the panel gets #isOpen open.
ReadonlypanelPanel of the menu. It hosts children of the menu.
The parent menu view of the menu. It is null for top-level menus.
See module:ui/menubar/menubarview~MenuBarView#registerMenu.
Shorthand for module:utils/locale~Locale#t.
Note: If #locale instance hasn't been passed to the view this method may not be available.
OptionaltemplateTemplate of this view. It provides the #element representing the view in DOM, which is #render rendered.
OptionalviewPositioning functions for the #panelView . They change depending on the role of the menu (top-level vs sub-menu) in the module:ui/menubar/menubarview~MenuBarView menu bar and the UI language direction.
Shorthand for module:ui/template~Template.bind, a binding module:ui/template~BindChain interface pre–configured for the view instance.
It provides module:ui/template~BindChain#to to() and
module:ui/template~BindChain#if if() methods that initialize bindings with
observable attributes and attach DOM listeners.
class SampleView extends View {
constructor( locale ) {
super( locale );
const bind = this.bindTemplate;
// These {@link module:utils/observablemixin~Observable observable} attributes will control
// the state of the view in DOM.
this.set( {
elementClass: 'foo',
isEnabled: true
} );
this.setTemplate( {
tag: 'p',
attributes: {
// The class HTML attribute will follow elementClass
// and isEnabled view attributes.
class: [
bind.to( 'elementClass' )
bind.if( 'isEnabled', 'present-when-enabled' )
]
},
on: {
// The view will fire the "clicked" event upon clicking <p> in DOM.
click: bind.to( 'clicked' )
}
} );
}
}
Internal
Attach all keyboard behaviors for the menu bar view.
Creates a new collection of views, which can be used as module:ui/template~Template#children of this view.
class SampleView extends View {
constructor( locale ) {
super( locale );
const child = new ChildView( locale );
this.items = this.createCollection( [ child ] );
this.setTemplate( {
tag: 'p',
// `items` collection will render here.
children: this.items
} );
}
}
const view = new SampleView( locale );
view.render();
// It will append <p><child#element></p> to the <body>.
document.body.appendChild( view.element );
A new collection of view instances.
The opposite of #registerChild. Removes a child view from this view instance. Once removed, the child is no longer managed by its parent, e.g. it can safely become a child of another parent view.
Child views to be removed.
Recursively destroys the view instance and child views added by #registerChild and residing in collections created by the #createCollection.
Destruction disables all event listeners:
view.on( 'event', () => {} ),module:ui/template~Template.extend Extends the #template of the view with with given definition.
A shorthand for:
Template.extend( view.template, definition );
Note: Is requires the #template to be already set. See #setTemplate.
Definition which extends the #template.
Registers a new child view under the view instance. Once registered, a child view is managed by its parent, including #render rendering and #destroy destruction.
To revert this, use #deregisterChild.
class SampleView extends View {
constructor( locale ) {
super( locale );
this.childA = new SomeChildView( locale );
this.childB = new SomeChildView( locale );
this.setTemplate( { tag: 'p' } );
// Register the children.
this.registerChild( [ this.childA, this.childB ] );
}
render() {
super.render();
this.element.appendChild( this.childA.element );
this.element.appendChild( this.childB.element );
}
}
const view = new SampleView( locale );
view.render();
// Will append <p><childA#element><b></b><childB#element></p>.
document.body.appendChild( view.element );
Note: There's no need to add child views if they're already referenced in the #template:
class SampleView extends View {
constructor( locale ) {
super( locale );
this.childA = new SomeChildView( locale );
this.childB = new SomeChildView( locale );
this.setTemplate( {
tag: 'p',
// These children will be added automatically. There's no
// need to call {@link #registerChild} for any of them.
children: [ this.childA, this.childB ]
} );
}
// ...
}
Children views to be registered.
Recursively renders the view.
Once the view is rendered:
true.Note: The children of the view:
In general, render() method is the right place to keep the code which refers to the
#element and should be executed at the very beginning of the view's life cycle.
It is possible to module:ui/template~Template.extend the #template before
the view is rendered. To allow an early customization of the view (e.g. by its parent),
such references should be done in render().
class SampleView extends View {
constructor() {
this.setTemplate( {
// ...
} );
},
render() {
// View#element becomes available.
super.render();
// The "scroll" listener depends on #element.
this.listenTo( window, 'scroll', () => {
// A reference to #element would render the #template and make it non-extendable.
if ( window.scrollY > 0 ) {
this.element.scrollLeft = 100;
} else {
this.element.scrollLeft = 0;
}
} );
}
}
const view = new SampleView();
// Let's customize the view before it gets rendered.
view.extendTemplate( {
attributes: {
class: [
'additional-class'
]
}
} );
// Late rendering allows customization of the view.
view.render();
Sets the #template of the view with with given definition.
A shorthand for:
view.setTemplate( definition );
Definition of view's template.
A menu view for the module:ui/menubar/menubarview~MenuBarView. Menus are building blocks of the menu bar, they host other sub-menus and menu items (buttons) that users can interact with.