If set to NO, then pressing backspace will NOT navigate to the previous page in the browser history, which is the default behavior in most browsers.

Usually it is best to leave this property set to NO in order to prevent the user from inadvertently losing data by pressing the backspace key.

Layout properties to center. Note that you must also specify a width and height for this to work.

Option for controls to automatically calculate their size (should be default on controls that use renderers).

Performance parameter. This will benchmark the time spent firing each binding.

Performance parameter. This will benchmark the time spend configuring each binding.

Stretch/shrink the shape to fit the frame while maintaining aspect ratio, such that the longest dimension will just fit within the frame

Shrink the shape to fit the frame while maintaining aspect ratio, such that the longest dimension will just fit within the frame. Do not stretch the shape if the shape's width is less than the frame's width.

SC.bodyOverflowArbitrator is a central object responsible for controlling the overflow on the body element.

Use it from views that would otherwise set the body overflow style directly; call requestHidden to ask for the body to have overflow:hidden, and call requestVisible to ask for the body to be visible.

Call withdrawRequest to register that you no longer have any interest in the body overflow setting. Don't forget to do this, or your object could be affecting the body overflow long after it's no longer relevant.

When calling requestHidden, requestVisible, and withdrawRequest, pass your object as the first argument so that its request can be associated with its GUID.

When calling requestHidden or requestVisible, you may optionally pass true as a second argument to signify that your desire for hidden or visible overflow is important. An important visible-request will override any other, but an important hidden-request will override a normal visible-request. A normal visible-request will in turn override a normal hidden-request.

Returns a wrapped copy of your function that caches its results according to its arguments. This function itself is cached, so the function you receive when you pass in a particular function will always be the same function.

How was does this function handle its own caching? Using itself, of course! :-D

Use this only on functions without side effects you depend on, and only on functions whose outputs depend entirely on their arguments and on nothing else external to them that could change.

The list of browser specific object prefixes, these are matched to the browser engine.

The list of browser specific CSS prefixes, these are matched to the browser engine.

Reads or writes data from a global cache. You can use this facility to store information about an object without actually adding properties to the object itself. This is needed especially when working with DOM, which can leak easily in IE.

To read data, simply pass in the reference element (used as a key) and the name of the value to read. To write, also include the data.

You can also just pass an object to retrieve the entire cache.

Standard error thrown when trying to compare two dates in different timezones.

(Document Your Controller Here)

this controller is used by Greenhouse to list all of the views in a page files

The device object allows you to check device specific properties such as orientation and if the device is offline, as well as observe when they change state.

Orientation

When a touch device changes orientation, the orientation property will be set accordingly which you can observe

Offline support

In order to build a good offline-capable web application, you need to know when your app has gone offline so you can for instance queue your server requests for a later time or provide a specific UI/message.

Similarly, you also need to know when your application has returned to an 'online' state again, so that you can re-synchronize with the server or do anything else that might be needed.

By observing the 'isOffline' property you can be notified when this state changes. Note that this property is only connected to the navigator.onLine property, which is available on most modern browsers.

The list of browser specific DOM prefixes, these are matched to the browser engine.

Special drag operation passed to delegate if the collection view proposes to perform a reorder event.

Indicates that the collection view expects to accept a drop AFTER the specified item. This is treated just like SC.DROP_BEFORE is most views except for tree lists.

Indicates that the collection view want's to know which operations would be allowed for either drop operation.

Indicates that the collection view expects to accept a drop BEFORE the specified item.

Indicates that the collection view expects to accept a drop ON the specified item.

Stretch/shrink the shape to fill the frame while maintaining aspect ratio, such that the shortest dimension will just fit within the frame and the longest dimension will overflow and be cropped.

Prevents the view from getting resized when the SplitView is resized, or the user resizes or moves an adjacent child view.

If true, then all SproutCore controls can be focused when the user presses the tab key. Otherwise, only SC.TextFieldView's will be focused.

Prepares the Handlebars templating library for use inside SproutCore's view system.

The SC.Handlebars object is the standard Handlebars library, extended to use SproutCore's get() method instead of direct property access, which allows computed properties to be used inside templates.

