Ember.Controller Class packages/ember-runtime/lib/controllers/controller.js:58
Extends: Ember.Object
Uses: Ember.ControllerMixin
Defined in: packages/ember-runtime/lib/controllers/controller.js:58
Module: ember-runtime
Methods
- _scheduledDestroy
- addObserver
- beginPropertyChanges
- cacheFor
- child
- controllerFor
- create
- createWithMixins
- decrementProperty
- describe
- destroy
- eachComputedProperty
- eachLocal
- endPropertyChanges
- extend
- factoryInjection
- factoryTypeInjection
- get
- getProperties
- getWithDefault
- has
- hasObserverFor
- incrementProperty
- init
- injection
- lookup
- lookupFactory
- makeToString
- metaForProperty
- normalize
- notifyPropertyChange
- options
- optionsForType
- propertyDidChange
- propertyWillChange
- register
- remove
- removeObserver
- reopen
- reopenClass
- replaceRoute
- replaceWith
- reset
- resolve
- set
- setProperties
- toString
- toggleProperty
- transitionTo
- transitionToRoute
- typeInjection
- unregister
- willDestroy
Properties
_scheduledDestroy
private
addObserver
(key, target, method)
Ember.Object
Adds an observer on a property.
This is the core method used to register an observer for a property.
Once you call this method, any time the key's value is set, your observer will be notified. Note that the observers are triggered any time the value is set, regardless of whether it has actually changed. Your observer should be prepared to handle that.
You can also pass an optional context parameter to this method. The context will be passed to your observer method whenever it is triggered. Note that if you add the same target/method pair on a key multiple times with different context parameters, your observer will only be called once with the last context you passed.
Observer Methods
Observer methods you pass should generally have the following signature if
you do not pass a context
parameter:
1 |
fooDidChange: function(sender, key, value, rev) { }; |
The sender is the object that changed. The key is the property that changes. The value property is currently reserved and unused. The rev is the last property revision of the object when it changed, which you can use to detect if the key value has really changed or not.
If you pass a context
parameter, the context will be passed before the
revision like so:
1 |
fooDidChange: function(sender, key, value, context, rev) { }; |
Usually you will not need the value, context or revision parameters at the end. In this case, it is common to write observer methods that take only a sender and key value as parameters or, if you aren't interested in any of these values, to write an observer that has no parameters at all.
Parameters:
- key String
- The key to observer
- target Object
- The target object to invoke
- method String|Function
- The method to invoke.
Returns:
- Ember.Object
- self
beginPropertyChanges
Ember.Observable
Begins a grouping of property changes.
You can use this method to group property changes so that notifications
will not be sent until the changes are finished. If you plan to make a
large number of changes to an object at one time, you should call this
method at the beginning of the changes to begin deferring change
notifications. When you are done making changes, call
endPropertyChanges()
to deliver the deferred change notifications and end
deferring.
Returns:
cacheFor
(keyName)
Object
Returns the cached value of a computed property, if it exists. This allows you to inspect the value of a computed property without accidentally invoking it if it is intended to be generated lazily.
Parameters:
- keyName String
Returns:
- Object
- The cached value of the computed property, if any
child
Container
Returns a new child of the current container. These children are configured to correctly inherit from the current container.
Returns:
- Container
controllerFor
deprecated
create
(arguments)
static
Creates an instance of a class. Accepts either no arguments, or an object containing values to initialize the newly instantiated object with.
1 2 3 4 5 6 7 8 9 10 11 |
App.Person = Ember.Object.extend({ helloWorld: function() { alert("Hi, my name is " + this.get('name')); } }); var tom = App.Person.create({ name: 'Tom Dale' }); tom.helloWorld(); // alerts "Hi, my name is Tom Dale". |
create
will call the init
function if defined during
Ember.AnyObject.extend
If no arguments are passed to create
, it will not set values to the new
instance during initialization:
1 2 |
var noName = App.Person.create(); noName.helloWorld(); // alerts undefined |
NOTE: For performance reasons, you cannot declare methods or computed
properties during create
. You should instead declare methods and computed
properties when using extend
or use the createWithMixins
shorthand.
Parameters:
- arguments
createWithMixins
(arguments)
static
Equivalent to doing extend(arguments).create()
.
If possible use the normal create
method instead.
Parameters:
- arguments
decrementProperty
(keyName, decrement)
Number
Set the value of a property to the current value minus some amount.
1 2 |
player.decrementProperty('lives'); orc.decrementProperty('health', 5); |
Parameters:
- keyName String
- The name of the property to decrement
- decrement Number
- The amount to decrement by. Defaults to 1
Returns:
- Number
- The new property value
describe
A hook that can be used to describe how the resolver will attempt to find the factory.
For example, the default Ember .describe
returns the full
class name (including namespace) where Ember's resolver expects
to find the fullName
.
destroy
A depth first traversal, destroying the container, its descendant containers and all their managed objects.
eachComputedProperty
(callback, binding)
Iterate over each computed property for the class, passing its name
and any associated metadata (see metaForProperty
) to the callback.
Parameters:
- callback Function
- binding Object
eachLocal
(callback, binding)
Iterate and invoke a callback for each local key-value pair.
Parameters:
- callback Function
- binding Object
endPropertyChanges
Ember.Observable
Ends a grouping of property changes.
You can use this method to group property changes so that notifications
will not be sent until the changes are finished. If you plan to make a
large number of changes to an object at one time, you should call
beginPropertyChanges()
at the beginning of the changes to defer change
notifications. When you are done making changes, call this method to
deliver the deferred change notifications and end deferring.
Returns:
extend
(mixins, arguments)
static
Creates a new subclass.
1 2 3 4 5 |
App.Person = Ember.Object.extend({ say: function(thing) { alert(thing); } }); |
This defines a new subclass of Ember.Object: App.Person
. It contains one method: say()
.
You can also create a subclass from any existing class by calling its extend()
method. For example, you might want to create a subclass of Ember's built-in Ember.View
class:
1 2 3 4 |
App.PersonView = Ember.View.extend({ tagName: 'li', classNameBindings: ['isAdministrator'] }); |
When defining a subclass, you can override methods but still access the implementation of your parent class by calling the special _super()
method:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
App.Person = Ember.Object.extend({ say: function(thing) { var name = this.get('name'); alert(name + ' says: ' + thing); } }); App.Soldier = App.Person.extend({ say: function(thing) { this._super(thing + ", sir!"); }, march: function(numberOfHours) { alert(this.get('name') + ' marches for ' + numberOfHours + ' hours.') } }); var yehuda = App.Soldier.create({ name: "Yehuda Katz" }); yehuda.say("Yes"); // alerts "Yehuda Katz says: Yes, sir!" |
The create()
on line #17 creates an instance of the App.Soldier
class. The extend()
on line #8 creates a subclass of App.Person
. Any instance of the App.Person
class will not have the march()
method.
You can also pass Ember.Mixin
classes to add additional properties to the subclass.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
App.Person = Ember.Object.extend({ say: function(thing) { alert(this.get('name') + ' says: ' + thing); } }); App.SingingMixin = Ember.Mixin.create({ sing: function(thing){ alert(this.get('name') + ' sings: la la la ' + thing); } }); App.BroadwayStar = App.Person.extend(App.SingingMixin, { dance: function() { alert(this.get('name') + ' dances: tap tap tap tap '); } }); |
The App.BroadwayStar
class contains three methods: say()
, sing()
, and dance()
.
Parameters:
- mixins Ember.Mixin
- One or more Ember.Mixin classes
- arguments Object
- Object containing values to use within the new class
factoryInjection
(factoryName, property, injectionName)
Defines factory injection rules.
Similar to regular injection rules, but are run against factories, via
Container#lookupFactory
.
These rules are used to inject objects onto factories when they are looked up.
Two forms of injections are possible:
1 2 |
* Injecting one fullName on another fullName * Injecting one fullName on a type |
Example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
var container = new Container(); container.register('store:main', Store); container.register('store:secondary', OtherStore); container.register('model:user', User); container.register('model:post', Post); // injecting one fullName on another type container.factoryInjection('model', 'store', 'store:main'); // injecting one fullName on another fullName container.factoryInjection('model:post', 'secondaryStore', 'store:secondary'); var UserFactory = container.lookupFactory('model:user'); var PostFactory = container.lookupFactory('model:post'); var store = container.lookup('store:main'); UserFactory.store instanceof Store; //=> true UserFactory.secondaryStore instanceof OtherStore; //=> false PostFactory.store instanceof Store; //=> true PostFactory.secondaryStore instanceof OtherStore; //=> true // and both models share the same source instance UserFactory.store === PostFactory.store; //=> true |
factoryTypeInjection
(type, property, fullName)
private
get
Any
Retrieve the value given a key, if the value is present at the current level use it, otherwise walk up the parent hierarchy and try again. If no matching key is found, return undefined.
Returns:
- Any
getProperties
(list)
Hash
To get multiple properties at once, call getProperties
with a list of strings or an array:
1 |
record.getProperties('firstName', 'lastName', 'zipCode'); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' } |
is equivalent to:
1 |
record.getProperties(['firstName', 'lastName', 'zipCode']); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' } |
Parameters:
- list String...|Array
- of keys to get
Returns:
- Hash
getWithDefault
(keyName, defaultValue)
Object
Retrieves the value of a property, or a default value in the case that the
property returns undefined
.
1 |
person.getWithDefault('lastName', 'Doe'); |
Parameters:
- keyName String
- The name of the property to retrieve
- defaultValue Object
- The value to return if the property value is undefined
Returns:
- Object
- The property value or the defaultValue.
has
(fullName)
Boolean
Given a fullName check if the container is aware of its factory or singleton instance.
Parameters:
- fullName String
Returns:
- Boolean
hasObserverFor
(key)
Boolean
Returns true
if the object currently has observers registered for a
particular key. You can use this method to potentially defer performing
an expensive action until someone begins observing a particular property
on the object.
Parameters:
- key String
- Key to check
Returns:
- Boolean
incrementProperty
(keyName, increment)
Number
Set the value of a property to the current value plus some amount.
1 2 |
person.incrementProperty('age'); team.incrementProperty('score', 2); |
Parameters:
- keyName String
- The name of the property to increment
- increment Number
- The amount to increment by. Defaults to 1
Returns:
- Number
- The new property value
init
An overridable method called when objects are instantiated. By default, does nothing unless it is overridden during class definition.
Example:
1 2 3 4 5 6 7 8 9 10 11 |
App.Person = Ember.Object.extend({ init: function() { alert('Name is ' + this.get('name')); } }); var steve = App.Person.create({ name: "Steve" }); // alerts 'Name is Steve'. |
NOTE: If you do override init
for a framework class like Ember.View
or
Ember.ArrayController
, be sure to call this._super()
in your
init
declaration! If you don't, Ember may not have an opportunity to
do important setup work, and you'll see strange behavior in your
application.
injection
(factoryName, property, injectionName)
Defines injection rules.
These rules are used to inject dependencies onto objects when they are instantiated.
Two forms of injections are possible:
1 2 |
* Injecting one fullName on another fullName * Injecting one fullName on a type |
Example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
var container = new Container(); container.register('source:main', Source); container.register('model:user', User); container.register('model:post', Post); // injecting one fullName on another fullName // eg. each user model gets a post model container.injection('model:user', 'post', 'model:post'); // injecting one fullName on another type container.injection('model', 'source', 'source:main'); var user = container.lookup('model:user'); var post = container.lookup('model:post'); user.source instanceof Source; //=> true post.source instanceof Source; //=> true user.post instanceof Post; //=> true // and both models share the same source user.source === post.source; //=> true |
lookup
(fullName, options)
Any
Given a fullName return a corresponding instance.
The default behaviour is for lookup to return a singleton instance. The singleton is scoped to the container, allowing multiple containers to all have their own locally scoped singletons.
1 2 3 4 5 6 7 8 9 10 11 12 |
var container = new Container(); container.register('api:twitter', Twitter); var twitter = container.lookup('api:twitter'); twitter instanceof Twitter; // => true // by default the container will return singletons twitter2 = container.lookup('api:twitter'); twitter instanceof Twitter; // => true twitter === twitter2; //=> true |
If singletons are not wanted an optional flag can be provided at lookup.
1 2 3 4 5 6 7 |
var container = new Container(); container.register('api:twitter', Twitter); var twitter = container.lookup('api:twitter', { singleton: false }); var twitter2 = container.lookup('api:twitter', { singleton: false }); twitter === twitter2; //=> false |
Parameters:
- fullName String
- options Object
Returns:
- Any
lookupFactory
(fullName)
Any
Given a fullName return the corresponding factory.
Parameters:
- fullName String
Returns:
- Any
makeToString
(factory, fullName)
Function
Parameters:
- factory Any
- fullName String
Returns:
- Function
- toString function
metaForProperty
(key)
In some cases, you may want to annotate computed properties with additional metadata about how they function or what values they operate on. For example, computed property functions may close over variables that are then no longer available for introspection.
You can pass a hash of these values to a computed property like this:
1 2 3 4 |
person: function() { var personId = this.get('personId'); return App.Person.create({ id: personId }); }.property().meta({ type: App.Person }) |
Once you've done this, you can retrieve the values saved to the computed property from your class like this:
1 |
MyClass.metaForProperty('person');
|
This will return the original hash that was passed to meta()
.
Parameters:
- key String
- property name
normalize
(fullName)
String
A hook to enable custom fullName normalization behaviour
Parameters:
- fullName String
Returns:
- String
- normalized fullName
notifyPropertyChange
(keyName)
Ember.Observable
Convenience method to call propertyWillChange
and propertyDidChange
in
succession.
Parameters:
- keyName String
- The property key to be notified about.
Returns:
optionsForType
(type, options)
Allow registering options for all factories of a type.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
var container = new Container(); // if all of type `connection` must not be singletons container.optionsForType('connection', { singleton: false }); container.register('connection:twitter', TwitterConnection); container.register('connection:facebook', FacebookConnection); var twitter = container.lookup('connection:twitter'); var twitter2 = container.lookup('connection:twitter'); twitter === twitter2; // => false var facebook = container.lookup('connection:facebook'); var facebook2 = container.lookup('connection:facebook'); facebook === facebook2; // => false |
Parameters:
- type String
- options Object
propertyDidChange
(keyName)
Ember.Observable
Notify the observer system that a property has just changed.
Sometimes you need to change a value directly or indirectly without
actually calling get()
or set()
on it. In this case, you can use this
method and propertyWillChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
- keyName String
- The property key that has just changed.
Returns:
propertyWillChange
(keyName)
Ember.Observable
Notify the observer system that a property is about to change.
Sometimes you need to change a value directly or indirectly without
actually calling get()
or set()
on it. In this case, you can use this
method and propertyDidChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
- keyName String
- The property key that is about to change.
Returns:
register
(fullName, factory, options)
Registers a factory for later injection.
Example:
1 2 3 4 5 |
var container = new Container(); container.register('model:user', Person, {singleton: false }); container.register('fruit:favorite', Orange); container.register('communication:main', Email, {singleton: false}); |
removeObserver
(key, target, method)
Ember.Observable
Remove an observer you have previously registered on this object. Pass
the same key, target, and method you passed to addObserver()
and your
target will no longer receive notifications.
Parameters:
- key String
- The key to observer
- target Object
- The target object to invoke
- method String|Function
- The method to invoke.
Returns:
- Ember.Observable
- receiver
reopen
Augments a constructor's prototype with additional
properties and functions:
javascript
MyObject = Ember.Object.extend({
name: 'an object'
});
o = MyObject.create();
o.get('name'); // 'an object'
MyObject.reopen({
say: function(msg){
console.log(msg);
}
})
o2 = MyObject.create();
o2.say("hello"); // logs "hello"
o.say("goodbye"); // logs "goodbye"
To add functions and properties to the constructor itself,
see reopenClass
reopenClass
Augments a constructor's own properties and functions:
1 2 3 4 5 6 7 8 9 10 11 |
MyObject = Ember.Object.extend({ name: 'an object' }); MyObject.reopenClass({ canBuild: false }); MyObject.canBuild; // false o = MyObject.create(); |
In other words, this creates static properties and functions for the class. These are only available on the class and not on any instance of that class.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
App.Person = Ember.Object.extend({ name : "", sayHello : function(){ alert("Hello. My name is " + this.get('name')); } }); App.Person.reopenClass({ species : "Homo sapiens", createPerson: function(newPersonsName){ return App.Person.create({ name:newPersonsName }); } }); var tom = App.Person.create({ name : "Tom Dale" }); var yehuda = App.Person.createPerson("Yehuda Katz"); tom.sayHello(); // "Hello. My name is Tom Dale" yehuda.sayHello(); // "Hello. My name is Yehuda Katz" alert(App.Person.species); // "Homo sapiens" |
Note that species
and createPerson
are not valid on the tom
and yehuda
variables. They are only valid on App.Person
.
To add functions and properties to instances of
a constructor by extending the constructor's prototype
see reopen
replaceRoute
(name, models)
Transition into another route while replacing the current URL, if possible.
This will replace the current history entry instead of adding a new one.
Beside that, it is identical to transitionToRoute
in all other respects.
1 2 |
aController.replaceRoute('blogPosts'); aController.replaceRoute('blogPosts.recentEntries'); |
Optionally supply a model for the route in question. The model
will be serialized into the URL using the serialize
hook of
the route:
1 |
aController.replaceRoute('blogPost', aPost);
|
Multiple models will be applied last to first recursively up the resource tree.
1 2 3 4 5 6 |
this.resource('blogPost', {path:':blogPostId'}, function(){ this.resource('blogComment', {path: ':blogCommentId'}); }); aController.replaceRoute('blogComment', aPost, aComment); |
Parameters:
- name String
- the name of the route
- models ...Object
- the model(s) to be used while transitioning to the route.
replaceWith
deprecated
reset
resolve
(fullName)
Function
Given a fullName return the corresponding factory.
By default resolve
will retrieve the factory from
its container's registry.
1 2 3 4 |
var container = new Container(); container.register('api:twitter', Twitter); container.resolve('api:twitter') // => Twitter |
Optionally the container can be provided with a custom resolver.
If provided, resolve
will first provide the custom resolver
the oppertunity to resolve the fullName, otherwise it will fallback
to the registry.
1 2 3 4 5 6 7 |
var container = new Container(); container.resolver = function(fullName) { // lookup via the module system of choice }; // the twitter factory is added to the module system container.resolve('api:twitter') // => Twitter |
Parameters:
- fullName String
Returns:
- Function
- fullName's factory
set
(object, key, value)
Sets a key-value pair on the current container. If a parent container, has the same key, once set on a child, the parent and child will diverge as expected.
Parameters:
- object Object
- key String
- value Any
setProperties
(hash)
Ember.Observable
To set multiple properties at once, call setProperties
with a Hash:
1 |
record.setProperties({ firstName: 'Charles', lastName: 'Jolley' }); |
Parameters:
- hash Hash
- the hash of keys and values to set
Returns:
toString
String
Returns a string representation which attempts to provide more information
than Javascript's toString
typically does, in a generic way for all Ember
objects.
1 2 3 |
App.Person = Em.Object.extend() person = App.Person.create() person.toString() //=> "<App.Person:ember1024>" |
If the object's class is not defined on an Ember namespace, it will indicate it is a subclass of the registered superclass:
1 2 3 |
Student = App.Person.extend() student = Student.create() student.toString() //=> "<(subclass of App.Person):ember1025>" |
If the method toStringExtension
is defined, its return value will be
included in the output.
1 2 3 4 5 6 7 |
App.Teacher = App.Person.extend({ toStringExtension: function() { return this.get('fullName'); } }); teacher = App.Teacher.create() teacher.toString(); //=> "<App.Teacher:ember1026:Tom Dale>" |
Returns:
- String
- string representation
toggleProperty
(keyName)
Object
Set the value of a boolean property to the opposite of it's current value.
1 |
starship.toggleProperty('warpDriveEngaged');
|
Parameters:
- keyName String
- The name of the property to toggle
Returns:
- Object
- The new property value
transitionTo
deprecated
transitionToRoute
(name, models)
Transition the application into another route. The route may be either a single route or route path:
1 2 |
aController.transitionToRoute('blogPosts'); aController.transitionToRoute('blogPosts.recentEntries'); |
Optionally supply a model for the route in question. The model
will be serialized into the URL using the serialize
hook of
the route:
1 |
aController.transitionToRoute('blogPost', aPost);
|
Multiple models will be applied last to first recursively up the resource tree.
1 2 3 4 5 6 |
this.resource('blogPost', {path:':blogPostId'}, function(){ this.resource('blogComment', {path: ':blogCommentId'}); }); aController.transitionToRoute('blogComment', aPost, aComment); |
See also 'replaceRoute'.
Parameters:
- name String
- the name of the route
- models ...Object
- the model(s) to be used while transitioning to the route.
typeInjection
(type, property, fullName)
private
unregister
(fullName)
Unregister a fullName
1 2 3 4 5 6 7 |
var container = new Container(); container.register('model:user', User); container.lookup('model:user') instanceof User //=> true container.unregister('model:user') container.lookup('model:user') === undefined //=> true |
Parameters:
- fullName String
willDestroy
Override to implement teardown.
_options
InheritingDict
private
Default: null
_typeOptions
InheritingDict
private
cache
InheritingDict
children
Array
Default: []
concatenatedProperties
Array
Defines the properties that will be concatenated from the superclass (instead of overridden).
By default, when you extend an Ember class a property defined in
the subclass overrides a property with the same name that is defined
in the superclass. However, there are some cases where it is preferable
to build up a property's value by combining the superclass' property
value with the subclass' value. An example of this in use within Ember
is the classNames
property of Ember.View
.
Here is some sample code showing the difference between a concatenated property and a normal one:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
App.BarView = Ember.View.extend({ someNonConcatenatedProperty: ['bar'], classNames: ['bar'] }); App.FooBarView = App.BarView.extend({ someNonConcatenatedProperty: ['foo'], classNames: ['foo'], }); var fooBarView = App.FooBarView.create(); fooBarView.get('someNonConcatenatedProperty'); // ['foo'] fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo'] |
This behavior extends to object creation as well. Continuing the above example:
1 2 3 4 5 6 |
var view = App.FooBarView.create({ someNonConcatenatedProperty: ['baz'], classNames: ['baz'] }) view.get('someNonConcatenatedProperty'); // ['baz'] view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] |
Adding a single property that is not an array will just add it in the array:
1 2 3 4 |
var view = App.FooBarView.create({ classNames: 'baz' }) view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] |
Using the concatenatedProperties
property, we can tell to Ember that mix
the content of the properties.
In Ember.View
the classNameBindings
and attributeBindings
properties
are also concatenated, in addition to classNames
.
This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).
Default: null
controllers
Object
Stores the instances of other controllers available from within
this controller. Any controller listed by name in the needs
property will be accessible by name through this property.
1 2 3 4 5 6 7 |
App.CommentsController = Ember.ArrayController.extend({ needs: ['post'], postTitle: function(){ var currentPost = this.get('controllers.post'); // instance of App.PostController return currentPost.get('title'); }.property('controllers.post.title') }); |
Default: null
dict
Object
Object used to store the current nodes data.
Default: Object
injections
Object
Default: {}
isDestroyed
Destroyed object property flag.
if this property is true
the observers and bindings were already
removed by the effect of calling the destroy()
method.
Default: false
isDestroying
Destruction scheduled flag. The destroy()
method has been called.
The object stays intact until the end of the run loop at which point
the isDestroyed
flag is set.
Default: false
needs
Array
An array of other controller objects available inside
instances of this controller via the controllers
property:
For example, when you define a controller:
1 2 3 |
App.CommentsController = Ember.ArrayController.extend({ needs: ['post'] }); |
The application's single instance of these other
controllers are accessible by name through the
controllers
property:
1 |
this.get('controllers.post'); // instance of App.PostController |
This is only available for singleton controllers.
Default: []
parent
Container
Default: null
registry
InheritingDict
resolver
function
target
The object to which actions from the view should be sent.
For example, when a Handlebars template uses the {{action}}
helper,
it will attempt to send the action to the view's controller's target
.
By default, a controller's target
is set to the router after it is
instantiated by Ember.Application#initialize
.
Default: null
typeInjections
InheritingDict