$
(selector)
JQuerypublic

Returns a jQuery object for this component'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 component.$('li') will return a jQuery object containing
all of the li elements inside the DOM element of this component.

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.

There are two common invocation patterns for .addObserver():

Passing two arguments:

the name of the property to observe (as a string)

the function to invoke (an actual function)

Passing three arguments:

the name of the property to observe (as a string)

the target object (will be used to look up and invoke a
function on)

the name of the function to invoke on the target object
(as a string).

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.

Usually you will not need the value 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.

didReceiveAttrspublic

Called when the attributes passed into the component have been updated.
Called both during the initial render of a container and during a rerender.
Can be used in place of an observer; code placed here will be executed
every time any attribute updates.

When you call get on a computed property, the function will be
called and the return value will be returned instead of the function
itself.

Unknown Properties

Likewise, if you try to call get on a property whose value is
undefined, the unknownProperty() method will be called on the object.
If this method returns any value other than undefined, it will be returned
instead. This allows you to implement "virtual" properties that are
not defined upfront.

NOTE: If you do override init for a framework class like Ember.View,
be sure to call this._super(...arguments) 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.

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 instead. Calling this method will notify all observers that the
property has potentially changed value.

person.on('didLoad', function(){
// fired once the person has loaded
});

An optional target can be passed in as the 2nd argument that will
be set as the "this" for the callback. This is a good way to give your
function access to the object triggering the event. When the target
parameter is used the callback method becomes the third argument.

Subscribes a function to a named event and then cancels the subscription
after the first time the event is triggered. It is good to use one when
you only care about the first time an event has taken place.

This function takes an optional 2nd argument that will become the "this"
value for the callback. When the target parameter is used the callback method
becomes the third argument.

readDOMAttr
(name)
public

Normally, Ember's component model is "write-only". The component takes a
bunch of attributes that it got passed in, and uses them to render its
template.

One nice thing about this model is that if you try to set a value to the
same thing as last time, Ember (through HTMLBars) will avoid doing any
work on the DOM.

This is not just a performance optimization. If an attribute has not
changed, it is important not to clobber the element's "hidden state".
For example, if you set an input's value to the same value as before,
it will clobber selection state and cursor position. In other words,
setting an attribute is not always idempotent.

This method provides a way to read an element's attribute and also
update the last value Ember knows about at the same time. This makes
setting an attribute idempotent.

In particular, what this means is that if you get an <input> element's
value attribute and then re-render the template with the same value,
it will avoid clobbering the cursor and selection position.
Since most attribute sets are idempotent in the browser, you typically
can get away with reading attributes using jQuery, but the most reliable
way to do so is through this method.

rerenderpublic

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.

Triggers a named action on the ActionHandler. Any parameters
supplied after the actionName string will be passed as arguments
to the action target function.

If the ActionHandler has its target property set, actions may
bubble to the target. Bubbling happens when an actionName can
not be found in the ActionHandler's actions hash or if the
action target function returns true.

This method is generally very similar to calling object["key"] = value or
object.key = value, except that it provides support for computed
properties, the setUnknownProperty() method and property observers.

Computed Properties

If you try to set a value on a key that has a computed property handler
defined (see the get() method for an example), then set() will call
that method, passing both the value and key instead of simply changing
the value itself. This is useful for those times when you need to
implement a property that is composed of one or more member
properties.

Unknown Properties

If you try to set a value on a key that is undefined in the target
object, then the setUnknownProperty() handler will be called instead. This
gives you an opportunity to implement complex "virtual" properties that
are not predefined on the object. If setUnknownProperty() returns
undefined, then set() will simply set the value on the object.

Property Observers

In addition to changing the property, set() will also register a property
change with the object. Unless you have placed this call inside of a
beginPropertyChanges() and endPropertyChanges(), any "local" observers
(i.e. observer methods declared on the same object), will be called
immediately. Any "remote" observers (i.e. observer methods declared on
another object) will be placed in a queue and called at a later time in a
coalesced manner.