To use SC.Handlebars, call SC.Handlebars.compile(). This will return a function that you can call multiple times, with a context object as the first parameter:

var template = SC.Handlebars.compile("my {{cool}} template");
var result = template({
  cool: "awesome"
});

console.log(result); // prints "my awesome template"

Note that you won't usually need to use SC.Handlebars yourself. Instead, use SC.TemplateView, which takes care of integration into the view layer for you.

States that the view's layout can be set to if its animation is cancelled.

START

The previous layout of the view before calling animate.

For example,

myView.set('layout', { left: 0, top: 0, width: 100, bottom: 0 });
myView.animate('left', 300, { duration: 1.5 });

// later..
myView.cancelAnimation(SC.LayoutState.START);

myView.get('layout'); // => { left: 0, top: 0, width: 100, bottom: 0 }

CURRENT

The current layout of the view while it is animating.

For example,

myView.set('layout', { left: 0, top: 0, width: 100, bottom: 0 });
myView.animate('left', 300, { duration: 1.5 });

// later..
myView.cancelAnimation(SC.LayoutState.CURRENT);
myView.get('layout'); // => { left: 150, top: 0, width: 100, bottom: 0 }

END

The final layout of the view if the animation completed.

For example,

myView.set('layout', { left: 0, top: 0, width: 100, bottom: 0 });
myView.animate('left', 300, { duration: 1.5 });

// later..
myView.cancelAnimation(SC.LayoutState.END);
myView.get('layout'); // => { left: 300, top: 0, width: 100, bottom: 0 }

This View is used by Greenhouse when application is in design mode This is a Drawing View: If you want to draw a new shape you can pass in the information: For a Line:

{
  +shape: SC.LINE,
  +start: {x: 0, y: 0},
  +end: {x: 100, y: 100},
  ?style: {
    ?width: 5,
    ?color: 'orange' | '#FFA500' | 'rgb(255,165,0)' | 'rgba(255,165,0,1)'
    ?transparency: 0.2
  }
}

For a Rectangle:

{
  +shape: SC.RECT,
  +start: {x: 0, y: 0},
  +size: {width: 100, height: 100},
  ?type: SC.FILL | SC.STROKE
  ?style: {
    ?width: 5,
    ?color: 'orange' | '#FFA500' | 'rgb(255,165,0)' | 'rgba(255,165,0,1)'
    ?transparency: 0.2
  }
}

For a Circle:

{
  +shape: SC.CIRCLE,
  +center: {x: 0, y: 0},
  +radius: 20,
  ?type: SC.FILL | SC.STROKE
  ?style: {
    ?width: 5,
    ?color: 'orange' | '#FFA500' | 'rgb(255,165,0)' | 'rgba(255,165,0,1)'
    ?transparency: 0.2
  }
}

For a Polygon:

{
  +shape: SC.POLY
  +path: [
    +{x: 0, y: 0},
    +{x: 10, y: 10},
    ?{x: 0, y: 50}
  ],
  ?type: SC.FILL | SC.STROKE
  ?style: {
    ?width: 5,
    ?color: 'orange' | '#FFA500' | 'rgb(255,165,0)' | 'rgba(255,165,0,1)'
    ?transparency: 0.2
  }
}

The Locale defined information about a specific locale, including date and number formatting conventions, and localization strings. You can define various locales by adding them to the SC.locales hash, keyed by language and/or country code.

On page load, the default locale will be chosen based on the current languages and saved at SC.Locale.current. This locale is used for localization, etc.

Creating a new locale

You can create a locale by simply extending the SC.Locale class and adding it to the locales hash:

SC.Locale.locales['en'] = SC.Locale.extend({ .. config .. }) ;

Alternatively, you could choose to base your locale on another locale by extending that locale:

SC.Locale.locales['en-US'] = SC.Locale.locales['en'].extend({ ... }) ;

Note that if you do not define your own strings property, then your locale will inherit any strings added to the parent locale. Otherwise you must implement your own strings instead.

Debug parameter you can turn on. This will log all bindings that fire to the console. This should be disabled in production code. Note that you can also enable this from the console or temporarily.

