Returns a CoreQuery instance for the element this context wraps (if it wraps any). If a selector is passed, the CoreQuery instance will be for nodes matching that selector.

Renderers may use this to modify DOM.

Adds the specified attribute to the current context.

This is a convenience method that simply calls setAttr(nameOrAttrs, value).

Adds a class or classes to the current context.

This is a convenience method that simply calls setClass(nameOrClasses, YES).

Adds the specified style to the current context.

This is a convenience method that simply calls setStyle(nameOrStyles, value).

Retrieves the current attributes for the context, less the class and style attributes.

If you retrieve the attributes hash to edit it, you must pass the hash back to setAttr in order for it to be applied to the element on rendering.

Use classes() or styles() to get those specific attributes.

Begins a new render context based on the passed tagName or element. Generate said context using end().

Retrieves the class names for the current context.

If the current context targets an element, this method returns the element. If the context does not target an element, this method will render the context into an offscreen element and return it.

Ends the current tag editing context. This will generate the tag string including any attributes you might have set along with a closing tag.

The generated HTML will be added to the render context strings. This will also return the previous context if there is one or the receiver.

If you do not have a current tag, this does nothing.

Helper method escapes the passed string to ensure HTML is displayed as plain text while preserving HTML entities like ' , à, etc. You should make sure you pass all user-entered data through this method to avoid errors. You can also do this with the text() helper method on a render context.

Returns the string at the designated index. If you do not pass anything returns the string array. This index is an offset from the start of the strings owned by this context.

Returns YES if the outer tag current has the passed class name, NO otherwise.

Reads the outer tag id if no param is passed, sets the id otherwise.

When you create a context you should pass either a tag name or an element that should be used as the basis for building the context. If you pass an element, then the element will be inspected for class names, styles and other attributes. You can also call update() or replace() to modify the element with you context contents.

If you do not pass any parameters, then we assume the tag name is 'div'.

A second parameter, parentContext, is used internally for chaining. You should never pass a second argument.

Joins the strings together, closes any open tags and returns the final result.

Adds a string to the render context for later joining and insertion. To HTML escape the string, see the similar text() method instead.

Note: You can pass multiple string arguments to this method and each will be pushed.

When used in render() for example,

MyApp.MyView = SC.View.extend({

  innerText: '',

  render: function (context) {
    var innerText = this.get('innerText');

    // This will be pushed into the DOM all at once.
    context.push('<div class="inner-div">', innerText, '<span class="inner-span">**</span></div>');
  }

});

Removes an element with the passed id in the currently managed element.

Removes the specified attribute from the current context.

This is a convenience method that simply calls setAttr(name, undefined).

Removes the specified class name from the current context.

This is a convenience method that simply calls setClass(name, NO).

Removes the specified style from the current context.

This is a convenience method that simply calls setStyle(name, undefined).

Removes all class names from the context.

Be aware that setClass() only effects the class names specified. If there are existing class names that are not modified by a call to setClass(), they will remain on the context. For example, if you call addClass('a') and addClass('b') followed by setClass({ b:NO }), the 'b' class will be removed, but the 'a' class will be unaffected.

If you want to call setClass() or addClass() to replace all classes, you should call this method first.

Removes all styles from the context.

Be aware that setStyle() only affects the styles specified. If there are existing styles that are not modified by a call to setStyle(), they will remain on the context. For example, if you call addStyle('margin-left', 10) and addStyle('margin-right', 10) followed by setClass({ 'margin-right': null }), the 'margin-right' style will be removed, but the 'margin-left' style will be unaffected.

If you want to call setStyle() or addStyle() to replace all styles, you should call this method first.

Sets or unsets an attribute or attributes on the context. Passing a value will set the value for the given attribute name, passing a null or undefined value will unset any current value for the given attribute name and remove it.

When used in render() for example,

MyApp.MyView = SC.View.extend({

  // By default this syle will not appear since the value is null.
  title: null,

  render: function (context) {
    var title = this.get('title');

    // Set the `title` and `data-test` attributes.
    context.setAttr({
      title: title,
      'data-test': SC.buildMode === 'test'
    });
  }
});

Sets or unsets class names on the current context.

You can either pass a single class name and a boolean indicating whether the value should be added or removed, or you can pass a hash with all the class names you want to add or remove with a boolean indicating whether they should be there or not.

When used in render() for example,

MyApp.MyView = SC.View.extend({

  isAdministrator: NO,

  render: function (context) {
    var isAdministrator = this.get('isAdministrator');

    // Sets the 'is-admin' class appropriately.
    context.setClass('is-admin', isAdministrator);
  }

});

Sets or unsets a style or styles on the context.

Passing a value will set the value for the given style name, passing a null or undefined value will unset any current value for the given style name and remove it.

Be aware that setStyle() only effects the styles specified. If there are existing styles that are not modified by a call to setStyle(), they will remain on the context. For example, if you call addStyle('margin-left', 10) and addStyle('margin-right', 10) followed by setClass({ 'margin-right': null }), the 'margin-right' style will be removed, but the 'margin-left' style will be unaffected.

If you want to call setStyle() or addStyle() to replace all styles, you should call resetStyles() method first.

When used in render() for example,

MyApp.MyView = SC.View.extend({

  textColor: 'blue',

  // By default this syle will not appear since the value is null.
  fontFamily: null,

  render: function (context) {
    var textColor = this.get('textColor'),
      fontFamily = this.get('fontFamily');

    // Set the `color` and `fontFamily` styles.
    context.setStyle({
      color: textColor,
      fontFamily: fontFamily
    });
  }
});

Retrieves the current styles for the context.

Generates a tag with the passed options. Like calling context.begin().end().

Reads outer tagName if no param is passed, sets tagName otherwise.

Pushes the passed string to the render context for later joining and insertion, but first escapes the string to ensure that no user-entered HTML is processed as HTML. To push the string without escaping, see the similar push() method instead.

Note: You can pass multiple string arguments to this method and each will be escaped and pushed.

When used in render() for example,

MyApp.MyView = SC.View.extend({

  userText: '<script src="http://maliciousscripts.com"></script>',

  render: function (context) {
    var userText = this.get('userText');

    // Pushes "<script src="http://maliciousscripts.com"></script>" in the DOM
    context.text(userText);
  }

});

If an element was set on this context when it was created, this method will actually apply any changes to the element itself. If you have not written any inner html into the context, then the innerHTML of the element will not be changed, otherwise it will be replaced with the new innerHTML.

Also, any attributes, id, classNames or styles you've set will be updated as well. This also ends the editing context session and cleans up.