-
- ```
-
- ## Automatic matching of parent/child tagNames
-
- Setting the `tagName` property of a `CollectionView` to any of
- "ul", "ol", "table", "thead", "tbody", "tfoot", "tr", or "select" will result
- in the item views receiving an appropriately matched `tagName` property.
-
- Given an empty `` and the following code:
-
- ```javascript
- anUnorderedListView = Ember.CollectionView.create({
- tagName: 'ul',
- content: ['A','B','C'],
- itemViewClass: Ember.View.extend({
- template: Ember.Handlebars.compile("the letter: {{view.content}}")
- })
- });
-
- anUnorderedListView.appendTo('body');
- ```
-
- Will result in the following HTML structure
-
- ```html
- the letter: A
- the letter: B
- the letter: C
- -
-
- the letter: A -
- the letter: B -
- the letter: C -
-
- ```
-
- ## Adding and Removing items
-
- The `childViews` property of a `CollectionView` should not be directly
- manipulated. Instead, add, remove, replace items from its `content` property.
- This will trigger appropriate changes to its rendered HTML.
-
-
- @class CollectionView
- @namespace Ember
- @extends Ember.ContainerView
- @since Ember 0.9
- */
- var CollectionView = ContainerView.extend({
-
- /**
- A list of items to be displayed by the `Ember.CollectionView`.
-
- @property content
- @type Ember.Array
- @default null
- */
- content: null,
-
- /**
- This provides metadata about what kind of empty view class this
- collection would like if it is being instantiated from another
- system (like Handlebars)
-
- @private
- @property emptyViewClass
- */
- emptyViewClass: View,
-
- /**
- An optional view to display if content is set to an empty array.
-
- @property emptyView
- @type Ember.View
- @default null
- */
- emptyView: null,
-
- /**
- @property itemViewClass
- @type Ember.View
- @default Ember.View
- */
- itemViewClass: View,
-
- /**
- Setup a CollectionView
-
- @method init
- */
- init: function() {
- var ret = this._super();
- this._contentDidChange();
- return ret;
- },
-
- /**
- Invoked when the content property is about to change. Notifies observers that the
- entire array content will change.
-
- @private
- @method _contentWillChange
- */
- _contentWillChange: beforeObserver('content', function() {
- var content = this.get('content');
-
- if (content) { content.removeArrayObserver(this); }
- var len = content ? get(content, 'length') : 0;
- this.arrayWillChange(content, 0, len);
- }),
-
- /**
- Check to make sure that the content has changed, and if so,
- update the children directly. This is always scheduled
- asynchronously, to allow the element to be created before
- bindings have synchronized and vice versa.
-
- @private
- @method _contentDidChange
- */
- _contentDidChange: observer('content', function() {
- var content = get(this, 'content');
-
- if (content) {
- this._assertArrayLike(content);
- content.addArrayObserver(this);
- }
-
- var len = content ? get(content, 'length') : 0;
- this.arrayDidChange(content, 0, null, len);
- }),
-
- /**
- Ensure that the content implements Ember.Array
-
- @private
- @method _assertArrayLike
- */
- _assertArrayLike: function(content) {
- Ember.assert(fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), EmberArray.detect(content));
- },
-
- /**
- Removes the content and content observers.
-
- @method destroy
- */
- destroy: function() {
- if (!this._super()) { return; }
-
- var content = get(this, 'content');
- if (content) { content.removeArrayObserver(this); }
-
- if (this._createdEmptyView) {
- this._createdEmptyView.destroy();
- }
-
- return this;
- },
-
- /**
- Called when a mutation to the underlying content array will occur.
-
- This method will remove any views that are no longer in the underlying
- content array.
-
- Invokes whenever the content array itself will change.
-
- @method arrayWillChange
- @param {Array} content the managed collection of objects
- @param {Number} start the index at which the changes will occurr
- @param {Number} removed number of object to be removed from content
- */
- arrayWillChange: function(content, start, removedCount) {
- // If the contents were empty before and this template collection has an
- // empty view remove it now.
- var emptyView = get(this, 'emptyView');
- if (emptyView && emptyView instanceof View) {
- emptyView.removeFromParent();
- }
-
- // Loop through child views that correspond with the removed items.
- // Note that we loop from the end of the array to the beginning because
- // we are mutating it as we go.
- var childViews = this._childViews, childView, idx, len;
-
- len = this._childViews.length;
-
- var removingAll = removedCount === len;
-
- if (removingAll) {
- this.currentState.empty(this);
- this.invokeRecursively(function(view) {
- view.removedFromDOM = true;
- }, false);
- }
-
- for (idx = start + removedCount - 1; idx >= start; idx--) {
- childView = childViews[idx];
- childView.destroy();
- }
- },
-
- /**
- Called when a mutation to the underlying content array occurs.
-
- This method will replay that mutation against the views that compose the
- `Ember.CollectionView`, ensuring that the view reflects the model.
-
- This array observer is added in `contentDidChange`.
-
- @method arrayDidChange
- @param {Array} content the managed collection of objects
- @param {Number} start the index at which the changes occurred
- @param {Number} removed number of object removed from content
- @param {Number} added number of object added to content
- */
- arrayDidChange: function(content, start, removed, added) {
- var addedViews = [], view, item, idx, len, itemViewClass,
- emptyView;
-
- len = content ? get(content, 'length') : 0;
-
- if (len) {
- itemViewClass = get(this, 'itemViewClass');
-
- if ('string' === typeof itemViewClass && isGlobalPath(itemViewClass)) {
- itemViewClass = get(itemViewClass) || itemViewClass;
- }
-
- Ember.assert(fmt("itemViewClass must be a subclass of Ember.View, not %@",
- [itemViewClass]),
- 'string' === typeof itemViewClass || View.detect(itemViewClass));
-
- for (idx = start; idx < start+added; idx++) {
- item = content.objectAt(idx);
-
- view = this.createChildView(itemViewClass, {
- content: item,
- contentIndex: idx
- });
-
- addedViews.push(view);
- }
- } else {
- emptyView = get(this, 'emptyView');
-
- if (!emptyView) { return; }
-
- if ('string' === typeof emptyView && isGlobalPath(emptyView)) {
- emptyView = get(emptyView) || emptyView;
- }
-
- emptyView = this.createChildView(emptyView);
- addedViews.push(emptyView);
- set(this, 'emptyView', emptyView);
-
- if (CoreView.detect(emptyView)) {
- this._createdEmptyView = emptyView;
- }
- }
-
- this.replace(start, 0, addedViews);
- },
-
- /**
- Instantiates a view to be added to the childViews array during view
- initialization. You generally will not call this method directly unless
- you are overriding `createChildViews()`. Note that this method will
- automatically configure the correct settings on the new view instance to
- act as a child of the parent.
-
- The tag name for the view will be set to the tagName of the viewClass
- passed in.
-
- @method createChildView
- @param {Class} viewClass
- @param {Hash} [attrs] Attributes to add
- @return {Ember.View} new instance
- */
- createChildView: function(view, attrs) {
- view = this._super(view, attrs);
-
- var itemTagName = get(view, 'tagName');
-
- if (itemTagName === null || itemTagName === undefined) {
- itemTagName = CollectionView.CONTAINER_MAP[get(this, 'tagName')];
- set(view, 'tagName', itemTagName);
- }
-
- return view;
- }
- });
-
- /**
- A map of parent tags to their default child tags. You can add
- additional parent tags if you want collection views that use
- a particular parent tag to default to a child tag.
-
- @property CONTAINER_MAP
- @type Hash
- @static
- @final
- */
- CollectionView.CONTAINER_MAP = {
- ul: 'li',
- ol: 'li',
- table: 'tr',
- thead: 'tr',
- tbody: 'tr',
- tfoot: 'tr',
- tr: 'td',
- select: 'option'
- };
-
- __exports__["default"] = CollectionView;
- });
-define("ember-views/views/component",
- ["ember-metal/core","ember-views/mixins/component_template_deprecation","ember-runtime/mixins/target_action_support","ember-views/views/view","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/computed","exports"],
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
- "use strict";
- var Ember = __dependency1__["default"];
- // Ember.assert, Ember.Handlebars
-
- var ComponentTemplateDeprecation = __dependency2__["default"];
- var TargetActionSupport = __dependency3__["default"];
- var View = __dependency4__.View;var get = __dependency5__.get;
- var set = __dependency6__.set;
- var isNone = __dependency7__.isNone;
-
- var computed = __dependency8__.computed;
-
- var a_slice = Array.prototype.slice;
-
- /**
- @module ember
- @submodule ember-views
- */
-
- /**
- An `Ember.Component` is a view that is completely
- isolated. Property access in its templates go
- to the view object and actions are targeted at
- the view object. There is no access to the
- surrounding context or outer controller; all
- contextual information must be passed in.
-
- The easiest way to create an `Ember.Component` is via
- a template. If you name a template
- `components/my-foo`, you will be able to use
- `{{my-foo}}` in other templates, which will make
- an instance of the isolated component.
-
- ```handlebars
- {{app-profile person=currentUser}}
- ```
-
- ```handlebars
-
-
- The collection is empty
-
- {{person.title}}
-{{person.signature}}
- ``` - - You can use `yield` inside a template to - include the **contents** of any block attached to - the component. The block will be executed in the - context of the surrounding context or outer controller: - - ```handlebars - {{#app-profile person=currentUser}} -Admin mode
- {{! Executed in the controller's context. }} - {{/app-profile}} - ``` - - ```handlebars - -{{person.title}}
- {{! Executed in the components context. }} - {{yield}} {{! block contents }} - ``` - - If you want to customize the component, in order to - handle events or actions, you implement a subclass - of `Ember.Component` named after the name of the - component. Note that `Component` needs to be appended to the name of - your subclass like `AppProfileComponent`. - - For example, you could implement the action - `hello` for the `app-profile` component: - - ```javascript - App.AppProfileComponent = Ember.Component.extend({ - actions: { - hello: function(name) { - console.log("Hello", name); - } - } - }); - ``` - - And then use it in the component's template: - - ```handlebars - - -{{person.title}}
- {{yield}} - - - ``` - - Components must have a `-` in their name to avoid - conflicts with built-in controls that wrap HTML - elements. This is consistent with the same - requirement in web components. - - @class Component - @namespace Ember - @extends Ember.View - */ - var Component = View.extend(TargetActionSupport, ComponentTemplateDeprecation, { - instrumentName: 'component', - instrumentDisplay: computed(function() { - if (this._debugContainerKey) { - return '{{' + this._debugContainerKey.split(':')[1] + '}}'; - } - }), - - init: function() { - this._super(); - set(this, 'context', this); - set(this, 'controller', this); - }, - - defaultLayout: function(context, options){ - Ember.Handlebars.helpers['yield'].call(context, options); - }, - - /** - A components template property is set by passing a block - during its invocation. It is executed within the parent context. - - Example: - - ```handlebars - {{#my-component}} - // something that is run in the context - // of the parent context - {{/my-component}} - ``` - - Specifying a template directly to a component is deprecated without - also specifying the layout property. - - @deprecated - @property template - */ - template: computed(function(key, value) { - if (value !== undefined) { return value; } - - var templateName = get(this, 'templateName'), - template = this.templateForName(templateName, 'template'); - - Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || template); - - return template || get(this, 'defaultTemplate'); - }).property('templateName'), - - /** - Specifying a components `templateName` is deprecated without also - providing the `layout` or `layoutName` properties. - - @deprecated - @property templateName - */ - templateName: null, - - // during render, isolate keywords - cloneKeywords: function() { - return { - view: this, - controller: this - }; - }, - - _yield: function(context, options) { - var view = options.data.view, - parentView = this._parentView, - template = get(this, 'template'); - - if (template) { - Ember.assert("A Component must have a parent view in order to yield.", parentView); - - view.appendChild(View, { - isVirtual: true, - tagName: '', - _contextView: parentView, - template: template, - context: get(parentView, 'context'), - controller: get(parentView, 'controller'), - templateData: { keywords: parentView.cloneKeywords() } - }); - } - }, - - /** - If the component is currently inserted into the DOM of a parent view, this - property will point to the controller of the parent view. - - @property targetObject - @type Ember.Controller - @default null - */ - targetObject: computed(function(key) { - var parentView = get(this, '_parentView'); - return parentView ? get(parentView, 'controller') : null; - }).property('_parentView'), - - /** - Triggers a named action on the controller context where the component is used if - this controller has registered for notifications of the action. - - For example a component for playing or pausing music may translate click events - into action notifications of "play" or "stop" depending on some internal state - of the component: - - - ```javascript - App.PlayButtonComponent = Ember.Component.extend({ - click: function(){ - if (this.get('isPlaying')) { - this.sendAction('play'); - } else { - this.sendAction('stop'); - } - } - }); - ``` - - When used inside a template these component actions are configured to - trigger actions in the outer application context: - - ```handlebars - {{! application.hbs }} - {{play-button play="musicStarted" stop="musicStopped"}} - ``` - - When the component receives a browser `click` event it translate this - interaction into application-specific semantics ("play" or "stop") and - triggers the specified action name on the controller for the template - where the component is used: - - - ```javascript - App.ApplicationController = Ember.Controller.extend({ - actions: { - musicStarted: function(){ - // called when the play button is clicked - // and the music started playing - }, - musicStopped: function(){ - // called when the play button is clicked - // and the music stopped playing - } - } - }); - ``` - - If no action name is passed to `sendAction` a default name of "action" - is assumed. - - ```javascript - App.NextButtonComponent = Ember.Component.extend({ - click: function(){ - this.sendAction(); - } - }); - ``` - - ```handlebars - {{! application.hbs }} - {{next-button action="playNextSongInAlbum"}} - ``` - - ```javascript - App.ApplicationController = Ember.Controller.extend({ - actions: { - playNextSongInAlbum: function(){ - ... - } - } - }); - ``` - - @method sendAction - @param [action] {String} the action to trigger - @param [context] {*} a context to send with the action - */ - sendAction: function(action) { - var actionName, - contexts = a_slice.call(arguments, 1); - - // Send the default action - if (action === undefined) { - actionName = get(this, 'action'); - Ember.assert("The default action was triggered on the component " + this.toString() + - ", but the action name (" + actionName + ") was not a string.", - isNone(actionName) || typeof actionName === 'string'); - } else { - actionName = get(this, action); - Ember.assert("The " + action + " action was triggered on the component " + - this.toString() + ", but the action name (" + actionName + - ") was not a string.", - isNone(actionName) || typeof actionName === 'string'); - } - - // If no action name for that action could be found, just abort. - if (actionName === undefined) { return; } - - this.triggerAction({ - action: actionName, - actionContext: contexts - }); - } - }); - - __exports__["default"] = Component; - }); -define("ember-views/views/container_view", - ["ember-metal/core","ember-metal/merge","ember-runtime/mixins/mutable_array","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/states","ember-metal/error","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/run_loop","ember-metal/properties","ember-views/system/render_buffer","ember-metal/mixin","ember-runtime/system/native_array","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __exports__) { - "use strict"; - var Ember = __dependency1__["default"]; - // Ember.assert, Ember.K - - var merge = __dependency2__["default"]; - var MutableArray = __dependency3__["default"]; - var get = __dependency4__.get; - var set = __dependency5__.set; - - var View = __dependency6__.View; - var ViewCollection = __dependency6__.ViewCollection; - var cloneStates = __dependency7__.cloneStates; - var EmberViewStates = __dependency7__.states; - - var EmberError = __dependency8__["default"]; - - // ES6TODO: functions on EnumerableUtils should get their own export - var EnumerableUtils = __dependency9__["default"]; - var forEach = EnumerableUtils.forEach; - - var computed = __dependency10__.computed; - var run = __dependency11__["default"]; - var defineProperty = __dependency12__.defineProperty; - var RenderBuffer = __dependency13__["default"]; - var observer = __dependency14__.observer; - var beforeObserver = __dependency14__.beforeObserver; - var A = __dependency15__.A; - - /** - @module ember - @submodule ember-views - */ - - var states = cloneStates(EmberViewStates); - - /** - A `ContainerView` is an `Ember.View` subclass that implements `Ember.MutableArray` - allowing programmatic management of its child views. - - ## Setting Initial Child Views - - The initial array of child views can be set in one of two ways. You can - provide a `childViews` property at creation time that contains instance of - `Ember.View`: - - ```javascript - aContainer = Ember.ContainerView.create({ - childViews: [Ember.View.create(), Ember.View.create()] - }); - ``` - - You can also provide a list of property names whose values are instances of - `Ember.View`: - - ```javascript - aContainer = Ember.ContainerView.create({ - childViews: ['aView', 'bView', 'cView'], - aView: Ember.View.create(), - bView: Ember.View.create(), - cView: Ember.View.create() - }); - ``` - - The two strategies can be combined: - - ```javascript - aContainer = Ember.ContainerView.create({ - childViews: ['aView', Ember.View.create()], - aView: Ember.View.create() - }); - ``` - - Each child view's rendering will be inserted into the container's rendered - HTML in the same order as its position in the `childViews` property. - - ## Adding and Removing Child Views - - The container view implements `Ember.MutableArray` allowing programmatic management of its child views. - - To remove a view, pass that view into a `removeObject` call on the container view. - - Given an empty `` the following code - - ```javascript - aContainer = Ember.ContainerView.create({ - classNames: ['the-container'], - childViews: ['aView', 'bView'], - aView: Ember.View.create({ - template: Ember.Handlebars.compile("A") - }), - bView: Ember.View.create({ - template: Ember.Handlebars.compile("B") - }) - }); - - aContainer.appendTo('body'); - ``` - - Results in the HTML - - ```html -
-
- ```
-
- Removing a view
-
- ```javascript
- aContainer.toArray(); // [aContainer.aView, aContainer.bView]
- aContainer.removeObject(aContainer.get('bView'));
- aContainer.toArray(); // [aContainer.aView]
- ```
-
- Will result in the following HTML
-
- ```html
- A
- B
-
-
- ```
-
- Similarly, adding a child view is accomplished by adding `Ember.View` instances to the
- container view.
-
- Given an empty `` the following code
-
- ```javascript
- aContainer = Ember.ContainerView.create({
- classNames: ['the-container'],
- childViews: ['aView', 'bView'],
- aView: Ember.View.create({
- template: Ember.Handlebars.compile("A")
- }),
- bView: Ember.View.create({
- template: Ember.Handlebars.compile("B")
- })
- });
-
- aContainer.appendTo('body');
- ```
-
- Results in the HTML
-
- ```html
- A
-
-
- ```
-
- Adding a view
-
- ```javascript
- AnotherViewClass = Ember.View.extend({
- template: Ember.Handlebars.compile("Another view")
- });
-
- aContainer.toArray(); // [aContainer.aView, aContainer.bView]
- aContainer.pushObject(AnotherViewClass.create());
- aContainer.toArray(); // [aContainer.aView, aContainer.bView, A
- B
-
-
- ```
-
- ## Templates and Layout
-
- A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or
- `defaultLayout` property on a container view will not result in the template
- or layout being rendered. The HTML contents of a `Ember.ContainerView`'s DOM
- representation will only be the rendered HTML of its child views.
-
- @class ContainerView
- @namespace Ember
- @extends Ember.View
- */
- var ContainerView = View.extend(MutableArray, {
- states: states,
-
- init: function() {
- this._super();
-
- var childViews = get(this, 'childViews');
-
- // redefine view's childViews property that was obliterated
- defineProperty(this, 'childViews', View.childViewsProperty);
-
- var _childViews = this._childViews;
-
- forEach(childViews, function(viewName, idx) {
- var view;
-
- if ('string' === typeof viewName) {
- view = get(this, viewName);
- view = this.createChildView(view);
- set(this, viewName, view);
- } else {
- view = this.createChildView(viewName);
- }
-
- _childViews[idx] = view;
- }, this);
-
- var currentView = get(this, 'currentView');
- if (currentView) {
- if (!_childViews.length) { _childViews = this._childViews = this._childViews.slice(); }
- _childViews.push(this.createChildView(currentView));
- }
- },
-
- replace: function(idx, removedCount, addedViews) {
- var addedCount = addedViews ? get(addedViews, 'length') : 0;
- var self = this;
- Ember.assert("You can't add a child to a container - the child is already a child of another view", A(addedViews).every(function(item) { return !get(item, '_parentView') || get(item, '_parentView') === self; }));
-
- this.arrayContentWillChange(idx, removedCount, addedCount);
- this.childViewsWillChange(this._childViews, idx, removedCount);
-
- if (addedCount === 0) {
- this._childViews.splice(idx, removedCount) ;
- } else {
- var args = [idx, removedCount].concat(addedViews);
- if (addedViews.length && !this._childViews.length) { this._childViews = this._childViews.slice(); }
- this._childViews.splice.apply(this._childViews, args);
- }
-
- this.arrayContentDidChange(idx, removedCount, addedCount);
- this.childViewsDidChange(this._childViews, idx, removedCount, addedCount);
-
- return this;
- },
-
- objectAt: function(idx) {
- return this._childViews[idx];
- },
-
- length: computed(function () {
- return this._childViews.length;
- }).volatile(),
-
- /**
- Instructs each child view to render to the passed render buffer.
-
- @private
- @method render
- @param {Ember.RenderBuffer} buffer the buffer to render to
- */
- render: function(buffer) {
- this.forEachChildView(function(view) {
- view.renderToBuffer(buffer);
- });
- },
-
- instrumentName: 'container',
-
- /**
- When a child view is removed, destroy its element so that
- it is removed from the DOM.
-
- The array observer that triggers this action is set up in the
- `renderToBuffer` method.
-
- @private
- @method childViewsWillChange
- @param {Ember.Array} views the child views array before mutation
- @param {Number} start the start position of the mutation
- @param {Number} removed the number of child views removed
- **/
- childViewsWillChange: function(views, start, removed) {
- this.propertyWillChange('childViews');
-
- if (removed > 0) {
- var changedViews = views.slice(start, start+removed);
- // transition to preRender before clearing parentView
- this.currentState.childViewsWillChange(this, views, start, removed);
- this.initializeViews(changedViews, null, null);
- }
- },
-
- removeChild: function(child) {
- this.removeObject(child);
- return this;
- },
-
- /**
- When a child view is added, make sure the DOM gets updated appropriately.
-
- If the view has already rendered an element, we tell the child view to
- create an element and insert it into the DOM. If the enclosing container
- view has already written to a buffer, but not yet converted that buffer
- into an element, we insert the string representation of the child into the
- appropriate place in the buffer.
-
- @private
- @method childViewsDidChange
- @param {Ember.Array} views the array of child views after the mutation has occurred
- @param {Number} start the start position of the mutation
- @param {Number} removed the number of child views removed
- @param {Number} added the number of child views added
- */
- childViewsDidChange: function(views, start, removed, added) {
- if (added > 0) {
- var changedViews = views.slice(start, start+added);
- this.initializeViews(changedViews, this, get(this, 'templateData'));
- this.currentState.childViewsDidChange(this, views, start, added);
- }
- this.propertyDidChange('childViews');
- },
-
- initializeViews: function(views, parentView, templateData) {
- forEach(views, function(view) {
- set(view, '_parentView', parentView);
-
- if (!view.container && parentView) {
- set(view, 'container', parentView.container);
- }
-
- if (!get(view, 'templateData')) {
- set(view, 'templateData', templateData);
- }
- });
- },
-
- currentView: null,
-
- _currentViewWillChange: beforeObserver('currentView', function() {
- var currentView = get(this, 'currentView');
- if (currentView) {
- currentView.destroy();
- }
- }),
-
- _currentViewDidChange: observer('currentView', function() {
- var currentView = get(this, 'currentView');
- if (currentView) {
- Ember.assert("You tried to set a current view that already has a parent. Make sure you don't have multiple outlets in the same view.", !get(currentView, '_parentView'));
- this.pushObject(currentView);
- }
- }),
-
- _ensureChildrenAreInDOM: function () {
- this.currentState.ensureChildrenAreInDOM(this);
- }
- });
-
- merge(states._default, {
- childViewsWillChange: Ember.K,
- childViewsDidChange: Ember.K,
- ensureChildrenAreInDOM: Ember.K
- });
-
- merge(states.inBuffer, {
- childViewsDidChange: function(parentView, views, start, added) {
- throw new EmberError('You cannot modify child views while in the inBuffer state');
- }
- });
-
- merge(states.hasElement, {
- childViewsWillChange: function(view, views, start, removed) {
- for (var i=start; iA
- B
- Another view
- I am the template
- ```
-
- Within an Ember application is more common to define a Handlebars templates as
- part of a page:
-
- ```html
-
- ```
-
- And associate it by name using a view's `templateName` property:
-
- ```javascript
- AView = Ember.View.extend({
- templateName: 'some-template'
- });
- ```
-
- If you have nested resources, your Handlebars template will look like this:
-
- ```html
-
- ```
-
- And `templateName` property:
-
- ```javascript
- AView = Ember.View.extend({
- templateName: 'posts/new'
- });
- ```
-
- Using a value for `templateName` that does not have a Handlebars template
- with a matching `data-template-name` attribute will throw an error.
-
- For views classes that may have a template later defined (e.g. as the block
- portion of a `{{view}}` Handlebars helper call in another template or in
- a subclass), you can provide a `defaultTemplate` property set to compiled
- template function. If a template is not later provided for the view instance
- the `defaultTemplate` value will be used:
-
- ```javascript
- AView = Ember.View.extend({
- defaultTemplate: Ember.Handlebars.compile('I was the default'),
- template: null,
- templateName: null
- });
- ```
-
- Will result in instances with an HTML representation of:
-
- ```html
- I was the default
- ```
-
- If a `template` or `templateName` is provided it will take precedence over
- `defaultTemplate`:
-
- ```javascript
- AView = Ember.View.extend({
- defaultTemplate: Ember.Handlebars.compile('I was the default')
- });
-
- aView = AView.create({
- template: Ember.Handlebars.compile('I was the template, not default')
- });
- ```
-
- Will result in the following HTML representation when rendered:
-
- ```html
- I was the template, not default
- ```
-
- ## View Context
-
- The default context of the compiled template is the view's controller:
-
- ```javascript
- AView = Ember.View.extend({
- template: Ember.Handlebars.compile('Hello {{excitedGreeting}}')
- });
-
- aController = Ember.Object.create({
- firstName: 'Barry',
- excitedGreeting: function() {
- return this.get("content.firstName") + "!!!"
- }.property()
- });
-
- aView = AView.create({
- controller: aController,
- });
- ```
-
- Will result in an HTML representation of:
-
- ```html
- Hello Barry!!!
- ```
-
- A context can also be explicitly supplied through the view's `context`
- property. If the view has neither `context` nor `controller` properties, the
- `parentView`'s context will be used.
-
- ## 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. ``)
- cannot have a layout and this property will be ignored.
-
- Most typically in Ember a layout will be a compiled `Ember.Handlebars`
- template.
-
- A view's layout can be set directly with the `layout` property or reference
- an existing Handlebars template by name with the `layoutName` property.
-
- A template used as a layout must contain a single use of the Handlebars
- `{{yield}}` helper. The HTML contents of a view's rendered `template` will be
- inserted at this location:
-
- ```javascript
- AViewWithLayout = Ember.View.extend({
- layout: Ember.Handlebars.compile("{{yield}}
")
- template: Ember.Handlebars.compile("I got wrapped"),
- });
- ```
-
- Will result in view instances with an HTML representation of:
-
- ```html
-
-
- ```
-
- See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_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.
-
- ```javascript
- AView = Ember.View.extend({
- click: function(event) {
- // will be called when 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
- descendent views.
-
- ```javascript
- AView = Ember.View.extend({
- eventManager: Ember.Object.create({
- doubleClick: function(event, view) {
- // will be called when when an instance's
- // rendered element or any rendering
- // of this views's descendent
- // elements is clicked
- }
- })
- });
- ```
-
- An event defined for an event manager takes precedence over events of the
- same name handled through methods on the view.
-
- ```javascript
- 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 descendent. 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 descendent.
-
- ```javascript
- OuterView = Ember.View.extend({
- template: Ember.Handlebars.compile("outer {{#view InnerView}}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 occured
- }
- })
- });
-
- 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.
- }
- });
- ```
-
- ### Handlebars `{{action}}` Helper
-
- See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_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`
-
- ## Handlebars `{{view}}` Helper
-
- Other `Ember.View` instances can be included as part of a view's template by
- using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view)
- for additional information.
-
- @class View
- @namespace Ember
- @extends Ember.CoreView
- */
- var View = CoreView.extend({
-
- concatenatedProperties: ['classNames', 'classNameBindings', 'attributeBindings'],
-
- /**
- @property isView
- @type Boolean
- @default true
- @static
- */
- isView: true,
-
- // ..........................................................
- // TEMPLATE SUPPORT
- //
-
- /**
- The name of the template to lookup if no template is provided.
-
- By default `Ember.View` will lookup a template with this name in
- `Ember.TEMPLATES` (a shared global object).
-
- @property templateName
- @type String
- @default null
- */
- templateName: null,
-
- /**
- The name of the layout to lookup if no layout is provided.
-
- By default `Ember.View` will lookup a template with this name in
- `Ember.TEMPLATES` (a shared global object).
-
- @property layoutName
- @type String
- @default null
- */
- layoutName: null,
-
- /**
- Used to identify this view during debugging
-
- @property instrumentDisplay
- @type String
- */
- instrumentDisplay: computed(function() {
- if (this.helperName) {
- return '{{' + this.helperName + '}}';
- }
- }),
-
- /**
- The template used to render the view. This should be a function that
- accepts an optional context parameter and returns a string of HTML that
- will be inserted into the DOM relative to its parent view.
-
- In general, you should set the `templateName` property instead of setting
- the template yourself.
-
- @property template
- @type Function
- */
- template: computed('templateName', function(key, value) {
- if (value !== undefined) { return value; }
-
- var templateName = get(this, 'templateName'),
- template = this.templateForName(templateName, 'template');
-
- Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || template);
-
- return template || get(this, 'defaultTemplate');
- }),
-
- /**
- The controller managing this view. If this property is set, it will be
- made available for use by the template.
-
- @property controller
- @type Object
- */
- controller: computed('_parentView', function(key) {
- var parentView = get(this, '_parentView');
- return parentView ? get(parentView, 'controller') : null;
- }),
-
- /**
- A view may contain a layout. A layout is a regular template but
- supersedes the `template` property during rendering. It is the
- responsibility of the layout template to retrieve the `template`
- property from the view (or alternatively, call `Handlebars.helpers.yield`,
- `{{yield}}`) to render it in the correct location.
-
- This is useful for a view that has a shared wrapper, but which delegates
- the rendering of the contents of the wrapper to the `template` property
- on a subclass.
-
- @property layout
- @type Function
- */
- layout: computed(function(key) {
- var layoutName = get(this, 'layoutName'),
- layout = this.templateForName(layoutName, 'layout');
-
- Ember.assert("You specified the layoutName " + layoutName + " for " + this + ", but it did not exist.", !layoutName || layout);
-
- return layout || get(this, 'defaultLayout');
- }).property('layoutName'),
-
- _yield: function(context, options) {
- var template = get(this, 'template');
- if (template) { template(context, options); }
- },
-
- templateForName: function(name, type) {
- if (!name) { return; }
- Ember.assert("templateNames are not allowed to contain periods: "+name, name.indexOf('.') === -1);
-
- // the defaultContainer is deprecated
- var container = this.container || (Container && Container.defaultContainer);
- return container && container.lookup('template:' + name);
- },
-
- /**
- The object from which templates should access properties.
-
- This object will be passed to the template function each time the render
- method is called, but it is up to the individual function to decide what
- to do with it.
-
- By default, this will be the view's controller.
-
- @property context
- @type Object
- */
- context: computed(function(key, value) {
- if (arguments.length === 2) {
- set(this, '_context', value);
- return value;
- } else {
- return get(this, '_context');
- }
- }).volatile(),
-
- /**
- Private copy of the view's template context. This can be set directly
- by Handlebars without triggering the observer that causes the view
- to be re-rendered.
-
- The context of a view is looked up as follows:
-
- 1. Supplied context (usually by Handlebars)
- 2. Specified controller
- 3. `parentView`'s context (for a child of a ContainerView)
-
- The code in Handlebars that overrides the `_context` property first
- checks to see whether the view has a specified controller. This is
- something of a hack and should be revisited.
-
- @property _context
- @private
- */
- _context: computed(function(key) {
- var parentView, controller;
-
- if (controller = get(this, 'controller')) {
- return controller;
- }
-
- parentView = this._parentView;
- if (parentView) {
- return get(parentView, '_context');
- }
-
- return null;
- }),
-
- /**
- If a value that affects template rendering changes, the view should be
- re-rendered to reflect the new value.
-
- @method _contextDidChange
- @private
- */
- _contextDidChange: observer('context', function() {
- this.rerender();
- }),
-
- /**
- If `false`, the view will appear hidden in DOM.
-
- @property isVisible
- @type Boolean
- @default null
- */
- isVisible: true,
-
- /**
- Array of child views. You should never edit this array directly.
- Instead, use `appendChild` and `removeFromParent`.
-
- @property childViews
- @type Array
- @default []
- @private
- */
- childViews: childViewsProperty,
-
- _childViews: EMPTY_ARRAY,
-
- // When it's a virtual view, we need to notify the parent that their
- // childViews will change.
- _childViewsWillChange: beforeObserver('childViews', function() {
- if (this.isVirtual) {
- var parentView = get(this, 'parentView');
- if (parentView) { propertyWillChange(parentView, 'childViews'); }
- }
- }),
-
- // When it's a virtual view, we need to notify the parent that their
- // childViews did change.
- _childViewsDidChange: observer('childViews', function() {
- if (this.isVirtual) {
- var parentView = get(this, 'parentView');
- if (parentView) { propertyDidChange(parentView, 'childViews'); }
- }
- }),
-
- /**
- Return the nearest ancestor that is an instance of the provided
- class.
-
- @method nearestInstanceOf
- @param {Class} klass Subclass of Ember.View (or Ember.View itself)
- @return Ember.View
- @deprecated
- */
- nearestInstanceOf: function(klass) {
- Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType.");
- var view = get(this, 'parentView');
-
- while (view) {
- if (view instanceof klass) { return view; }
- view = get(view, 'parentView');
- }
- },
-
- /**
- Return the nearest ancestor that is an instance of the provided
- class or mixin.
-
- @method nearestOfType
- @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself),
- or an instance of Ember.Mixin.
- @return Ember.View
- */
- nearestOfType: function(klass) {
- var view = get(this, 'parentView'),
- isOfType = klass instanceof Mixin ?
- function(view) { return klass.detect(view); } :
- function(view) { return klass.detect(view.constructor); };
-
- while (view) {
- if (isOfType(view)) { return view; }
- view = get(view, 'parentView');
- }
- },
-
- /**
- Return the nearest ancestor that has a given property.
-
- @method nearestWithProperty
- @param {String} property A property name
- @return Ember.View
- */
- nearestWithProperty: function(property) {
- var view = get(this, 'parentView');
-
- while (view) {
- if (property in view) { return view; }
- view = get(view, 'parentView');
- }
- },
-
- /**
- Return the nearest ancestor whose parent is an instance of
- `klass`.
-
- @method nearestChildOf
- @param {Class} klass Subclass of Ember.View (or Ember.View itself)
- @return Ember.View
- */
- nearestChildOf: function(klass) {
- var view = get(this, 'parentView');
-
- while (view) {
- if (get(view, 'parentView') instanceof klass) { return view; }
- view = get(view, 'parentView');
- }
- },
-
- /**
- When the parent view changes, recursively invalidate `controller`
-
- @method _parentViewDidChange
- @private
- */
- _parentViewDidChange: observer('_parentView', function() {
- if (this.isDestroying) { return; }
-
- this.trigger('parentViewDidChange');
-
- if (get(this, 'parentView.controller') && !get(this, 'controller')) {
- this.notifyPropertyChange('controller');
- }
- }),
-
- _controllerDidChange: observer('controller', function() {
- if (this.isDestroying) { return; }
-
- this.rerender();
-
- this.forEachChildView(function(view) {
- view.propertyDidChange('controller');
- });
- }),
-
- cloneKeywords: function() {
- var templateData = get(this, 'templateData');
-
- var keywords = templateData ? copy(templateData.keywords) : {};
- set(keywords, 'view', get(this, 'concreteView'));
- set(keywords, '_view', this);
- set(keywords, 'controller', get(this, 'controller'));
-
- return keywords;
- },
-
- /**
- Called on your view when it should push strings of HTML into a
- `Ember.RenderBuffer`. Most users will want to override the `template`
- or `templateName` properties instead of this method.
-
- By default, `Ember.View` will look for a function in the `template`
- property and invoke it with the value of `context`. The value of
- `context` will be the view's controller unless you override it.
-
- @method render
- @param {Ember.RenderBuffer} buffer The render buffer
- */
- render: function(buffer) {
- // If this view has a layout, it is the responsibility of the
- // the layout to render the view's template. Otherwise, render the template
- // directly.
- var template = get(this, 'layout') || get(this, 'template');
-
- if (template) {
- var context = get(this, 'context');
- var keywords = this.cloneKeywords();
- var output;
-
- var data = {
- view: this,
- buffer: buffer,
- isRenderData: true,
- keywords: keywords,
- insideGroup: get(this, 'templateData.insideGroup')
- };
-
- // Invoke the template with the provided template context, which
- // is the view's controller by default. A hash of data is also passed that provides
- // the template with access to the view and render buffer.
-
- Ember.assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function');
- // The template should write directly to the render buffer instead
- // of returning a string.
- output = template(context, { data: data });
-
- // If the template returned a string instead of writing to the buffer,
- // push the string onto the buffer.
- if (output !== undefined) { buffer.push(output); }
- }
- },
-
- /**
- Renders the view again. This will work regardless of whether the
- view is already in the DOM or not. If the view is in the DOM, the
- rendering process will be deferred to give bindings a chance
- to synchronize.
-
- If children were added during the rendering process using `appendChild`,
- `rerender` will remove them, because they will be added again
- if needed by the next `render`.
-
- In general, if the display of your view changes, you should modify
- the DOM element directly instead of manually calling `rerender`, which can
- be slow.
-
- @method rerender
- */
- rerender: function() {
- return this.currentState.rerender(this);
- },
-
- clearRenderedChildren: function() {
- var lengthBefore = this.lengthBeforeRender,
- lengthAfter = this.lengthAfterRender;
-
- // If there were child views created during the last call to render(),
- // remove them under the assumption that they will be re-created when
- // we re-render.
-
- // VIEW-TODO: Unit test this path.
- var childViews = this._childViews;
- for (var i=lengthAfter-1; i>=lengthBefore; i--) {
- if (childViews[i]) { childViews[i].destroy(); }
- }
- },
-
- /**
- Iterates over the view's `classNameBindings` array, inserts the value
- of the specified property into the `classNames` array, then creates an
- observer to update the view's element if the bound property ever changes
- in the future.
-
- @method _applyClassNameBindings
- @private
- */
- _applyClassNameBindings: function(classBindings) {
- var classNames = this.classNames,
- elem, newClass, dasherizedClass;
-
- // Loop through all of the configured bindings. These will be either
- // property names ('isUrgent') or property paths relative to the view
- // ('content.isUrgent')
- a_forEach(classBindings, function(binding) {
-
- Ember.assert("classNameBindings must not have spaces in them. Multiple class name bindings can be provided as elements of an array, e.g. ['foo', ':bar']", binding.indexOf(' ') === -1);
-
- // Variable in which the old class value is saved. The observer function
- // closes over this variable, so it knows which string to remove when
- // the property changes.
- var oldClass;
- // Extract just the property name from bindings like 'foo:bar'
- var parsedPath = View._parsePropertyPath(binding);
-
- // Set up an observer on the context. If the property changes, toggle the
- // class name.
- var observer = function() {
- // Get the current value of the property
- newClass = this._classStringForProperty(binding);
- elem = this.$();
-
- // If we had previously added a class to the element, remove it.
- if (oldClass) {
- elem.removeClass(oldClass);
- // Also remove from classNames so that if the view gets rerendered,
- // the class doesn't get added back to the DOM.
- classNames.removeObject(oldClass);
- }
-
- // If necessary, add a new class. Make sure we keep track of it so
- // it can be removed in the future.
- if (newClass) {
- elem.addClass(newClass);
- oldClass = newClass;
- } else {
- oldClass = null;
- }
- };
-
- // Get the class name for the property at its current value
- dasherizedClass = this._classStringForProperty(binding);
-
- if (dasherizedClass) {
- // Ensure that it gets into the classNames array
- // so it is displayed when we render.
- a_addObject(classNames, dasherizedClass);
-
- // Save a reference to the class name so we can remove it
- // if the observer fires. Remember that this variable has
- // been closed over by the observer.
- oldClass = dasherizedClass;
- }
-
- this.registerObserver(this, parsedPath.path, observer);
- // Remove className so when the view is rerendered,
- // the className is added based on binding reevaluation
- this.one('willClearRender', function() {
- if (oldClass) {
- classNames.removeObject(oldClass);
- oldClass = null;
- }
- });
-
- }, this);
- },
-
- _unspecifiedAttributeBindings: null,
-
- /**
- Iterates through the view's attribute bindings, sets up observers for each,
- then applies the current value of the attributes to the passed render buffer.
-
- @method _applyAttributeBindings
- @param {Ember.RenderBuffer} buffer
- @private
- */
- _applyAttributeBindings: function(buffer, attributeBindings) {
- var attributeValue,
- unspecifiedAttributeBindings = this._unspecifiedAttributeBindings = this._unspecifiedAttributeBindings || {};
-
- a_forEach(attributeBindings, function(binding) {
- var split = binding.split(':'),
- property = split[0],
- attributeName = split[1] || property;
-
- if (property in this) {
- this._setupAttributeBindingObservation(property, attributeName);
-
- // Determine the current value and add it to the render buffer
- // if necessary.
- attributeValue = get(this, property);
- View.applyAttributeBindings(buffer, attributeName, attributeValue);
- } else {
- unspecifiedAttributeBindings[property] = attributeName;
- }
- }, this);
-
- // Lazily setup setUnknownProperty after attributeBindings are initially applied
- this.setUnknownProperty = this._setUnknownProperty;
- },
-
- _setupAttributeBindingObservation: function(property, attributeName) {
- var attributeValue, elem;
-
- // Create an observer to add/remove/change the attribute if the
- // JavaScript property changes.
- var observer = function() {
- elem = this.$();
-
- attributeValue = get(this, property);
-
- View.applyAttributeBindings(elem, attributeName, attributeValue);
- };
-
- this.registerObserver(this, property, observer);
- },
-
- /**
- We're using setUnknownProperty as a hook to setup attributeBinding observers for
- properties that aren't defined on a view at initialization time.
-
- Note: setUnknownProperty will only be called once for each property.
-
- @method setUnknownProperty
- @param key
- @param value
- @private
- */
- setUnknownProperty: null, // Gets defined after initialization by _applyAttributeBindings
-
- _setUnknownProperty: function(key, value) {
- var attributeName = this._unspecifiedAttributeBindings && this._unspecifiedAttributeBindings[key];
- if (attributeName) {
- this._setupAttributeBindingObservation(key, attributeName);
- }
-
- defineProperty(this, key);
- return set(this, key, value);
- },
-
- /**
- Given a property name, returns a dasherized version of that
- property name if the property evaluates to a non-falsy value.
-
- For example, if the view has property `isUrgent` that evaluates to true,
- passing `isUrgent` to this method will return `"is-urgent"`.
-
- @method _classStringForProperty
- @param property
- @private
- */
- _classStringForProperty: function(property) {
- var parsedPath = View._parsePropertyPath(property);
- var path = parsedPath.path;
-
- var val = get(this, path);
- if (val === undefined && isGlobalPath(path)) {
- val = get(Ember.lookup, path);
- }
-
- return View._classStringForValue(path, val, parsedPath.className, parsedPath.falsyClassName);
- },
-
- // ..........................................................
- // ELEMENT SUPPORT
- //
-
- /**
- Returns the current DOM element for the view.
-
- @property element
- @type DOMElement
- */
- element: computed('_parentView', function(key, value) {
- if (value !== undefined) {
- return this.currentState.setElement(this, value);
- } else {
- return this.currentState.getElement(this);
- }
- }),
-
- /**
- Returns a jQuery object for this view's element. If you pass in a selector
- string, this method will return a jQuery object, using the current element
- as its buffer.
-
- For example, calling `view.$('li')` will return a jQuery object containing
- all of the `li` elements inside the DOM element of this view.
-
- @method $
- @param {String} [selector] a jQuery-compatible selector string
- @return {jQuery} the jQuery object for the DOM node
- */
- $: function(sel) {
- return this.currentState.$(this, sel);
- },
-
- mutateChildViews: function(callback) {
- var childViews = this._childViews,
- idx = childViews.length,
- view;
-
- while(--idx >= 0) {
- view = childViews[idx];
- callback(this, view, idx);
- }
-
- return this;
- },
-
- forEachChildView: function(callback) {
- var childViews = this._childViews;
-
- if (!childViews) { return this; }
-
- var len = childViews.length,
- view, idx;
-
- for (idx = 0; idx < len; idx++) {
- view = childViews[idx];
- callback(view);
- }
-
- return this;
- },
-
- /**
- Appends the view's element to the specified parent element.
-
- If the view does not have an HTML representation yet, `createElement()`
- will be called automatically.
-
- Note that this method just schedules the view to be appended; the DOM
- element will not be appended to the given element until all bindings have
- finished synchronizing.
-
- This is not typically a function that you will need to call directly when
- building your application. You might consider using `Ember.ContainerView`
- instead. If you do need to use `appendTo`, be sure that the target element
- you are providing is associated with an `Ember.Application` and does not
- have an ancestor element that is associated with an Ember view.
-
- @method appendTo
- @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
- @return {Ember.View} receiver
- */
- appendTo: function(target) {
- // Schedule the DOM element to be created and appended to the given
- // element after bindings have synchronized.
- this._insertElementLater(function() {
- Ember.assert("You tried to append to (" + target + ") but that isn't in the DOM", jQuery(target).length > 0);
- Ember.assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !jQuery(target).is('.ember-view') && !jQuery(target).parents().is('.ember-view'));
- this.$().appendTo(target);
- });
-
- return this;
- },
-
- /**
- Replaces the content of the specified parent element with this view's
- element. If the view does not have an HTML representation yet,
- `createElement()` will be called automatically.
-
- Note that this method just schedules the view to be appended; the DOM
- element will not be appended to the given element until all bindings have
- finished synchronizing
-
- @method replaceIn
- @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object
- @return {Ember.View} received
- */
- replaceIn: function(target) {
- Ember.assert("You tried to replace in (" + target + ") but that isn't in the DOM", jQuery(target).length > 0);
- Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !jQuery(target).is('.ember-view') && !jQuery(target).parents().is('.ember-view'));
-
- this._insertElementLater(function() {
- jQuery(target).empty();
- this.$().appendTo(target);
- });
-
- return this;
- },
-
- /**
- Schedules a DOM operation to occur during the next render phase. This
- ensures that all bindings have finished synchronizing before the view is
- rendered.
-
- To use, pass a function that performs a DOM operation.
-
- Before your function is called, this view and all child views will receive
- the `willInsertElement` event. After your function is invoked, this view
- and all of its child views will receive the `didInsertElement` event.
-
- ```javascript
- view._insertElementLater(function() {
- this.createElement();
- this.$().appendTo('body');
- });
- ```
-
- @method _insertElementLater
- @param {Function} fn the function that inserts the element into the DOM
- @private
- */
- _insertElementLater: function(fn) {
- this._scheduledInsert = run.scheduleOnce('render', this, '_insertElement', fn);
- },
-
- _insertElement: function (fn) {
- this._scheduledInsert = null;
- this.currentState.insertElement(this, fn);
- },
-
- /**
- Appends the view's element to the document body. If the view does
- not have an HTML representation yet, `createElement()` will be called
- automatically.
-
- If your application uses the `rootElement` property, you must append
- the view within that element. Rendering views outside of the `rootElement`
- is not supported.
-
- Note that this method just schedules the view to be appended; the DOM
- element will not be appended to the document body until all bindings have
- finished synchronizing.
-
- @method append
- @return {Ember.View} receiver
- */
- append: function() {
- return this.appendTo(document.body);
- },
-
- /**
- Removes the view's element from the element to which it is attached.
-
- @method remove
- @return {Ember.View} receiver
- */
- remove: function() {
- // What we should really do here is wait until the end of the run loop
- // to determine if the element has been re-appended to a different
- // element.
- // In the interim, we will just re-render if that happens. It is more
- // important than elements get garbage collected.
- if (!this.removedFromDOM) { this.destroyElement(); }
- this.invokeRecursively(function(view) {
- if (view.clearRenderedChildren) { view.clearRenderedChildren(); }
- });
- },
-
- elementId: null,
-
- /**
- Attempts to discover the element in the parent element. The default
- implementation looks for an element with an ID of `elementId` (or the
- view's guid if `elementId` is null). You can override this method to
- provide your own form of lookup. For example, if you want to discover your
- element using a CSS class name instead of an ID.
-
- @method findElementInParentElement
- @param {DOMElement} parentElement The parent's DOM element
- @return {DOMElement} The discovered element
- */
- findElementInParentElement: function(parentElem) {
- var id = "#" + this.elementId;
- return jQuery(id)[0] || jQuery(id, parentElem)[0];
- },
-
- /**
- Creates a DOM representation of the view and all of its
- child views by recursively calling the `render()` method.
-
- After the element has been created, `didInsertElement` will
- be called on this view and all of its child views.
-
- @method createElement
- @return {Ember.View} receiver
- */
- createElement: function() {
- if (get(this, 'element')) { return this; }
-
- var buffer = this.renderToBuffer();
- set(this, 'element', buffer.element());
-
- return this;
- },
-
- /**
- Called when a view is going to insert an element into the DOM.
-
- @event willInsertElement
- */
- willInsertElement: Ember.K,
-
- /**
- Called when the element of the view has been inserted into the DOM
- or after the view was re-rendered. Override this function to do any
- set up that requires an element in the document body.
-
- @event didInsertElement
- */
- didInsertElement: Ember.K,
-
- /**
- Called when the view is about to rerender, but before anything has
- been torn down. This is a good opportunity to tear down any manual
- observers you have installed based on the DOM state
-
- @event willClearRender
- */
- willClearRender: Ember.K,
-
- /**
- Run this callback on the current view (unless includeSelf is false) and recursively on child views.
-
- @method invokeRecursively
- @param fn {Function}
- @param includeSelf {Boolean} Includes itself if true.
- @private
- */
- invokeRecursively: function(fn, includeSelf) {
- var childViews = (includeSelf === false) ? this._childViews : [this];
- var currentViews, view, currentChildViews;
-
- while (childViews.length) {
- currentViews = childViews.slice();
- childViews = [];
-
- for (var i=0, l=currentViews.length; i
- I got wrapped
-
-
- Ember.View.extend({
- attributeBindings: ['type'],
- type: 'button'
- });
- ```
-
- If the value of the property is a Boolean, the name of that property is
- added as an attribute.
-
- ```javascript
- // Renders something like
- Ember.View.extend({
- attributeBindings: ['enabled'],
- enabled: true
- });
- ```
-
- @property attributeBindings
- */
- attributeBindings: EMPTY_ARRAY,
-
- // .......................................................
- // CORE DISPLAY METHODS
- //
-
- /**
- Setup a view, but do not finish waking it up.
-
- * configure `childViews`
- * register the view with the global views hash, which is used for event
- dispatch
-
- @method init
- @private
- */
- init: function() {
- this.elementId = this.elementId || guidFor(this);
-
- this._super();
-
- // setup child views. be sure to clone the child views array first
- this._childViews = this._childViews.slice();
-
- Ember.assert("Only arrays are allowed for 'classNameBindings'", typeOf(this.classNameBindings) === 'array');
- this.classNameBindings = A(this.classNameBindings.slice());
-
- Ember.assert("Only arrays are allowed for 'classNames'", typeOf(this.classNames) === 'array');
- this.classNames = A(this.classNames.slice());
- },
-
- appendChild: function(view, options) {
- return this.currentState.appendChild(this, view, options);
- },
-
- /**
- Removes the child view from the parent view.
-
- @method removeChild
- @param {Ember.View} view
- @return {Ember.View} receiver
- */
- removeChild: function(view) {
- // If we're destroying, the entire subtree will be
- // freed, and the DOM will be handled separately,
- // so no need to mess with childViews.
- if (this.isDestroying) { return; }
-
- // update parent node
- set(view, '_parentView', null);
-
- // remove view from childViews array.
- var childViews = this._childViews;
-
- a_removeObject(childViews, view);
-
- this.propertyDidChange('childViews'); // HUH?! what happened to will change?
-
- return this;
- },
-
- /**
- Removes all children from the `parentView`.
-
- @method removeAllChildren
- @return {Ember.View} receiver
- */
- removeAllChildren: function() {
- return this.mutateChildViews(function(parentView, view) {
- parentView.removeChild(view);
- });
- },
-
- destroyAllChildren: function() {
- return this.mutateChildViews(function(parentView, view) {
- view.destroy();
- });
- },
-
- /**
- Removes the view from its `parentView`, if one is found. Otherwise
- does nothing.
-
- @method removeFromParent
- @return {Ember.View} receiver
- */
- removeFromParent: function() {
- var parent = this._parentView;
-
- // Remove DOM element from parent
- this.remove();
-
- if (parent) { parent.removeChild(this); }
- return this;
- },
-
- /**
- You must call `destroy` on a view to destroy the view (and all of its
- child views). This will remove the view from any parent node, then make
- sure that the DOM element managed by the view can be released by the
- memory manager.
-
- @method destroy
- */
- destroy: function() {
- var childViews = this._childViews,
- // get parentView before calling super because it'll be destroyed
- nonVirtualParentView = get(this, 'parentView'),
- viewName = this.viewName,
- childLen, i;
-
- if (!this._super()) { return; }
-
- childLen = childViews.length;
- for (i=childLen-1; i>=0; i--) {
- childViews[i].removedFromDOM = true;
- }
-
- // remove from non-virtual parent view if viewName was specified
- if (viewName && nonVirtualParentView) {
- nonVirtualParentView.set(viewName, null);
- }
-
- childLen = childViews.length;
- for (i=childLen-1; i>=0; i--) {
- childViews[i].destroy();
- }
-
- return this;
- },
-
- /**
- Instantiates a view to be added to the childViews array during view
- initialization. You generally will not call this method directly unless
- you are overriding `createChildViews()`. Note that this method will
- automatically configure the correct settings on the new view instance to
- act as a child of the parent.
-
- @method createChildView
- @param {Class|String} viewClass
- @param {Hash} [attrs] Attributes to add
- @return {Ember.View} new instance
- */
- createChildView: function(view, attrs) {
- if (!view) {
- throw new TypeError("createChildViews first argument must exist");
- }
-
- if (view.isView && view._parentView === this && view.container === this.container) {
- return view;
- }
-
- attrs = attrs || {};
- attrs._parentView = this;
-
- if (CoreView.detect(view)) {
- attrs.templateData = attrs.templateData || get(this, 'templateData');
-
- attrs.container = this.container;
- view = view.create(attrs);
-
- // don't set the property on a virtual view, as they are invisible to
- // consumers of the view API
- if (view.viewName) {
- set(get(this, 'concreteView'), view.viewName, view);
- }
- } else if ('string' === typeof view) {
- var fullName = 'view:' + view;
- var ViewKlass = this.container.lookupFactory(fullName);
-
- Ember.assert("Could not find view: '" + fullName + "'", !!ViewKlass);
-
- attrs.templateData = get(this, 'templateData');
- view = ViewKlass.create(attrs);
- } else {
- Ember.assert('You must pass instance or subclass of View', view.isView);
- attrs.container = this.container;
-
- if (!get(view, 'templateData')) {
- attrs.templateData = get(this, 'templateData');
- }
-
- setProperties(view, attrs);
-
- }
-
- return view;
- },
-
- becameVisible: Ember.K,
- becameHidden: Ember.K,
-
- /**
- When the view's `isVisible` property changes, toggle the visibility
- element of the actual DOM element.
-
- @method _isVisibleDidChange
- @private
- */
- _isVisibleDidChange: observer('isVisible', function() {
- if (this._isVisible === get(this, 'isVisible')) { return ; }
- run.scheduleOnce('render', this, this._toggleVisibility);
- }),
-
- _toggleVisibility: function() {
- var $el = this.$();
- if (!$el) { return; }
-
- var isVisible = get(this, 'isVisible');
-
- if (this._isVisible === isVisible) { return ; }
-
- $el.toggle(isVisible);
-
- this._isVisible = isVisible;
-
- if (this._isAncestorHidden()) { return; }
-
- if (isVisible) {
- this._notifyBecameVisible();
- } else {
- this._notifyBecameHidden();
- }
- },
-
- _notifyBecameVisible: function() {
- this.trigger('becameVisible');
-
- this.forEachChildView(function(view) {
- var isVisible = get(view, 'isVisible');
-
- if (isVisible || isVisible === null) {
- view._notifyBecameVisible();
- }
- });
- },
-
- _notifyBecameHidden: function() {
- this.trigger('becameHidden');
- this.forEachChildView(function(view) {
- var isVisible = get(view, 'isVisible');
-
- if (isVisible || isVisible === null) {
- view._notifyBecameHidden();
- }
- });
- },
-
- _isAncestorHidden: function() {
- var parent = get(this, 'parentView');
-
- while (parent) {
- if (get(parent, 'isVisible') === false) { return true; }
-
- parent = get(parent, 'parentView');
- }
-
- return false;
- },
-
- clearBuffer: function() {
- this.invokeRecursively(nullViewsBuffer);
- },
-
- transitionTo: function(state, children) {
- var priorState = this.currentState,
- currentState = this.currentState = this.states[state];
- this.state = state;
-
- if (priorState && priorState.exit) { priorState.exit(this); }
- if (currentState.enter) { currentState.enter(this); }
- if (state === 'inDOM') { meta(this).cache.element = undefined; }
-
- if (children !== false) {
- this.forEachChildView(function(view) {
- view.transitionTo(state);
- });
- }
- },
-
- // .......................................................
- // EVENT HANDLING
- //
-
- /**
- Handle events from `Ember.EventDispatcher`
-
- @method handleEvent
- @param eventName {String}
- @param evt {Event}
- @private
- */
- handleEvent: function(eventName, evt) {
- return this.currentState.handleEvent(this, eventName, evt);
- },
-
- registerObserver: function(root, path, target, observer) {
- if (!observer && 'function' === typeof target) {
- observer = target;
- target = null;
- }
-
- if (!root || typeof root !== 'object') {
- return;
- }
-
- var view = this,
- stateCheckedObserver = function() {
- view.currentState.invokeObserver(this, observer);
- },
- scheduledObserver = function() {
- run.scheduleOnce('render', this, stateCheckedObserver);
- };
-
- addObserver(root, path, target, scheduledObserver);
-
- this.one('willClearRender', function() {
- removeObserver(root, path, target, scheduledObserver);
- });
- }
-
- });
-
- /*
- Describe how the specified actions should behave in the various
- states that a view can exist in. Possible states:
-
- * preRender: when a view is first instantiated, and after its
- element was destroyed, it is in the preRender state
- * inBuffer: once a view has been rendered, but before it has
- been inserted into the DOM, it is in the inBuffer state
- * hasElement: the DOM representation of the view is created,
- and is ready to be inserted
- * inDOM: once a view has been inserted into the DOM it is in
- the inDOM state. A view spends the vast majority of its
- existence in this state.
- * destroyed: once a view has been destroyed (using the destroy
- method), it is in this state. No further actions can be invoked
- on a destroyed view.
- */
-
- // in the destroyed state, everything is illegal
-
- // before rendering has begun, all legal manipulations are noops.
-
- // inside the buffer, legal manipulations are done on the buffer
-
- // once the view has been inserted into the DOM, legal manipulations
- // are done on the DOM element.
-
- function notifyMutationListeners() {
- run.once(View, 'notifyMutationListeners');
- }
-
- var DOMManager = {
- prepend: function(view, html) {
- view.$().prepend(html);
- notifyMutationListeners();
- },
-
- after: function(view, html) {
- view.$().after(html);
- notifyMutationListeners();
- },
-
- html: function(view, html) {
- view.$().html(html);
- notifyMutationListeners();
- },
-
- replace: function(view) {
- var element = get(view, 'element');
-
- set(view, 'element', null);
-
- view._insertElementLater(function() {
- jQuery(element).replaceWith(get(view, 'element'));
- notifyMutationListeners();
- });
- },
-
- remove: function(view) {
- view.$().remove();
- notifyMutationListeners();
- },
-
- empty: function(view) {
- view.$().empty();
- notifyMutationListeners();
- }
- };
-
- View.reopen({
- domManager: DOMManager
- });
-
- View.reopenClass({
-
- /**
- Parse a path and return an object which holds the parsed properties.
-
- For example a path like "content.isEnabled:enabled:disabled" will return the
- following object:
-
- ```javascript
- {
- path: "content.isEnabled",
- className: "enabled",
- falsyClassName: "disabled",
- classNames: ":enabled:disabled"
- }
- ```
-
- @method _parsePropertyPath
- @static
- @private
- */
- _parsePropertyPath: function(path) {
- var split = path.split(':'),
- propertyPath = split[0],
- classNames = "",
- className,
- falsyClassName;
-
- // check if the property is defined as prop:class or prop:trueClass:falseClass
- if (split.length > 1) {
- className = split[1];
- if (split.length === 3) { falsyClassName = split[2]; }
-
- classNames = ':' + className;
- if (falsyClassName) { classNames += ":" + falsyClassName; }
- }
-
- return {
- path: propertyPath,
- classNames: classNames,
- className: (className === '') ? undefined : className,
- falsyClassName: falsyClassName
- };
- },
-
- /**
- Get the class name for a given value, based on the path, optional
- `className` and optional `falsyClassName`.
-
- - if a `className` or `falsyClassName` has been specified:
- - if the value is truthy and `className` has been specified,
- `className` is returned
- - if the value is falsy and `falsyClassName` has been specified,
- `falsyClassName` is returned
- - otherwise `null` is returned
- - if the value is `true`, the dasherized last part of the supplied path
- is returned
- - if the value is not `false`, `undefined` or `null`, the `value`
- is returned
- - if none of the above rules apply, `null` is returned
-
- @method _classStringForValue
- @param path
- @param val
- @param className
- @param falsyClassName
- @static
- @private
- */
- _classStringForValue: function(path, val, className, falsyClassName) {
- if(isArray(val)) {
- val = get(val, 'length') !== 0;
- }
-
- // When using the colon syntax, evaluate the truthiness or falsiness
- // of the value to determine which className to return
- if (className || falsyClassName) {
- if (className && !!val) {
- return className;
-
- } else if (falsyClassName && !val) {
- return falsyClassName;
-
- } else {
- return null;
- }
-
- // If value is a Boolean and true, return the dasherized property
- // name.
- } else if (val === true) {
- // Normalize property path to be suitable for use
- // as a class name. For exaple, content.foo.barBaz
- // becomes bar-baz.
- var parts = path.split('.');
- return dasherize(parts[parts.length-1]);
-
- // If the value is not false, undefined, or null, return the current
- // value of the property.
- } else if (val !== false && val != null) {
- return val;
-
- // Nothing to display. Return null so that the old class is removed
- // but no new class is added.
- } else {
- return null;
- }
- }
- });
-
- var mutation = EmberObject.extend(Evented).create();
-
- View.addMutationListener = function(callback) {
- mutation.on('change', callback);
- };
-
- View.removeMutationListener = function(callback) {
- mutation.off('change', callback);
- };
-
- View.notifyMutationListeners = function() {
- mutation.trigger('change');
- };
-
- /**
- Global views hash
-
- @property views
- @static
- @type Hash
- */
- View.views = {};
-
- // If someone overrides the child views computed property when
- // defining their class, we want to be able to process the user's
- // supplied childViews and then restore the original computed property
- // at view initialization time. This happens in Ember.ContainerView's init
- // method.
- View.childViewsProperty = childViewsProperty;
-
- View.applyAttributeBindings = function(elem, name, value) {
- var type = typeOf(value);
-
- // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js
- if (name !== 'value' && (type === 'string' || (type === 'number' && !isNaN(value)))) {
- if (value !== elem.attr(name)) {
- elem.attr(name, value);
- }
- } else if (name === 'value' || type === 'boolean') {
- if (isNone(value) || value === false) {
- // `null`, `undefined` or `false` should remove attribute
- elem.removeAttr(name);
- elem.prop(name, '');
- } else if (value !== elem.prop(name)) {
- // value should always be properties
- elem.prop(name, value);
- }
- } else if (!value) {
- elem.removeAttr(name);
- }
- };
-
- __exports__.CoreView = CoreView;
- __exports__.View = View;
- __exports__.ViewCollection = ViewCollection;
- });
-})();
-
-(function() {
-define("metamorph",
- [],
- function() {
- "use strict";
- // ==========================================================================
- // Project: metamorph
- // Copyright: ©2014 Tilde, Inc. All rights reserved.
- // ==========================================================================
-
- var K = function() {},
- guid = 0,
- disableRange = (function(){
- if ('undefined' !== typeof MetamorphENV) {
- return MetamorphENV.DISABLE_RANGE_API;
- } else if ('undefined' !== ENV) {
- return ENV.DISABLE_RANGE_API;
- } else {
- return false;
- }
- })(),
-
- // Feature-detect the W3C range API, the extended check is for IE9 which only partially supports ranges
- supportsRange = (!disableRange) && typeof document !== 'undefined' && ('createRange' in document) && (typeof Range !== 'undefined') && Range.prototype.createContextualFragment,
-
- // Internet Explorer prior to 9 does not allow setting innerHTML if the first element
- // is a "zero-scope" element. This problem can be worked around by making
- // the first node an invisible text node. We, like Modernizr, use
- needsShy = typeof document !== 'undefined' && (function() {
- var testEl = document.createElement('div');
- testEl.innerHTML = "";
- testEl.firstChild.innerHTML = "";
- return testEl.firstChild.innerHTML === '';
- })(),
-
-
- // IE 8 (and likely earlier) likes to move whitespace preceeding
- // a script tag to appear after it. This means that we can
- // accidentally remove whitespace when updating a morph.
- movesWhitespace = document && (function() {
- var testEl = document.createElement('div');
- testEl.innerHTML = "Test: Value";
- return testEl.childNodes[0].nodeValue === 'Test:' &&
- testEl.childNodes[2].nodeValue === ' Value';
- })();
-
- // Constructor that supports either Metamorph('foo') or new
- // Metamorph('foo');
- //
- // Takes a string of HTML as the argument.
-
- var Metamorph = function(html) {
- var self;
-
- if (this instanceof Metamorph) {
- self = this;
- } else {
- self = new K();
- }
-
- self.innerHTML = html;
- var myGuid = 'metamorph-'+(guid++);
- self.start = myGuid + '-start';
- self.end = myGuid + '-end';
-
- return self;
- };
-
- K.prototype = Metamorph.prototype;
-
- var rangeFor, htmlFunc, removeFunc, outerHTMLFunc, appendToFunc, afterFunc, prependFunc, startTagFunc, endTagFunc;
-
- outerHTMLFunc = function() {
- return this.startTag() + this.innerHTML + this.endTag();
- };
-
- startTagFunc = function() {
- /*
- * We replace chevron by its hex code in order to prevent escaping problems.
- * Check this thread for more explaination:
- * http://stackoverflow.com/questions/8231048/why-use-x3c-instead-of-when-generating-html-from-javascript
- */
- return "hi . Other browsers create it
- * before the first node, no matter what.
- *
- * This means the the following code:
- *
- * div = document.createElement("div");
- * div.innerHTML = "
- *
- * Generates the following DOM in IE:
- *
- * + div
- * + table
- * - script id='first'
- * + tbody
- * + tr
- * + td
- * - "hi"
- * - script id='last'
- *
- * Which means that the two script tags, even though they were
- * inserted at the same point in the hierarchy in the original
- * HTML, now have different parents.
- *
- * This code reparents the first script tag by making it the tbody's
- * first child.
- *
- */
- var fixParentage = function(start, end) {
- if (start.parentNode !== end.parentNode) {
- end.parentNode.insertBefore(start, end.parentNode.firstChild);
- }
- };
-
- htmlFunc = function(html, outerToo) {
- // get the real starting node. see realNode for details.
- var start = realNode(document.getElementById(this.start));
- var end = document.getElementById(this.end);
- var parentNode = end.parentNode;
- var node, nextSibling, last;
-
- // make sure that the start and end nodes share the same
- // parent. If not, fix it.
- fixParentage(start, end);
-
- // remove all of the nodes after the starting placeholder and
- // before the ending placeholder.
- node = start.nextSibling;
- while (node) {
- nextSibling = node.nextSibling;
- last = node === end;
-
- // if this is the last node, and we want to remove it as well,
- // set the `end` node to the next sibling. This is because
- // for the rest of the function, we insert the new nodes
- // before the end (note that insertBefore(node, null) is
- // the same as appendChild(node)).
- //
- // if we do not want to remove it, just break.
- if (last) {
- if (outerToo) { end = node.nextSibling; } else { break; }
- }
-
- node.parentNode.removeChild(node);
-
- // if this is the last node and we didn't break before
- // (because we wanted to remove the outer nodes), break
- // now.
- if (last) { break; }
-
- node = nextSibling;
- }
-
- // get the first node for the HTML string, even in cases like
- // tables and lists where a simple innerHTML on a div would
- // swallow some of the content.
- node = firstNodeFor(start.parentNode, html);
-
- if (outerToo) {
- start.parentNode.removeChild(start);
- }
-
- // copy the nodes for the HTML between the starting and ending
- // placeholder.
- while (node) {
- nextSibling = node.nextSibling;
- parentNode.insertBefore(node, end);
- node = nextSibling;
- }
- };
-
- // remove the nodes in the DOM representing this metamorph.
- //
- // this includes the starting and ending placeholders.
- removeFunc = function() {
- var start = realNode(document.getElementById(this.start));
- var end = document.getElementById(this.end);
-
- this.html('');
- start.parentNode.removeChild(start);
- end.parentNode.removeChild(end);
- };
-
- appendToFunc = function(parentNode) {
- var node = firstNodeFor(parentNode, this.outerHTML());
- var nextSibling;
-
- while (node) {
- nextSibling = node.nextSibling;
- parentNode.appendChild(node);
- node = nextSibling;
- }
- };
-
- afterFunc = function(html) {
- // get the real starting node. see realNode for details.
- var end = document.getElementById(this.end);
- var insertBefore = end.nextSibling;
- var parentNode = end.parentNode;
- var nextSibling;
- var node;
-
- // get the first node for the HTML string, even in cases like
- // tables and lists where a simple innerHTML on a div would
- // swallow some of the content.
- node = firstNodeFor(parentNode, html);
-
- // copy the nodes for the HTML between the starting and ending
- // placeholder.
- while (node) {
- nextSibling = node.nextSibling;
- parentNode.insertBefore(node, insertBefore);
- node = nextSibling;
- }
- };
-
- prependFunc = function(html) {
- var start = document.getElementById(this.start);
- var parentNode = start.parentNode;
- var nextSibling;
- var node;
-
- node = firstNodeFor(parentNode, html);
- var insertBefore = start.nextSibling;
-
- while (node) {
- nextSibling = node.nextSibling;
- parentNode.insertBefore(node, insertBefore);
- node = nextSibling;
- }
- };
- }
-
- Metamorph.prototype.html = function(html) {
- this.checkRemoved();
- if (html === undefined) { return this.innerHTML; }
-
- htmlFunc.call(this, html);
-
- this.innerHTML = html;
- };
-
- Metamorph.prototype.replaceWith = function(html) {
- this.checkRemoved();
- htmlFunc.call(this, html, true);
- };
-
- Metamorph.prototype.remove = removeFunc;
- Metamorph.prototype.outerHTML = outerHTMLFunc;
- Metamorph.prototype.appendTo = appendToFunc;
- Metamorph.prototype.after = afterFunc;
- Metamorph.prototype.prepend = prependFunc;
- Metamorph.prototype.startTag = startTagFunc;
- Metamorph.prototype.endTag = endTagFunc;
-
- Metamorph.prototype.isRemoved = function() {
- var before = document.getElementById(this.start);
- var after = document.getElementById(this.end);
-
- return !before || !after;
- };
-
- Metamorph.prototype.checkRemoved = function() {
- if (this.isRemoved()) {
- throw new Error("Cannot perform operations on a Metamorph that is not in the DOM.");
- }
- };
-
- return Metamorph;
- });
-
-})();
-
-(function() {
-define("ember-handlebars-compiler",
- ["ember-metal/core","exports"],
- function(__dependency1__, __exports__) {
- "use strict";
- /**
- @module ember
- @submodule ember-handlebars-compiler
- */
-
- var Ember = __dependency1__["default"];
-
- // ES6Todo: you'll need to import debugger once debugger is es6'd.
- if (typeof Ember.assert === 'undefined') { Ember.assert = function(){}; };
- if (typeof Ember.FEATURES === 'undefined') { Ember.FEATURES = { isEnabled: function(){} }; };
-
- var objectCreate = Object.create || function(parent) {
- function F() {}
- F.prototype = parent;
- return new F();
- };
-
- // set up for circular references later
- var View, Component;
-
- // ES6Todo: when ember-debug is es6'ed import this.
- // var emberAssert = Ember.assert;
- var Handlebars = (Ember.imports && Ember.imports.Handlebars) || (this && this.Handlebars);
- if (!Handlebars && typeof require === 'function') {
- Handlebars = require('handlebars');
- }
-
- Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1. Include " +
- "a SCRIPT tag in the HTML HEAD linking to the Handlebars file " +
- "before you link to Ember.", Handlebars);
-
- Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1, " +
- "COMPILER_REVISION expected: 4, got: " + Handlebars.COMPILER_REVISION +
- " - Please note: Builds of master may have other COMPILER_REVISION values.",
- Handlebars.COMPILER_REVISION === 4);
-
- /**
- Prepares the Handlebars templating library for use inside Ember's view
- system.
-
- The `Ember.Handlebars` object is the standard Handlebars library, extended to
- use Ember's `get()` method instead of direct property access, which allows
- computed properties to be used inside templates.
-
- To create an `Ember.Handlebars` template, call `Ember.Handlebars.compile()`.
- This will return a function that can be used by `Ember.View` for rendering.
-
- @class Handlebars
- @namespace Ember
- */
- var EmberHandlebars = Ember.Handlebars = objectCreate(Handlebars);
-
- /**
- Register a bound helper or custom view helper.
-
- ## Simple bound helper example
-
- ```javascript
- Ember.Handlebars.helper('capitalize', function(value) {
- return value.toUpperCase();
- });
- ```
-
- The above bound helper can be used inside of templates as follows:
-
- ```handlebars
- {{capitalize name}}
- ```
-
- In this case, when the `name` property of the template's context changes,
- the rendered value of the helper will update to reflect this change.
-
- For more examples of bound helpers, see documentation for
- `Ember.Handlebars.registerBoundHelper`.
-
- ## Custom view helper example
-
- Assuming a view subclass named `App.CalendarView` were defined, a helper
- for rendering instances of this view could be registered as follows:
-
- ```javascript
- Ember.Handlebars.helper('calendar', App.CalendarView):
- ```
-
- The above bound helper can be used inside of templates as follows:
-
- ```handlebars
- {{calendar}}
- ```
-
- Which is functionally equivalent to:
-
- ```handlebars
- {{view App.CalendarView}}
- ```
-
- Options in the helper will be passed to the view in exactly the same
- manner as with the `view` helper.
-
- @method helper
- @for Ember.Handlebars
- @param {String} name
- @param {Function|Ember.View} function or view class constructor
- @param {String} dependentKeys*
- */
- EmberHandlebars.helper = function(name, value) {
- if (!View) { View = requireModule('ember-views/views/view')['View']; } // ES6TODO: stupid circular dep
- if (!Component) { Component = requireModule('ember-views/views/component')['default']; } // ES6TODO: stupid circular dep
-
- Ember.assert("You tried to register a component named '" + name + "', but component names must include a '-'", !Component.detect(value) || name.match(/-/));
-
- if (View.detect(value)) {
- EmberHandlebars.registerHelper(name, EmberHandlebars.makeViewHelper(value));
- } else {
- EmberHandlebars.registerBoundHelper.apply(null, arguments);
- }
- };
-
- /**
- Returns a helper function that renders the provided ViewClass.
-
- Used internally by Ember.Handlebars.helper and other methods
- involving helper/component registration.
-
- @private
- @method makeViewHelper
- @for Ember.Handlebars
- @param {Function} ViewClass view class constructor
- @since 1.2.0
- */
- EmberHandlebars.makeViewHelper = function(ViewClass) {
- return function(options) {
- Ember.assert("You can only pass attributes (such as name=value) not bare values to a helper for a View found in '" + ViewClass.toString() + "'", arguments.length < 2);
- return EmberHandlebars.helpers.view.call(this, ViewClass, options);
- };
- };
-
- /**
- @class helpers
- @namespace Ember.Handlebars
- */
- EmberHandlebars.helpers = objectCreate(Handlebars.helpers);
-
- /**
- Override the the opcode compiler and JavaScript compiler for Handlebars.
-
- @class Compiler
- @namespace Ember.Handlebars
- @private
- @constructor
- */
- EmberHandlebars.Compiler = function() {};
-
- // Handlebars.Compiler doesn't exist in runtime-only
- if (Handlebars.Compiler) {
- EmberHandlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype);
- }
-
- EmberHandlebars.Compiler.prototype.compiler = EmberHandlebars.Compiler;
-
- /**
- @class JavaScriptCompiler
- @namespace Ember.Handlebars
- @private
- @constructor
- */
- EmberHandlebars.JavaScriptCompiler = function() {};
-
- // Handlebars.JavaScriptCompiler doesn't exist in runtime-only
- if (Handlebars.JavaScriptCompiler) {
- EmberHandlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype);
- EmberHandlebars.JavaScriptCompiler.prototype.compiler = EmberHandlebars.JavaScriptCompiler;
- }
-
-
- EmberHandlebars.JavaScriptCompiler.prototype.namespace = "Ember.Handlebars";
-
- EmberHandlebars.JavaScriptCompiler.prototype.initializeBuffer = function() {
- return "''";
- };
-
- /**
- Override the default buffer for Ember Handlebars. By default, Handlebars
- creates an empty String at the beginning of each invocation and appends to
- it. Ember's Handlebars overrides this to append to a single shared buffer.
-
- @private
- @method appendToBuffer
- @param string {String}
- */
- EmberHandlebars.JavaScriptCompiler.prototype.appendToBuffer = function(string) {
- return "data.buffer.push("+string+");";
- };
-
- // Hacks ahead:
- // Handlebars presently has a bug where the `blockHelperMissing` hook
- // doesn't get passed the name of the missing helper name, but rather
- // gets passed the value of that missing helper evaluated on the current
- // context, which is most likely `undefined` and totally useless.
- //
- // So we alter the compiled template function to pass the name of the helper
- // instead, as expected.
- //
- // This can go away once the following is closed:
- // https://github.com/wycats/handlebars.js/issues/634
-
- var DOT_LOOKUP_REGEX = /helpers\.(.*?)\)/,
- BRACKET_STRING_LOOKUP_REGEX = /helpers\['(.*?)'/,
- INVOCATION_SPLITTING_REGEX = /(.*blockHelperMissing\.call\(.*)(stack[0-9]+)(,.*)/;
-
- EmberHandlebars.JavaScriptCompiler.stringifyLastBlockHelperMissingInvocation = function(source) {
- var helperInvocation = source[source.length - 1],
- helperName = (DOT_LOOKUP_REGEX.exec(helperInvocation) || BRACKET_STRING_LOOKUP_REGEX.exec(helperInvocation))[1],
- matches = INVOCATION_SPLITTING_REGEX.exec(helperInvocation);
-
- source[source.length - 1] = matches[1] + "'" + helperName + "'" + matches[3];
- };
-
- var stringifyBlockHelperMissing = EmberHandlebars.JavaScriptCompiler.stringifyLastBlockHelperMissingInvocation;
-
- var originalBlockValue = EmberHandlebars.JavaScriptCompiler.prototype.blockValue;
- EmberHandlebars.JavaScriptCompiler.prototype.blockValue = function() {
- originalBlockValue.apply(this, arguments);
- stringifyBlockHelperMissing(this.source);
- };
-
- var originalAmbiguousBlockValue = EmberHandlebars.JavaScriptCompiler.prototype.ambiguousBlockValue;
- EmberHandlebars.JavaScriptCompiler.prototype.ambiguousBlockValue = function() {
- originalAmbiguousBlockValue.apply(this, arguments);
- stringifyBlockHelperMissing(this.source);
- };
-
- /**
- Rewrite simple mustaches from `{{foo}}` to `{{bind "foo"}}`. This means that
- all simple mustaches in Ember's Handlebars will also set up an observer to
- keep the DOM up to date when the underlying property changes.
-
- @private
- @method mustache
- @for Ember.Handlebars.Compiler
- @param mustache
- */
- EmberHandlebars.Compiler.prototype.mustache = function(mustache) {
- if (!(mustache.params.length || mustache.hash)) {
- var id = new Handlebars.AST.IdNode([{ part: '_triageMustache' }]);
-
- // Update the mustache node to include a hash value indicating whether the original node
- // was escaped. This will allow us to properly escape values when the underlying value
- // changes and we need to re-render the value.
- if (!mustache.escaped) {
- mustache.hash = mustache.hash || new Handlebars.AST.HashNode([]);
- mustache.hash.pairs.push(["unescaped", new Handlebars.AST.StringNode("true")]);
- }
- mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, !mustache.escaped);
- }
-
- return Handlebars.Compiler.prototype.mustache.call(this, mustache);
- };
-
- /**
- Used for precompilation of Ember Handlebars templates. This will not be used
- during normal app execution.
-
- @method precompile
- @for Ember.Handlebars
- @static
- @param {String} string The template to precompile
- @param {Boolean} asObject optional parameter, defaulting to true, of whether or not the
- compiled template should be returned as an Object or a String
- */
- EmberHandlebars.precompile = function(string, asObject) {
- var ast = Handlebars.parse(string);
-
- var options = {
- knownHelpers: {
- action: true,
- unbound: true,
- 'bind-attr': true,
- template: true,
- view: true,
- _triageMustache: true
- },
- data: true,
- stringParams: true
- };
-
- asObject = asObject === undefined ? true : asObject;
-
- var environment = new EmberHandlebars.Compiler().compile(ast, options);
- return new EmberHandlebars.JavaScriptCompiler().compile(environment, options, undefined, asObject);
- };
-
- // We don't support this for Handlebars runtime-only
- if (Handlebars.compile) {
- /**
- The entry point for Ember Handlebars. This replaces the default
- `Handlebars.compile` and turns on template-local data and String
- parameters.
-
- @method compile
- @for Ember.Handlebars
- @static
- @param {String} string The template to compile
- @return {Function}
- */
- EmberHandlebars.compile = function(string) {
- var ast = Handlebars.parse(string);
- var options = { data: true, stringParams: true };
- var environment = new EmberHandlebars.Compiler().compile(ast, options);
- var templateSpec = new EmberHandlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
-
- var template = EmberHandlebars.template(templateSpec);
- template.isMethod = false; //Make sure we don't wrap templates with ._super
-
- return template;
- };
- }
-
- __exports__["default"] = EmberHandlebars;
- });
-})();
-
-(function() {
-define("ember-handlebars/component_lookup",
- ["ember-runtime/system/object","exports"],
- function(__dependency1__, __exports__) {
- "use strict";
- var EmberObject = __dependency1__["default"];
-
- var ComponentLookup = EmberObject.extend({
- lookupFactory: function(name, container) {
-
- container = container || this.container;
-
- var fullName = 'component:' + name,
- templateFullName = 'template:components/' + name,
- templateRegistered = container && container.has(templateFullName);
-
- if (templateRegistered) {
- container.injection(fullName, 'layout', templateFullName);
- }
-
- var Component = container.lookupFactory(fullName);
-
- // Only treat as a component if either the component
- // or a template has been registered.
- if (templateRegistered || Component) {
- if (!Component) {
- container.register(fullName, Ember.Component);
- Component = container.lookupFactory(fullName);
- }
- return Component;
- }
- }
- });
-
- __exports__["default"] = ComponentLookup;
- });
-define("ember-handlebars/controls",
- ["ember-handlebars/controls/checkbox","ember-handlebars/controls/text_field","ember-handlebars/controls/text_area","ember-metal/core","ember-handlebars-compiler","exports"],
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
- "use strict";
- var Checkbox = __dependency1__["default"];
- var TextField = __dependency2__["default"];
- var TextArea = __dependency3__["default"];
-
- var Ember = __dependency4__["default"];
- // Ember.assert
- // var emberAssert = Ember.assert;
-
- var EmberHandlebars = __dependency5__["default"];
- var helpers = EmberHandlebars.helpers;
- /**
- @module ember
- @submodule ember-handlebars-compiler
- */
-
- /**
-
- The `{{input}}` helper inserts an HTML `` tag into the template,
- with a `type` value of either `text` or `checkbox`. If no `type` is provided,
- `text` will be the default value applied. The attributes of `{{input}}`
- match those of the native HTML tag as closely as possible for these two types.
-
- ## Use as text field
- An `{{input}}` with no `type` or a `type` of `text` will render an HTML text input.
- The following HTML attributes can be set via the helper:
-
-
-
-
-
- When set to a quoted string, these values will be directly applied to the HTML
- element. When left unquoted, these values will be bound to a property on the
- template's current rendering context (most typically a controller instance).
-
- ## Unbound:
-
- ```handlebars
- {{input value="http://www.facebook.com"}}
- ```
-
-
- ```html
-
- ```
-
- ## Bound:
-
- ```javascript
- App.ApplicationController = Ember.Controller.extend({
- firstName: "Stanley",
- entryNotAllowed: true
- });
- ```
-
-
- ```handlebars
- {{input type="text" value=firstName disabled=entryNotAllowed size="50"}}
- ```
-
-
- ```html
-
- ```
-
- ## Extension
-
- Internally, `{{input type="text"}}` creates an instance of `Ember.TextField`, passing
- arguments from the helper to `Ember.TextField`'s `create` method. You can extend the
- capabilities of text inputs in your applications by reopening this class. For example,
- if you are building a Bootstrap project where `data-*` attributes are used, you
- can add one to the `TextField`'s `attributeBindings` property:
-
-
- ```javascript
- Ember.TextField.reopen({
- attributeBindings: ['data-error']
- });
- ```
-
- Keep in mind when writing `Ember.TextField` subclasses that `Ember.TextField`
- itself extends `Ember.Component`, meaning that it does NOT inherit
- the `controller` of the parent view.
-
- See more about [Ember components](api/classes/Ember.Component.html)
-
-
- ## Use as checkbox
-
- An `{{input}}` with a `type` of `checkbox` will render an HTML checkbox input.
- The following HTML attributes can be set via the helper:
-
- * `checked`
- * `disabled`
- * `tabindex`
- * `indeterminate`
- * `name`
- * `autofocus`
- * `form`
-
-
- When set to a quoted string, these values will be directly applied to the HTML
- element. When left unquoted, these values will be bound to a property on the
- template's current rendering context (most typically a controller instance).
-
- ## Unbound:
-
- ```handlebars
- {{input type="checkbox" name="isAdmin"}}
- ```
-
- ```html
-
- ```
-
- ## Bound:
-
- ```javascript
- App.ApplicationController = Ember.Controller.extend({
- isAdmin: true
- });
- ```
-
-
- ```handlebars
- {{input type="checkbox" checked=isAdmin }}
- ```
-
-
- ```html
-
- ```
-
- ## Extension
-
- Internally, `{{input type="checkbox"}}` creates an instance of `Ember.Checkbox`, passing
- arguments from the helper to `Ember.Checkbox`'s `create` method. You can extend the
- capablilties of checkbox inputs in your applications by reopening this class. For example,
- if you wanted to add a css class to all checkboxes in your application:
-
-
- ```javascript
- Ember.Checkbox.reopen({
- classNames: ['my-app-checkbox']
- });
- ```
-
-
- @method input
- @for Ember.Handlebars.helpers
- @param {Hash} options
- */
- function inputHelper(options) {
- Ember.assert('You can only pass attributes to the `input` helper, not arguments', arguments.length < 2);
-
- var hash = options.hash,
- types = options.hashTypes,
- inputType = hash.type,
- onEvent = hash.on;
-
- delete hash.type;
- delete hash.on;
-
- if (inputType === 'checkbox') {
- Ember.assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`; you must use `checked=someBooleanValue` instead.", options.hashTypes.value !== 'ID');
- return helpers.view.call(this, Checkbox, options);
- } else {
- if (inputType) { hash.type = inputType; }
- hash.onEvent = onEvent || 'enter';
- return helpers.view.call(this, TextField, options);
- }
- }
-
- /**
- `{{textarea}}` inserts a new instance of `
- ```
-
- Bound:
-
- In the following example, the `writtenWords` property on `App.ApplicationController`
- will be updated live as the user types 'Lots of text that IS bound' into
- the text area of their browser's window.
-
- ```javascript
- App.ApplicationController = Ember.Controller.extend({
- writtenWords: "Lots of text that IS bound"
- });
- ```
-
- ```handlebars
- {{textarea value=writtenWords}}
- ```
-
- Would result in the following HTML:
-
- ```html
-
- ```
-
- If you wanted a one way binding between the text area and a div tag
- somewhere else on your screen, you could use `Ember.computed.oneWay`:
-
- ```javascript
- App.ApplicationController = Ember.Controller.extend({
- writtenWords: "Lots of text that IS bound",
- outputWrittenWords: Ember.computed.oneWay("writtenWords")
- });
- ```
-
- ```handlebars
- {{textarea value=writtenWords}}
-
-
| hi |
| `readonly` | `required` | `autofocus` |
| `value` | `placeholder` | `disabled` |
| `size` | `tabindex` | `maxlength` |
| `name` | `min` | `max` |
| `pattern` | `accept` | `autocomplete` |
| `autosave` | `formaction` | `formenctype` |
| `formmethod` | `formnovalidate` | `formtarget` |
| `height` | `inputmode` | `multiple` |
| `step` | `width` | `form` |
| `selectionDirection` | `spellcheck` |
- {{outputWrittenWords}}
-
- ```
-
- Would result in the following HTML:
-
- ```html
-
-
- <-- the following div will be updated in real time as you type -->
-
-
- Lots of text that IS bound
-
- ```
-
- Finally, this example really shows the power and ease of Ember when two
- properties are bound to eachother via `Ember.computed.alias`. Type into
- either text area box and they'll both stay in sync. Note that
- `Ember.computed.alias` costs more in terms of performance, so only use it when
- your really binding in both directions:
-
- ```javascript
- App.ApplicationController = Ember.Controller.extend({
- writtenWords: "Lots of text that IS bound",
- twoWayWrittenWords: Ember.computed.alias("writtenWords")
- });
- ```
-
- ```handlebars
- {{textarea value=writtenWords}}
- {{textarea value=twoWayWrittenWords}}
- ```
-
- ```html
-
-
- <-- both updated in real time -->
-
-
- ```
-
- ## Extension
-
- Internally, `{{textarea}}` creates an instance of `Ember.TextArea`, passing
- arguments from the helper to `Ember.TextArea`'s `create` method. You can
- extend the capabilities of text areas in your application by reopening this
- class. For example, if you are building a Bootstrap project where `data-*`
- attributes are used, you can globally add support for a `data-*` attribute
- on all `{{textarea}}`s' in your app by reopening `Ember.TextArea` or
- `Ember.TextSupport` and adding it to the `attributeBindings` concatenated
- property:
-
- ```javascript
- Ember.TextArea.reopen({
- attributeBindings: ['data-error']
- });
- ```
-
- Keep in mind when writing `Ember.TextArea` subclasses that `Ember.TextArea`
- itself extends `Ember.Component`, meaning that it does NOT inherit
- the `controller` of the parent view.
-
- See more about [Ember components](api/classes/Ember.Component.html)
-
- @method textarea
- @for Ember.Handlebars.helpers
- @param {Hash} options
- */
- function textareaHelper(options) {
- Ember.assert('You can only pass attributes to the `textarea` helper, not arguments', arguments.length < 2);
-
- var hash = options.hash,
- types = options.hashTypes;
-
- return helpers.view.call(this, TextArea, options);
- }
-
- __exports__.inputHelper = inputHelper;
- __exports__.textareaHelper = textareaHelper;
- });
-define("ember-handlebars/controls/checkbox",
- ["ember-metal/property_get","ember-metal/property_set","ember-views/views/view","exports"],
- function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
- "use strict";
- var get = __dependency1__.get;
- var set = __dependency2__.set;
- var View = __dependency3__.View;
-
- /**
- @module ember
- @submodule ember-handlebars
- */
-
- /**
- The internal class used to create text inputs when the `{{input}}`
- helper is used with `type` of `checkbox`.
-
- See [handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input) for usage details.
-
- ## Direct manipulation of `checked`
-
- The `checked` attribute of an `Ember.Checkbox` object should always be set
- through the Ember object or by interacting with its rendered element
- representation via the mouse, keyboard, or touch. Updating the value of the
- checkbox via jQuery will result in the checked value of the object and its
- element losing synchronization.
-
- ## Layout and LayoutName properties
-
- Because HTML `input` elements are self closing `layout` and `layoutName`
- properties will not be applied. See [Ember.View](/api/classes/Ember.View.html)'s
- layout section for more information.
-
- @class Checkbox
- @namespace Ember
- @extends Ember.View
- */
- var Checkbox = View.extend({
- instrumentDisplay: '{{input type="checkbox"}}',
-
- classNames: ['ember-checkbox'],
-
- tagName: 'input',
-
- attributeBindings: ['type', 'checked', 'indeterminate', 'disabled', 'tabindex', 'name',
- 'autofocus', 'required', 'form'],
-
- type: "checkbox",
- checked: false,
- disabled: false,
- indeterminate: false,
-
- init: function() {
- this._super();
- this.on("change", this, this._updateElementValue);
- },
-
- didInsertElement: function() {
- this._super();
- get(this, 'element').indeterminate = !!get(this, 'indeterminate');
- },
-
- _updateElementValue: function() {
- set(this, 'checked', this.$().prop('checked'));
- }
- });
-
- __exports__["default"] = Checkbox;
- });
-define("ember-handlebars/controls/select",
- ["ember-handlebars-compiler","ember-metal/enumerable_utils","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/collection_view","ember-metal/utils","ember-metal/is_none","ember-metal/computed","ember-runtime/system/native_array","ember-metal/mixin","ember-metal/properties","exports"],
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
- "use strict";
- /*jshint eqeqeq:false newcap:false */
-
- /**
- @module ember
- @submodule ember-handlebars
- */
-
- var EmberHandlebars = __dependency1__["default"];
- var EnumerableUtils = __dependency2__["default"];
- var get = __dependency3__.get;
- var set = __dependency4__.set;
- var View = __dependency5__.View;
- var CollectionView = __dependency6__["default"];
- var isArray = __dependency7__.isArray;
- var isNone = __dependency8__["default"];
- var computed = __dependency9__.computed;
- var A = __dependency10__.A;
- var observer = __dependency11__.observer;
- var defineProperty = __dependency12__.defineProperty;
-
- var indexOf = EnumerableUtils.indexOf,
- indexesOf = EnumerableUtils.indexesOf,
- forEach = EnumerableUtils.forEach,
- replace = EnumerableUtils.replace,
- precompileTemplate = EmberHandlebars.compile;
-
- var SelectOption = View.extend({
- instrumentDisplay: 'Ember.SelectOption',
-
- tagName: 'option',
- attributeBindings: ['value', 'selected'],
-
- defaultTemplate: function(context, options) {
- options = { data: options.data, hash: {} };
- EmberHandlebars.helpers.bind.call(context, "view.label", options);
- },
-
- init: function() {
- this.labelPathDidChange();
- this.valuePathDidChange();
-
- this._super();
- },
-
- selected: computed(function() {
- var content = get(this, 'content'),
- selection = get(this, 'parentView.selection');
- if (get(this, 'parentView.multiple')) {
- return selection && indexOf(selection, content.valueOf()) > -1;
- } else {
- // Primitives get passed through bindings as objects... since
- // `new Number(4) !== 4`, we use `==` below
- return content == selection;
- }
- }).property('content', 'parentView.selection'),
-
- labelPathDidChange: observer('parentView.optionLabelPath', function() {
- var labelPath = get(this, 'parentView.optionLabelPath');
-
- if (!labelPath) { return; }
-
- defineProperty(this, 'label', computed(function() {
- return get(this, labelPath);
- }).property(labelPath));
- }),
-
- valuePathDidChange: observer('parentView.optionValuePath', function() {
- var valuePath = get(this, 'parentView.optionValuePath');
-
- if (!valuePath) { return; }
-
- defineProperty(this, 'value', computed(function() {
- return get(this, valuePath);
- }).property(valuePath));
- })
- });
-
- var SelectOptgroup = CollectionView.extend({
- instrumentDisplay: 'Ember.SelectOptgroup',
-
- tagName: 'optgroup',
- attributeBindings: ['label'],
-
- selectionBinding: 'parentView.selection',
- multipleBinding: 'parentView.multiple',
- optionLabelPathBinding: 'parentView.optionLabelPath',
- optionValuePathBinding: 'parentView.optionValuePath',
-
- itemViewClassBinding: 'parentView.optionView'
- });
-
- /**
- The `Ember.Select` view class renders a
- [select](https://developer.mozilla.org/en/HTML/Element/select) HTML element,
- allowing the user to choose from a list of options.
-
- The text and `value` property of each `