Set to YES to have all observing activity logged to the console.

This is only available in debug mode.

If {@link SC.Logger.debug} falls back onto {@link SC.Logger.log}, this will be prepended to the output.

If {@link SC.Logger.error} falls back onto {@link SC.Logger.log}, this will be prepended to the output.

If {@link SC.Logger.group} falls back onto {@link SC.Logger.log}, this will be prepended to the output.

If the reporter does not support group(), then we’ll add our own indentation to our output. This constant represents one level of indentation.

If {@link SC.Logger.info} falls back onto {@link SC.Logger.log}, this will be prepended to the output.

If {@link SC.Logger.warn} falls back onto {@link SC.Logger.log}, this will be prepended to the output.

When reporting recorded log messages, the timestamp is included with this prefix.

Tells the SplitThumb to automatically choose which child of the SplitView to move in response to touch or mouse events in an SC.SplitThumb.

Tells the SplitThumb to move the child of the SplitView that is either the SplitThumb or a parent of it.

Tells the SplitThumb to move the child of the SplitVie that comes after the child that is either the SplitThumb or a parent of it.

Tells the SplitThumb to move the child of the SplitView that preceeds the child that is either the SplitThumb or a parent of it.

Generic base class to encode a view hierarchy. ViewCoders are used to collect the properties that may be included in a view design and then to serialize that design to a JavaScript string that can be evaled.

To encode a view with a ViewCoder, simply call SC.ViewCoder.encode(view). Most of the time, however, you will not initiate coding directly but instead work with the coder while designing an SC.DesignerView subclass.

Using a Coder

When you are passed an instance of a coder, you can simply write attributes into the coder using one of the many encoding methods defined on the view. Encoding methods are defined for most primitive view types.

coder.string("firstName" , "Charles").string('lastName', 'Jolley');

An instance of this controller is created for every page where designers are involved. The Designer's themselves will register with the controller so that you can hook to the controller to manage the views and their editors.

Among other things, this controller implements global selection support for the designers.

This View is used by Greenhouse when application is in design mode Used for displaying page items

Removes data from the global cache. This is used throughout the framework to hold data without creating memory leaks.

You can remove either a single item on the cache or all of the cached data for an object.

Allows the view to be resized when the SplitView is resized or due to the user resizing or moving an adjacent child view.

Prevents the view from getting resized when the SplitView is resized (unless the SplitView has resized all other views), but allows it to be resized when the user resizes or moves an adjacent child view.

This View is used by Greenhouse when application is in design mode It darkens the area around the rootDesigner

Standard error thrown by SC.Scanner when it can any kind a string in the matching array.

This View is used by Greenhouse when application is in design mode This view draws selection handles for a given designer. It will also forward any mouse events to the underlying designer.

Mike Ball

Add this Mixin to any View and it gives you an API to draw snap lines for all the child views

Default property to disable or enable if the focus can jump to the address bar or not.

Represents a single task which can be run by a task queue. Note that tasks are actually allowed to add themselves back onto the queue if they did not/ might not finish.

Runs a set of tasks. Most importantly, has a runWhenIdle option that allows it to run when no user input is occurring. This allows, for instance, preloading bundles while not blocking user interaction.

Adds a new module of unit tests to verify that the passed object implements the SC.Array interface. To generate, call the ArrayTests array with a test descriptor. Any properties you pass will be applied to the ArrayTests descendant created by the create method.

You should pass at least a newObject() method, which should return a new instance of the object you want to have tested. You can also implement the destroyObject() method, which should destroy a passed object.

SC.ArrayTests.generate("Array", {
  newObject:  function() { return []; }
});

newObject must accept an optional array indicating the number of items that should be in the array. You should initialize the the item with that many items. The actual objects you add are up to you.

Unit tests themselves can be added by calling the define() method. The function you pass will be invoked whenever the ArrayTests are generated. The parameter passed will be the instance of ArrayTests you should work with.

SC.ArrayTests.define(function(T) {
  T.module("length");

  test("verify length", function() {
    var ary = T.newObject();
    equals(ary.get('length'), 0, 'should have 0 initial length');
  });
}