--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/view/view.js Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,440 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('view', function (Y, NAME) {
+
+/**
+Represents a logical piece of an application's user interface, and provides a
+lightweight, overridable API for rendering content and handling delegated DOM
+events on a container element.
+
+@module app
+@submodule view
+@since 3.4.0
+**/
+
+/**
+Represents a logical piece of an application's user interface, and provides a
+lightweight, overridable API for rendering content and handling delegated DOM
+events on a container element.
+
+The View class imposes little structure and provides only minimal functionality
+of its own: it's basically just an overridable API interface that helps you
+implement custom views.
+
+As of YUI 3.5.0, View allows ad-hoc attributes to be specified at instantiation
+time, so you don't need to subclass `Y.View` to add custom attributes. Just pass
+them to the constructor:
+
+ var view = new Y.View({foo: 'bar'});
+ view.get('foo'); // => "bar"
+
+@class View
+@constructor
+@extends Base
+@since 3.4.0
+**/
+
+function View() {
+ View.superclass.constructor.apply(this, arguments);
+}
+
+Y.View = Y.extend(View, Y.Base, {
+ // -- Public Properties ----------------------------------------------------
+
+ /**
+ Template for this view's container.
+
+ @property containerTemplate
+ @type String
+ @default "<div/>"
+ @since 3.5.0
+ **/
+ containerTemplate: '<div/>',
+
+ /**
+ Hash of CSS selectors mapped to events to delegate to elements matching
+ those selectors.
+
+ CSS selectors are relative to the `container` element. Events are attached
+ to the container, and delegation is used so that subscribers are only
+ notified of events that occur on elements inside the container that match
+ the specified selectors. This allows the container's contents to be re-
+ rendered as needed without losing event subscriptions.
+
+ Event handlers can be specified either as functions or as strings that map
+ to function names on this view instance or its prototype.
+
+ The `this` object in event handlers will refer to this view instance. If
+ you'd prefer `this` to be something else, use `Y.bind()` to bind a custom
+ `this` object.
+
+ @example
+
+ var view = new Y.View({
+ events: {
+ // Call `this.toggle()` whenever the element with the id
+ // "toggle-button" is clicked.
+ '#toggle-button': {click: 'toggle'},
+
+ // Call `this.hoverOn()` when the mouse moves over any element
+ // with the "hoverable" class, and `this.hoverOff()` when the
+ // mouse moves out of any element with the "hoverable" class.
+ '.hoverable': {
+ mouseover: 'hoverOn',
+ mouseout : 'hoverOff'
+ }
+ }
+ });
+
+ @property events
+ @type Object
+ @default {}
+ **/
+ events: {},
+
+ /**
+ Template for this view's contents.
+
+ This is a convenience property that has no default behavior of its own.
+ It's only provided as a convention to allow you to store whatever you
+ consider to be a template, whether that's an HTML string, a `Y.Node`
+ instance, a Mustache template, or anything else your little heart
+ desires.
+
+ How this template gets used is entirely up to you and your custom
+ `render()` method.
+
+ @property template
+ @type mixed
+ @default ''
+ **/
+ template: '',
+
+ // -- Protected Properties -------------------------------------------------
+
+ /**
+ This tells `Y.Base` that it should create ad-hoc attributes for config
+ properties passed to View's constructor. This makes it possible to
+ instantiate a view and set a bunch of attributes without having to subclass
+ `Y.View` and declare all those attributes first.
+
+ @property _allowAdHocAttrs
+ @type Boolean
+ @default true
+ @protected
+ @since 3.5.0
+ **/
+ _allowAdHocAttrs: true,
+
+ // -- Lifecycle Methods ----------------------------------------------------
+ initializer: function (config) {
+ config || (config = {});
+
+ // Set instance properties specified in the config.
+ config.containerTemplate &&
+ (this.containerTemplate = config.containerTemplate);
+
+ config.template && (this.template = config.template);
+
+ // Merge events from the config into events in `this.events`.
+ this.events = config.events ? Y.merge(this.events, config.events) :
+ this.events;
+
+ // When the container node changes (or when it's set for the first
+ // time), we'll attach events to it, but not until then. This allows the
+ // container to be created lazily the first time it's accessed rather
+ // than always on init.
+ this.after('containerChange', this._afterContainerChange);
+ },
+
+ /**
+ Destroys this View, detaching any DOM events and optionally also destroying
+ its container node.
+
+ By default, the container node will not be destroyed. Pass an _options_
+ object with a truthy `remove` property to destroy the container as well.
+
+ @method destroy
+ @param {Object} [options] Options.
+ @param {Boolean} [options.remove=false] If `true`, this View's container
+ will be removed from the DOM and destroyed as well.
+ @chainable
+ */
+ destroy: function (options) {
+ // We also accept `delete` as a synonym for `remove`.
+ if (options && (options.remove || options['delete'])) {
+ // Attaching an event handler here because the `destroy` event is
+ // preventable. If we destroyed the container before calling the
+ // superclass's `destroy()` method and the event was prevented, the
+ // class would end up in a broken state.
+ this.onceAfter('destroy', function () {
+ this._destroyContainer();
+ });
+ }
+
+ return View.superclass.destroy.call(this);
+ },
+
+ destructor: function () {
+ this.detachEvents();
+ delete this._container;
+ },
+
+ // -- Public Methods -------------------------------------------------------
+
+ /**
+ Attaches delegated event handlers to this view's container element. This
+ method is called internally to subscribe to events configured in the
+ `events` attribute when the view is initialized.
+
+ You may override this method to customize the event attaching logic.
+
+ @method attachEvents
+ @param {Object} [events] Hash of events to attach. See the docs for the
+ `events` attribute for details on the format. If not specified, this
+ view's `events` property will be used.
+ @chainable
+ @see detachEvents
+ **/
+ attachEvents: function (events) {
+ var container = this.get('container'),
+ owns = Y.Object.owns,
+ handler, handlers, name, selector;
+
+ this.detachEvents();
+
+ events || (events = this.events);
+
+ for (selector in events) {
+ if (!owns(events, selector)) { continue; }
+
+ handlers = events[selector];
+
+ for (name in handlers) {
+ if (!owns(handlers, name)) { continue; }
+
+ handler = handlers[name];
+
+ // TODO: Make this more robust by using lazy-binding:
+ // `handler = Y.bind(handler, this);`
+ if (typeof handler === 'string') {
+ handler = this[handler];
+ }
+
+ if (!handler) {
+ continue;
+ }
+
+ this._attachedViewEvents.push(
+ container.delegate(name, handler, selector, this));
+ }
+ }
+
+ return this;
+ },
+
+ /**
+ Creates and returns a container node for this view.
+
+ By default, the container is created from the HTML template specified in the
+ `containerTemplate` property, and is _not_ added to the DOM automatically.
+
+ You may override this method to customize how the container node is created
+ (such as by rendering it from a custom template format). Your method must
+ return a `Y.Node` instance.
+
+ @method create
+ @param {HTMLElement|Node|String} [container] Selector string, `Y.Node`
+ instance, or DOM element to use at the container node.
+ @return {Node} Node instance of the created container node.
+ **/
+ create: function (container) {
+ return container ? Y.one(container) :
+ Y.Node.create(this.containerTemplate);
+ },
+
+ /**
+ Detaches DOM events that have previously been attached to the container by
+ `attachEvents()`.
+
+ @method detachEvents
+ @chainable
+ @see attachEvents
+ **/
+ detachEvents: function () {
+ Y.Array.each(this._attachedViewEvents, function (handle) {
+ if (handle) {
+ handle.detach();
+ }
+ });
+
+ this._attachedViewEvents = [];
+ return this;
+ },
+
+ /**
+ Removes this view's container element from the DOM (if it's in the DOM),
+ but doesn't destroy it or any event listeners attached to it.
+
+ @method remove
+ @chainable
+ **/
+ remove: function () {
+ var container = this.get('container');
+ container && container.remove();
+ return this;
+ },
+
+ /**
+ Renders this view.
+
+ This method is a noop by default. Override it to provide a custom
+ implementation that renders this view's content and appends it to the
+ container element. Ideally your `render` method should also return `this` as
+ the end to allow chaining, but that's up to you.
+
+ Since there's no default renderer, you're free to render your view however
+ you see fit, whether that means manipulating the DOM directly, dumping
+ strings into `innerHTML`, or using a template language of some kind.
+
+ For basic templating needs, `Y.Node.create()` and `Y.Lang.sub()` may
+ suffice, but there are no restrictions on what tools or techniques you can
+ use to render your view. All you need to do is append something to the
+ container element at some point, and optionally append the container
+ to the DOM if it's not there already.
+
+ @method render
+ @chainable
+ **/
+ render: function () {
+ return this;
+ },
+
+ // -- Protected Methods ----------------------------------------------------
+
+ /**
+ Removes the `container` from the DOM and purges all its event listeners.
+
+ @method _destroyContainer
+ @protected
+ **/
+ _destroyContainer: function () {
+ var container = this.get('container');
+ container && container.remove(true);
+ },
+
+ /**
+ Getter for the `container` attribute.
+
+ @method _getContainer
+ @param {Node|null} value Current attribute value.
+ @return {Node} Container node.
+ @protected
+ @since 3.5.0
+ **/
+ _getContainer: function (value) {
+ // This wackiness is necessary to enable fully lazy creation of the
+ // container node both when no container is specified and when one is
+ // specified via a valueFn.
+
+ if (!this._container) {
+ if (value) {
+ // Attach events to the container when it's specified via a
+ // valueFn, which won't fire the containerChange event.
+ this._container = value;
+ this.attachEvents();
+ } else {
+ // Create a default container and set that as the new attribute
+ // value. The `this._container` property prevents infinite
+ // recursion.
+ value = this._container = this.create();
+ this._set('container', value);
+ }
+ }
+
+ return value;
+ },
+
+ // -- Protected Event Handlers ---------------------------------------------
+
+ /**
+ Handles `containerChange` events. Detaches event handlers from the old
+ container (if any) and attaches them to the new container.
+
+ Right now the `container` attr is initOnly so this event should only ever
+ fire the first time the container is created, but in the future (once Y.App
+ can handle it) we may allow runtime container changes.
+
+ @method _afterContainerChange
+ @protected
+ @since 3.5.0
+ **/
+ _afterContainerChange: function () {
+ this.attachEvents(this.events);
+ }
+}, {
+ NAME: 'view',
+
+ ATTRS: {
+ /**
+ Container node into which this view's content will be rendered.
+
+ The container node serves as the host for all DOM events attached by the
+ view. Delegation is used to handle events on children of the container,
+ allowing the container's contents to be re-rendered at any time without
+ losing event subscriptions.
+
+ The default container is a `<div>` Node, but you can override this in
+ a subclass, or by passing in a custom `container` config value at
+ instantiation time. If you override the default container in a subclass
+ using `ATTRS`, you must use the `valueFn` property. The view's constructor
+ will ignore any assignments using `value`.
+
+ When `container` is overridden by a subclass or passed as a config
+ option at instantiation time, you can provide it as a selector string, a
+ DOM element, a `Y.Node` instance, or (if you are subclassing and modifying
+ the attribute), a `valueFn` function that returns a `Y.Node` instance.
+ The value will be converted into a `Y.Node` instance if it isn't one
+ already.
+
+ The container is not added to the page automatically. This allows you to
+ have full control over how and when your view is actually rendered to
+ the page.
+
+ @attribute container
+ @type HTMLElement|Node|String
+ @default Y.Node.create(this.containerTemplate)
+ @writeOnce
+ **/
+ container: {
+ getter : '_getContainer',
+ setter : Y.one,
+ writeOnce: true
+ }
+ },
+
+ /**
+ Properties that shouldn't be turned into ad-hoc attributes when passed to
+ View's constructor.
+
+ @property _NON_ATTRS_CFG
+ @type Array
+ @static
+ @protected
+ @since 3.5.0
+ **/
+ _NON_ATTRS_CFG: [
+ 'containerTemplate',
+ 'events',
+ 'template'
+ ]
+});
+
+
+
+}, '3.10.3', {"requires": ["base-build", "node-event-delegate"]});