Class Ember.View

public

Ember.View is the class in Ember responsible for encapsulating templates of HTML content, combining templates with data to render as sections of a page's DOM, and registering and responding to user-initiated events.

HTML Tag

The default HTML tag name used for a view's DOM representation is div. This can be customized by setting the tagName property. The following view class:

1
2
3
ParagraphView = Ember.View.extend({
  tagName: 'em'
});

Would result in instances with the following HTML:

1
<em id="ember1" class="ember-view"></em>

HTML class Attribute

The HTML class attribute of a view's tag can be set by providing a classNames property that is set to an array of strings:

1
2
3
MyView = Ember.View.extend({
  classNames: ['my-class', 'my-other-class']
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view my-class my-other-class"></div>

class attribute values can also be set by providing a classNameBindings property set to an array of properties names for the view. The return value of these properties will be added as part of the value for the view's class attribute. These properties can be computed properties:

1
2
3
4
5
6
7
MyView = Ember.View.extend({
  classNameBindings: ['propertyA', 'propertyB'],
  propertyA: 'from-a',
  propertyB: Ember.computed(function() {
    if (someLogic) { return 'from-b'; }
  })
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view from-a from-b"></div>

If the value of a class name binding returns a boolean the property name itself will be used as the class name if the property is true. The class name will not be added if the value is false or undefined.

1
2
3
4
MyView = Ember.View.extend({
  classNameBindings: ['hovered'],
  hovered: true
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view hovered"></div>

When using boolean class name bindings you can supply a string value other than the property name for use as the class HTML attribute by appending the preferred value after a ":" character when defining the binding:

1
2
3
4
MyView = Ember.View.extend({
  classNameBindings: ['awesome:so-very-cool'],
  awesome: true
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view so-very-cool"></div>

Boolean value class name bindings whose property names are in a camelCase-style format will be converted to a dasherized format:

1
2
3
4
MyView = Ember.View.extend({
  classNameBindings: ['isUrgent'],
  isUrgent: true
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view is-urgent"></div>

Class name bindings can also refer to object values that are found by traversing a path relative to the view itself:

1
2
3
4
5
6
MyView = Ember.View.extend({
  classNameBindings: ['messages.empty']
  messages: Ember.Object.create({
    empty: true
  })
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view empty"></div>

If you want to add a class name for a property which evaluates to true and and a different class name if it evaluates to false, you can pass a binding like this:

1
2
3
4
5
// Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false
Ember.View.extend({
  classNameBindings: ['isEnabled:enabled:disabled']
  isEnabled: true
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view enabled"></div>

When isEnabled is false, the resulting HTML representation looks like this:

1
<div id="ember1" class="ember-view disabled"></div>

This syntax offers the convenience to add a class if a property is false:

1
2
3
4
5
// Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
Ember.View.extend({
  classNameBindings: ['isEnabled::disabled']
  isEnabled: true
});

Will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view"></div>

When the isEnabled property on the view is set to false, it will result in view instances with an HTML representation of:

1
<div id="ember1" class="ember-view disabled"></div>

Updates to the value of a class name binding will result in automatic update of the HTML class attribute in the view's rendered HTML representation. If the value becomes false or undefined the class name will be removed.

Both classNames and classNameBindings are concatenated properties. See Ember.Object documentation for more information about concatenated properties.

HTML Attributes

The HTML attribute section of a view's tag can be set by providing an attributeBindings property set to an array of property names on the view. The return value of these properties will be used as the value of the view's HTML associated attribute:

1
2
3
4
5
AnchorView = Ember.View.extend({
  tagName: 'a',
  attributeBindings: ['href'],
  href: 'http://google.com'
});

Will result in view instances with an HTML representation of:

1
<a id="ember1" class="ember-view" href="http://google.com"></a>

One property can be mapped on to another by placing a ":" between the source property and the destination property:

1
2
3
4
5
AnchorView = Ember.View.extend({
  tagName: 'a',
  attributeBindings: ['url:href'],
  url: 'http://google.com'
});

Will result in view instances with an HTML representation of:

1
<a id="ember1" class="ember-view" href="http://google.com"></a>

Namespaced attributes (e.g. xlink:href) are supported, but have to be mapped, since : is not a valid character for properties in Javascript:

1
2
3
4
5
UseView = Ember.View.extend({
  tagName: 'use',
  attributeBindings: ['xlinkHref:xlink:href'],
  xlinkHref: '#triangle'
});

Will result in view instances with an HTML representation of:

1
<use xlink:href="#triangle"></use>

If the return value of an attributeBindings monitored property is a boolean the attribute will be present or absent depending on the value:

1
2
3
4
5
MyTextInput = Ember.View.extend({
  tagName: 'input',
  attributeBindings: ['disabled'],
  disabled: false
});

Will result in a view instance with an HTML representation of:

1
<input id="ember1" class="ember-view" />

attributeBindings can refer to computed properties:

1
2
3
4
5
6
7
8
9
10
11
MyTextInput = Ember.View.extend({
  tagName: 'input',
  attributeBindings: ['disabled'],
  disabled: Ember.computed(function() {
    if (someLogic) {
      return true;
    } else {
      return false;
    }
  })
});

To prevent setting an attribute altogether, use null or undefined as the return value of the attributeBindings monitored property:

1
2
3
4
5
MyTextInput = Ember.View.extend({
  tagName: 'form',
  attributeBindings: ['novalidate'],
  novalidate: null
});

Updates to the property of an attribute binding will result in automatic update of the HTML attribute in the view's rendered HTML representation.

attributeBindings is a concatenated property. See Ember.Object documentation for more information about concatenated properties.

Layouts

Views can have a secondary template that wraps their main template. Like primary templates, layouts can be any function that accepts an optional context parameter and returns a string of HTML that will be inserted inside view's tag. Views whose HTML element is self closing (e.g. <input />) cannot have a layout and this property will be ignored.

Most typically in Ember a layout will be a compiled template.

A view's layout can be set directly with the layout property or reference an existing template by name with the layoutName property.

A template used as a layout must contain a single use of the {{yield}} helper. The HTML contents of a view's rendered template will be inserted at this location:

1
2
3
4
AViewWithLayout = Ember.View.extend({
  layout: Ember.HTMLBars.compile("<div class='my-decorative-class'>{{yield}}</div>"),
  template: Ember.HTMLBars.compile("I got wrapped")
});

Will result in view instances with an HTML representation of:

1
2
3
4
5
<div id="ember1" class="ember-view">
  <div class="my-decorative-class">
    I got wrapped
  </div>
</div>

See Ember.Templates.helpers.yield for more information.

Responding to Browser Events

Views can respond to user-initiated events in one of three ways: method implementation, through an event manager, and through {{action}} helper use in their template or layout.

Method Implementation

Views can respond to user-initiated events by implementing a method that matches the event name. A jQuery.Event object will be passed as the argument to this method.

1
2
3
4
5
6
AView = Ember.View.extend({
  click: function(event) {
    // will be called when an instance's
    // rendered element is clicked
  }
});

Event Managers

Views can define an object as their eventManager property. This object can then implement methods that match the desired event names. Matching events that occur on the view's rendered HTML or the rendered HTML of any of its DOM descendants will trigger this method. A jQuery.Event object will be passed as the first argument to the method and an Ember.View object as the second. The Ember.View will be the view whose rendered HTML was interacted with. This may be the view with the eventManager property or one of its descendant views.

1
2
3
4
5
6
7
8
9
10
AView = Ember.View.extend({
  eventManager: Ember.Object.create({
    doubleClick: function(event, view) {
      // will be called when an instance's
      // rendered element or any rendering
      // of this view's descendant
      // elements is clicked
    }
  })
});

An event defined for an event manager takes precedence over events of the same name handled through methods on the view.

1
2
3
4
5
6
7
8
9
10
AView = Ember.View.extend({
  mouseEnter: function(event) {
    // will never trigger.
  },
  eventManager: Ember.Object.create({
    mouseEnter: function(event, view) {
      // takes precedence over AView#mouseEnter
    }
  })
});

Similarly a view's event manager will take precedence for events of any views rendered as a descendant. A method name that matches an event name will not be called if the view instance was rendered inside the HTML representation of a view that has an eventManager property defined that handles events of the name. Events not handled by the event manager will still trigger method calls on the descendant.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var App = Ember.Application.create();
App.OuterView = Ember.View.extend({
  template: Ember.HTMLBars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
  eventManager: Ember.Object.create({
    mouseEnter: function(event, view) {
      // view might be instance of either
      // OuterView or InnerView depending on
      // where on the page the user interaction occurred
    }
  })
});

App.InnerView = Ember.View.extend({
  click: function(event) {
    // will be called if rendered inside
    // an OuterView because OuterView's
    // eventManager doesn't handle click events
  },
  mouseEnter: function(event) {
    // will never be called if rendered inside
    // an OuterView.
  }
});

{{action}} Helper

See Ember.Templates.helpers.action.

Event Names

All of the event handling approaches described above respond to the same set of events. The names of the built-in events are listed below. (The hash of built-in events exists in Ember.EventDispatcher.) Additional, custom events can be registered by using Ember.Application.customEvents.

Touch events:

  • touchStart
  • touchMove
  • touchEnd
  • touchCancel

Keyboard events

  • keyDown
  • keyUp
  • keyPress

Mouse events

  • mouseDown
  • mouseUp
  • contextMenu
  • click
  • doubleClick
  • mouseMove
  • focusIn
  • focusOut
  • mouseEnter
  • mouseLeave

Form events:

  • submit
  • change
  • focusIn
  • focusOut
  • input

HTML5 drag and drop events:

  • dragStart
  • drag
  • dragEnter
  • dragLeave
  • dragOver
  • dragEnd
  • drop

Show:

Module: ember

The collection of functions, keyed by name, available on this ActionHandler as action targets.

These functions will be invoked when a matching {{action}} is triggered from within a template and the application's current route is this route.

Actions can also be invoked from other parts of your application via ActionHandler#send.

The actions hash will inherit action handlers from the actions hash defined on extended parent classes or mixins rather than just replace the entire hash, e.g.:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
App.CanDisplayBanner = Ember.Mixin.create({
  actions: {
    displayBanner(msg) {
      // ...
    }
  }
});

App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, {
  actions: {
    playMusic() {
      // ...
    }
  }
});

// `WelcomeRoute`, when active, will be able to respond
// to both actions, since the actions hash is merged rather
// then replaced when extending mixins / parent classes.
this.send('displayBanner');
this.send('playMusic');

Within a Controller, Route, View or Component's action handler, the value of the this context is the Controller, Route, View or Component object:

1
2
3
4
5
6
7
8
9
App.SongRoute = Ember.Route.extend({
  actions: {
    myAction() {
      this.controllerFor("song");
      this.transitionTo("other.route");
      ...
    }
  }
});

It is also possible to call this._super(...arguments) from within an action handler if it overrides a handler defined on a parent class or mixin:

Take for example the following routes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
App.DebugRoute = Ember.Mixin.create({
  actions: {
    debugRouteInformation() {
      console.debug("trololo");
    }
  }
});

App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, {
  actions: {
    debugRouteInformation() {
      // also call the debugRouteInformation of mixed in App.DebugRoute
      this._super(...arguments);

      // show additional annoyance
      window.alert(...);
    }
  }
});

Bubbling

By default, an action will stop bubbling once a handler defined on the actions hash handles it. To continue bubbling the action, you must return true from the handler:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
App.Router.map(function() {
  this.route("album", function() {
    this.route("song");
  });
});

App.AlbumRoute = Ember.Route.extend({
  actions: {
    startPlaying: function() {
    }
  }
});

App.AlbumSongRoute = Ember.Route.extend({
  actions: {
    startPlaying() {
      // ...

      if (actionShouldAlsoBeTriggeredOnParentRoute) {
        return true;
      }
    }
  }
});
Module: ember

The WAI-ARIA role of the control represented by this view. For example, a button may have a role of type 'button', or a pane may have a role of type 'alertdialog'. This property is used by assistive software to help visually challenged users navigate rich web applications.

The full list of valid WAI-ARIA roles is available at: http://www.w3.org/TR/wai-aria/roles#roles_categorization

Module: ember

A list of properties of the view to apply as class names. If the property is a string value, the value of that string will be applied as a class name.

1
2
3
4
5
// Applies the 'high' class to the view element
Ember.View.extend({
  classNameBindings: ['priority'],
  priority: 'high'
});

If the value of the property is a Boolean, the name of that property is added as a dasherized class name.

1
2
3
4
5
// Applies the 'is-urgent' class to the view element
Ember.View.extend({
  classNameBindings: ['isUrgent'],
  isUrgent: true
});

If you would prefer to use a custom value instead of the dasherized property name, you can pass a binding like this:

1
2
3
4
5
// Applies the 'urgent' class to the view element
Ember.View.extend({
  classNameBindings: ['isUrgent:urgent'],
  isUrgent: true
});

This list of properties is inherited from the view's superclasses as well.

Module: ember

Standard CSS class names to apply to the view's outer element. This property automatically inherits any class names defined by the view's superclasses as well.

Module: ember

Defines the properties that will be concatenated from the superclass (instead of overridden).

By default, when you extend an Ember class a property defined in the subclass overrides a property with the same name that is defined in the superclass. However, there are some cases where it is preferable to build up a property's value by combining the superclass' property value with the subclass' value. An example of this in use within Ember is the classNames property of Ember.View.

Here is some sample code showing the difference between a concatenated property and a normal one:

1
2
3
4
5
6
7
8
9
10
11
12
13
App.BarView = Ember.View.extend({
  someNonConcatenatedProperty: ['bar'],
  classNames: ['bar']
});

App.FooBarView = App.BarView.extend({
  someNonConcatenatedProperty: ['foo'],
  classNames: ['foo']
});

var fooBarView = App.FooBarView.create();
fooBarView.get('someNonConcatenatedProperty'); // ['foo']
fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']

This behavior extends to object creation as well. Continuing the above example:

1
2
3
4
5
6
var view = App.FooBarView.create({
  someNonConcatenatedProperty: ['baz'],
  classNames: ['baz']
})
view.get('someNonConcatenatedProperty'); // ['baz']
view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']

Adding a single property that is not an array will just add it in the array:

1
2
3
4
var view = App.FooBarView.create({
  classNames: 'baz'
})
view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']

Using the concatenatedProperties property, we can tell Ember to mix the content of the properties.

In Ember.View the classNameBindings and attributeBindings properties are also concatenated, in addition to classNames.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).

Module: ember

Used to identify this view during debugging

Module: ember

Destroyed object property flag.

if this property is true the observers and bindings were already removed by the effect of calling the destroy() method.

Module: ember

Destruction scheduled flag. The destroy() method has been called.

The object stays intact until the end of the run loop at which point the isDestroyed flag is set.

Module: ember

If false, the view will appear hidden in DOM.

Module: ember

Defines the properties that will be merged from the superclass (instead of overridden).

By default, when you extend an Ember class a property defined in the subclass overrides a property with the same name that is defined in the superclass. However, there are some cases where it is preferable to build up a property's value by merging the superclass property value with the subclass property's value. An example of this in use within Ember is the queryParams property of routes.

Here is some sample code showing the difference between a merged property and a normal one:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
App.BarRoute = Ember.Route.extend({
  someNonMergedProperty: {
    nonMerged: 'superclass value of nonMerged'
  },
  queryParams: {
    page: {replace: false},
    limit: {replace: true}
  }
});

App.FooBarRoute = App.BarRoute.extend({
  someNonMergedProperty: {
    completelyNonMerged: 'subclass value of nonMerged'
  },
  queryParams: {
    limit: {replace: false}
  }
});

var fooBarRoute = App.FooBarRoute.create();

fooBarRoute.get('someNonMergedProperty');
// => { completelyNonMerged: 'subclass value of nonMerged' }
//
// Note the entire object, including the nonMerged property of
// the superclass object, has been replaced

fooBarRoute.get('queryParams');
// => {
//   page: {replace: false},
//   limit: {replace: false}
// }
//
// Note the page remains from the superclass, and the
// `limit` property's value of `false` has been merged from
// the subclass.

This behavior is not available during object create calls. It is only available at extend time.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual merged property (to not mislead your users to think they can override the property in a subclass).