openerp-community team mailing list archive
-
openerp-community team
-
Mailing list archive
-
Message #03928
[Merge] lp:~openerp-community/web-addons/7.0-web-unleashed into lp:web-addons
Michel Meyer has proposed merging lp:~openerp-community/web-addons/7.0-web-unleashed into lp:web-addons.
Commit message:
web unleased: core module for an easy web module development, see https://github.com/trobz/openerp-web-unleashed
Requested reviews:
Web-Addons Core Editors (webaddons-core-editors)
For more details, see:
https://code.launchpad.net/~openerp-community/web-addons/7.0-web-unleashed/+merge/194639
New core module for an easy web module development:
- clear MVC pattern, based on Backbone and Marionnette... with all their documentations !
- new namespace to organize and get access to your objects
- full-featured Backbone Models with OpenERP JSON-RPC API support
-QWeb rendering for Marionette views
- base objects to build custom views (Pager, Grouped Collection, Extended OpenERP View, State manager...)
-unit tests for basic functionalities
- load/configuration commonly used libraries (momentjs, numeraljs, awesome-font,...)
Check the doc on https://github.com/trobz/openerp-web-unleashed
--
The attached diff has been truncated due to its size.
https://code.launchpad.net/~openerp-community/web-addons/7.0-web-unleashed/+merge/194639
Your team OpenERP Community is subscribed to branch lp:~openerp-community/web-addons/7.0-web-unleashed.
=== added directory 'web_unleashed'
=== added file 'web_unleashed/__init__.py'
--- web_unleashed/__init__.py 1970-01-01 00:00:00 +0000
+++ web_unleashed/__init__.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+import tests
=== added file 'web_unleashed/__openerp__.py'
--- web_unleashed/__openerp__.py 1970-01-01 00:00:00 +0000
+++ web_unleashed/__openerp__.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+{
+ 'name': 'Web Unleashed',
+ 'version': '1.0',
+ 'category': 'Hidden',
+
+ 'description': """
+Core Web Module:
+
+- improve code architecture and organization
+- add support of Backbone and Marionette frameworks
+- native support of JSON-RPC API for Backbone
+ """,
+
+ 'author': 'Trobz',
+ 'website': 'https://github.com/trobz/openerp-web-unleashed',
+
+ 'depends': [
+ 'web'
+ ],
+
+ 'qweb' : [
+ 'static/src/templates/*.xml',
+ ],
+
+ 'css' : [
+ 'static/src/css/pager.css',
+ ],
+
+ 'js': [
+ # backbone 1.1.0 and underscore 1.5.2 used in no conflict mode, see `unleashed.js` for more details
+ 'static/lib/underscore/underscore.js',
+ 'static/lib/backbone/backbone.js',
+
+ # backbone.marionette 1.1.0
+ 'static/lib/marionette/marionette.js',
+
+ # addons for libs
+ 'static/lib/jquery-addons/jquery.font_size.js',
+ 'static/lib/jquery-addons/jquery.when_all.js',
+ 'static/lib/jquery-addons/jquery.serialize_object.js',
+ 'static/lib/jquery-addons/jquery.form_reset.js',
+ 'static/lib/underscore-addons/underscore.deep_extend.js',
+ 'static/lib/underscore-addons/underscore.find_index_where.js',
+
+ # manage object instanciation and sync support for backbone models
+ 'static/src/js/core/unleashed.js',
+
+ # utils
+ 'static/src/js/utils/connector.js',
+
+ # controller
+ 'static/src/js/controllers/pager.js',
+
+ # backbone base models
+ 'static/src/js/models/base.js',
+ 'static/src/js/models/query.js',
+ 'static/src/js/models/iterator.js',
+ 'static/src/js/models/state.js',
+
+ # backbone base collections
+ 'static/src/js/collections/base.js',
+ 'static/src/js/collections/pager.js',
+ 'static/src/js/collections/group.js',
+ 'static/src/js/collections/iterator.js',
+
+ # backbone base views
+ 'static/src/js/views/view.js',
+ 'static/src/js/views/base.js',
+ 'static/src/js/views/region.js',
+ 'static/src/js/views/pager.js',
+ 'static/src/js/views/panel.js',
+ 'static/src/js/views/unleashed.js',
+ ],
+
+ 'test': [
+ 'static/src/tests/group.js',
+ 'static/src/tests/pager.js',
+ 'static/src/tests/connector.js',
+ ]
+}
=== added directory 'web_unleashed/static'
=== added directory 'web_unleashed/static/lib'
=== added directory 'web_unleashed/static/lib/backbone'
=== added file 'web_unleashed/static/lib/backbone/backbone.js'
--- web_unleashed/static/lib/backbone/backbone.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/backbone/backbone.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,1581 @@
+// Backbone.js 1.1.0
+
+// (c) 2010-2011 Jeremy Ashkenas, DocumentCloud Inc.
+// (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+// Backbone may be freely distributed under the MIT license.
+// For all details and documentation:
+// http://backbonejs.org
+
+(function(){
+
+ // Initial Setup
+ // -------------
+
+ // Save a reference to the global object (`window` in the browser, `exports`
+ // on the server).
+ var root = this;
+
+ // Save the previous value of the `Backbone` variable, so that it can be
+ // restored later on, if `noConflict` is used.
+ var previousBackbone = root.Backbone;
+
+ // Create local references to array methods we'll want to use later.
+ var array = [];
+ var push = array.push;
+ var slice = array.slice;
+ var splice = array.splice;
+
+ // The top-level namespace. All public Backbone classes and modules will
+ // be attached to this. Exported for both the browser and the server.
+ var Backbone;
+ if (typeof exports !== 'undefined') {
+ Backbone = exports;
+ } else {
+ Backbone = root.Backbone = {};
+ }
+
+ // Current version of the library. Keep in sync with `package.json`.
+ Backbone.VERSION = '1.1.0';
+
+ // Require Underscore, if we're on the server, and it's not already present.
+ var _ = root._;
+ if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
+
+ // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
+ // the `$` variable.
+ Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
+
+ // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
+ // to its previous owner. Returns a reference to this Backbone object.
+ Backbone.noConflict = function() {
+ root.Backbone = previousBackbone;
+ return this;
+ };
+
+ // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
+ // will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and
+ // set a `X-Http-Method-Override` header.
+ Backbone.emulateHTTP = false;
+
+ // Turn on `emulateJSON` to support legacy servers that can't deal with direct
+ // `application/json` requests ... will encode the body as
+ // `application/x-www-form-urlencoded` instead and will send the model in a
+ // form param named `model`.
+ Backbone.emulateJSON = false;
+
+ // Backbone.Events
+ // ---------------
+
+ // A module that can be mixed in to *any object* in order to provide it with
+ // custom events. You may bind with `on` or remove with `off` callback
+ // functions to an event; `trigger`-ing an event fires all callbacks in
+ // succession.
+ //
+ // var object = {};
+ // _.extend(object, Backbone.Events);
+ // object.on('expand', function(){ alert('expanded'); });
+ // object.trigger('expand');
+ //
+ var Events = Backbone.Events = {
+
+ // Bind an event to a `callback` function. Passing `"all"` will bind
+ // the callback to all events fired.
+ on: function(name, callback, context) {
+ if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
+ this._events || (this._events = {});
+ var events = this._events[name] || (this._events[name] = []);
+ events.push({callback: callback, context: context, ctx: context || this});
+ return this;
+ },
+
+ // Bind an event to only be triggered a single time. After the first time
+ // the callback is invoked, it will be removed.
+ once: function(name, callback, context) {
+ if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
+ var self = this;
+ var once = _.once(function() {
+ self.off(name, once);
+ callback.apply(this, arguments);
+ });
+ once._callback = callback;
+ return this.on(name, once, context);
+ },
+
+ // Remove one or many callbacks. If `context` is null, removes all
+ // callbacks with that function. If `callback` is null, removes all
+ // callbacks for the event. If `name` is null, removes all bound
+ // callbacks for all events.
+ off: function(name, callback, context) {
+ var retain, ev, events, names, i, l, j, k;
+ if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+ if (!name && !callback && !context) {
+ this._events = {};
+ return this;
+ }
+ names = name ? [name] : _.keys(this._events);
+ for (i = 0, l = names.length; i < l; i++) {
+ name = names[i];
+ if (events = this._events[name]) {
+ this._events[name] = retain = [];
+ if (callback || context) {
+ for (j = 0, k = events.length; j < k; j++) {
+ ev = events[j];
+ if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
+ (context && context !== ev.context)) {
+ retain.push(ev);
+ }
+ }
+ }
+ if (!retain.length) delete this._events[name];
+ }
+ }
+
+ return this;
+ },
+
+ // Trigger one or many events, firing all bound callbacks. Callbacks are
+ // passed the same arguments as `trigger` is, apart from the event name
+ // (unless you're listening on `"all"`, which will cause your callback to
+ // receive the true name of the event as the first argument).
+ trigger: function(name) {
+ if (!this._events) return this;
+ var args = slice.call(arguments, 1);
+ if (!eventsApi(this, 'trigger', name, args)) return this;
+ var events = this._events[name];
+ var allEvents = this._events.all;
+ if (events) triggerEvents(events, args);
+ if (allEvents) triggerEvents(allEvents, arguments);
+ return this;
+ },
+
+ // Tell this object to stop listening to either specific events ... or
+ // to every object it's currently listening to.
+ stopListening: function(obj, name, callback) {
+ var listeningTo = this._listeningTo;
+ if (!listeningTo) return this;
+ var remove = !name && !callback;
+ if (!callback && typeof name === 'object') callback = this;
+ if (obj) (listeningTo = {})[obj._listenId] = obj;
+ for (var id in listeningTo) {
+ obj = listeningTo[id];
+ obj.off(name, callback, this);
+ if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
+ }
+ return this;
+ }
+
+ };
+
+ // Regular expression used to split event strings.
+ var eventSplitter = /\s+/;
+
+ // Implement fancy features of the Events API such as multiple event
+ // names `"change blur"` and jQuery-style event maps `{change: action}`
+ // in terms of the existing API.
+ var eventsApi = function(obj, action, name, rest) {
+ if (!name) return true;
+
+ // Handle event maps.
+ if (typeof name === 'object') {
+ for (var key in name) {
+ obj[action].apply(obj, [key, name[key]].concat(rest));
+ }
+ return false;
+ }
+
+ // Handle space separated event names.
+ if (eventSplitter.test(name)) {
+ var names = name.split(eventSplitter);
+ for (var i = 0, l = names.length; i < l; i++) {
+ obj[action].apply(obj, [names[i]].concat(rest));
+ }
+ return false;
+ }
+
+ return true;
+ };
+
+ // A difficult-to-believe, but optimized internal dispatch function for
+ // triggering events. Tries to keep the usual cases speedy (most internal
+ // Backbone events have 3 arguments).
+ var triggerEvents = function(events, args) {
+ var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
+ switch (args.length) {
+ case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
+ case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
+ case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
+ case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
+ default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+ }
+ };
+
+ var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
+
+ // Inversion-of-control versions of `on` and `once`. Tell *this* object to
+ // listen to an event in another object ... keeping track of what it's
+ // listening to.
+ _.each(listenMethods, function(implementation, method) {
+ Events[method] = function(obj, name, callback) {
+ var listeningTo = this._listeningTo || (this._listeningTo = {});
+ var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
+ listeningTo[id] = obj;
+ if (!callback && typeof name === 'object') callback = this;
+ obj[implementation](name, callback, this);
+ return this;
+ };
+ });
+
+ // Aliases for backwards compatibility.
+ Events.bind = Events.on;
+ Events.unbind = Events.off;
+
+ // Allow the `Backbone` object to serve as a global event bus, for folks who
+ // want global "pubsub" in a convenient place.
+ _.extend(Backbone, Events);
+
+ // Backbone.Model
+ // --------------
+
+ // Backbone **Models** are the basic data object in the framework --
+ // frequently representing a row in a table in a database on your server.
+ // A discrete chunk of data and a bunch of useful, related methods for
+ // performing computations and transformations on that data.
+
+ // Create a new model with the specified attributes. A client id (`cid`)
+ // is automatically generated and assigned for you.
+ var Model = Backbone.Model = function(attributes, options) {
+ var attrs = attributes || {};
+ options || (options = {});
+ this.cid = _.uniqueId('c');
+ this.attributes = {};
+ if (options.collection) this.collection = options.collection;
+ if (options.parse) attrs = this.parse(attrs, options) || {};
+ attrs = _.defaults({}, attrs, _.result(this, 'defaults'));
+ this.set(attrs, options);
+ this.changed = {};
+ this.initialize.apply(this, arguments);
+ };
+
+ // Attach all inheritable methods to the Model prototype.
+ _.extend(Model.prototype, Events, {
+
+ // A hash of attributes whose current and previous value differ.
+ changed: null,
+
+ // The value returned during the last failed validation.
+ validationError: null,
+
+ // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+ // CouchDB users may want to set this to `"_id"`.
+ idAttribute: 'id',
+
+ // Initialize is an empty function by default. Override it with your own
+ // initialization logic.
+ initialize: function(){},
+
+ // Return a copy of the model's `attributes` object.
+ toJSON: function(options) {
+ return _.clone(this.attributes);
+ },
+
+ // Proxy `Backbone.sync` by default -- but override this if you need
+ // custom syncing semantics for *this* particular model.
+ sync: function() {
+ return Backbone.sync.apply(this, arguments);
+ },
+
+ // Get the value of an attribute.
+ get: function(attr) {
+ return this.attributes[attr];
+ },
+
+ // Get the HTML-escaped value of an attribute.
+ escape: function(attr) {
+ return _.escape(this.get(attr));
+ },
+
+ // Returns `true` if the attribute contains a value that is not null
+ // or undefined.
+ has: function(attr) {
+ return this.get(attr) != null;
+ },
+
+ // Set a hash of model attributes on the object, firing `"change"`. This is
+ // the core primitive operation of a model, updating the data and notifying
+ // anyone who needs to know about the change in state. The heart of the beast.
+ set: function(key, val, options) {
+ var attr, attrs, unset, changes, silent, changing, prev, current;
+ if (key == null) return this;
+
+ // Handle both `"key", value` and `{key: value}` -style arguments.
+ if (typeof key === 'object') {
+ attrs = key;
+ options = val;
+ } else {
+ (attrs = {})[key] = val;
+ }
+
+ options || (options = {});
+
+ // Run validation.
+ if (!this._validate(attrs, options)) return false;
+
+ // Extract attributes and options.
+ unset = options.unset;
+ silent = options.silent;
+ changes = [];
+ changing = this._changing;
+ this._changing = true;
+
+ if (!changing) {
+ this._previousAttributes = _.clone(this.attributes);
+ this.changed = {};
+ }
+ current = this.attributes, prev = this._previousAttributes;
+
+ // Check for changes of `id`.
+ if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+ // For each `set` attribute, update or delete the current value.
+ for (attr in attrs) {
+ val = attrs[attr];
+ if (!_.isEqual(current[attr], val)) changes.push(attr);
+ if (!_.isEqual(prev[attr], val)) {
+ this.changed[attr] = val;
+ } else {
+ delete this.changed[attr];
+ }
+ unset ? delete current[attr] : current[attr] = val;
+ }
+
+ // Trigger all relevant attribute changes.
+ if (!silent) {
+ if (changes.length) this._pending = true;
+ for (var i = 0, l = changes.length; i < l; i++) {
+ this.trigger('change:' + changes[i], this, current[changes[i]], options);
+ }
+ }
+
+ // You might be wondering why there's a `while` loop here. Changes can
+ // be recursively nested within `"change"` events.
+ if (changing) return this;
+ if (!silent) {
+ while (this._pending) {
+ this._pending = false;
+ this.trigger('change', this, options);
+ }
+ }
+ this._pending = false;
+ this._changing = false;
+ return this;
+ },
+
+ // Remove an attribute from the model, firing `"change"`. `unset` is a noop
+ // if the attribute doesn't exist.
+ unset: function(attr, options) {
+ return this.set(attr, void 0, _.extend({}, options, {unset: true}));
+ },
+
+ // Clear all attributes on the model, firing `"change"`.
+ clear: function(options) {
+ var attrs = {};
+ for (var key in this.attributes) attrs[key] = void 0;
+ return this.set(attrs, _.extend({}, options, {unset: true}));
+ },
+
+ // Determine if the model has changed since the last `"change"` event.
+ // If you specify an attribute name, determine if that attribute has changed.
+ hasChanged: function(attr) {
+ if (attr == null) return !_.isEmpty(this.changed);
+ return _.has(this.changed, attr);
+ },
+
+ // Return an object containing all the attributes that have changed, or
+ // false if there are no changed attributes. Useful for determining what
+ // parts of a view need to be updated and/or what attributes need to be
+ // persisted to the server. Unset attributes will be set to undefined.
+ // You can also pass an attributes object to diff against the model,
+ // determining if there *would be* a change.
+ changedAttributes: function(diff) {
+ if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
+ var val, changed = false;
+ var old = this._changing ? this._previousAttributes : this.attributes;
+ for (var attr in diff) {
+ if (_.isEqual(old[attr], (val = diff[attr]))) continue;
+ (changed || (changed = {}))[attr] = val;
+ }
+ return changed;
+ },
+
+ // Get the previous value of an attribute, recorded at the time the last
+ // `"change"` event was fired.
+ previous: function(attr) {
+ if (attr == null || !this._previousAttributes) return null;
+ return this._previousAttributes[attr];
+ },
+
+ // Get all of the attributes of the model at the time of the previous
+ // `"change"` event.
+ previousAttributes: function() {
+ return _.clone(this._previousAttributes);
+ },
+
+ // Fetch the model from the server. If the server's representation of the
+ // model differs from its current attributes, they will be overridden,
+ // triggering a `"change"` event.
+ fetch: function(options) {
+ options = options ? _.clone(options) : {};
+ if (options.parse === void 0) options.parse = true;
+ var model = this;
+ var success = options.success;
+ options.success = function(resp) {
+ if (!model.set(model.parse(resp, options), options)) return false;
+ if (success) success(model, resp, options);
+ model.trigger('sync', model, resp, options);
+ };
+ wrapError(this, options);
+ return this.sync('read', this, options);
+ },
+
+ // Set a hash of model attributes, and sync the model to the server.
+ // If the server returns an attributes hash that differs, the model's
+ // state will be `set` again.
+ save: function(key, val, options) {
+ var attrs, method, xhr, attributes = this.attributes;
+
+ // Handle both `"key", value` and `{key: value}` -style arguments.
+ if (key == null || typeof key === 'object') {
+ attrs = key;
+ options = val;
+ } else {
+ (attrs = {})[key] = val;
+ }
+
+ options = _.extend({validate: true}, options);
+
+ // If we're not waiting and attributes exist, save acts as
+ // `set(attr).save(null, opts)` with validation. Otherwise, check if
+ // the model will be valid when the attributes, if any, are set.
+ if (attrs && !options.wait) {
+ if (!this.set(attrs, options)) return false;
+ } else {
+ if (!this._validate(attrs, options)) return false;
+ }
+
+ // Set temporary attributes if `{wait: true}`.
+ if (attrs && options.wait) {
+ this.attributes = _.extend({}, attributes, attrs);
+ }
+
+ // After a successful server-side save, the client is (optionally)
+ // updated with the server-side state.
+ if (options.parse === void 0) options.parse = true;
+ var model = this;
+ var success = options.success;
+ options.success = function(resp) {
+ // Ensure attributes are restored during synchronous saves.
+ model.attributes = attributes;
+ var serverAttrs = model.parse(resp, options);
+ if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+ if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+ return false;
+ }
+ if (success) success(model, resp, options);
+ model.trigger('sync', model, resp, options);
+ };
+ wrapError(this, options);
+
+ method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+ if (method === 'patch') options.attrs = attrs;
+ xhr = this.sync(method, this, options);
+
+ // Restore attributes.
+ if (attrs && options.wait) this.attributes = attributes;
+
+ return xhr;
+ },
+
+ // Destroy this model on the server if it was already persisted.
+ // Optimistically removes the model from its collection, if it has one.
+ // If `wait: true` is passed, waits for the server to respond before removal.
+ destroy: function(options) {
+ options = options ? _.clone(options) : {};
+ var model = this;
+ var success = options.success;
+
+ var destroy = function() {
+ model.trigger('destroy', model, model.collection, options);
+ };
+
+ options.success = function(resp) {
+ if (options.wait || model.isNew()) destroy();
+ if (success) success(model, resp, options);
+ if (!model.isNew()) model.trigger('sync', model, resp, options);
+ };
+
+ if (this.isNew()) {
+ options.success();
+ return false;
+ }
+ wrapError(this, options);
+
+ var xhr = this.sync('delete', this, options);
+ if (!options.wait) destroy();
+ return xhr;
+ },
+
+ // Default URL for the model's representation on the server -- if you're
+ // using Backbone's restful methods, override this to change the endpoint
+ // that will be called.
+ url: function() {
+ var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
+ if (this.isNew()) return base;
+ return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
+ },
+
+ // **parse** converts a response into the hash of attributes to be `set` on
+ // the model. The default implementation is just to pass the response along.
+ parse: function(resp, options) {
+ return resp;
+ },
+
+ // Create a new model with identical attributes to this one.
+ clone: function() {
+ return new this.constructor(this.attributes);
+ },
+
+ // A model is new if it has never been saved to the server, and lacks an id.
+ isNew: function() {
+ return this.id == null;
+ },
+
+ // Check if the model is currently in a valid state.
+ isValid: function(options) {
+ return this._validate({}, _.extend(options || {}, { validate: true }));
+ },
+
+ // Run validation against the next complete set of model attributes,
+ // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+ _validate: function(attrs, options) {
+ if (!options.validate || !this.validate) return true;
+ attrs = _.extend({}, this.attributes, attrs);
+ var error = this.validationError = this.validate(attrs, options) || null;
+ if (!error) return true;
+ this.trigger('invalid', this, error, _.extend(options, {validationError: error}));
+ return false;
+ }
+
+ });
+
+ // Underscore methods that we want to implement on the Model.
+ var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
+
+ // Mix in each Underscore method as a proxy to `Model#attributes`.
+ _.each(modelMethods, function(method) {
+ Model.prototype[method] = function() {
+ var args = slice.call(arguments);
+ args.unshift(this.attributes);
+ return _[method].apply(_, args);
+ };
+ });
+
+ // Backbone.Collection
+ // -------------------
+
+ // If models tend to represent a single row of data, a Backbone Collection is
+ // more analagous to a table full of data ... or a small slice or page of that
+ // table, or a collection of rows that belong together for a particular reason
+ // -- all of the messages in this particular folder, all of the documents
+ // belonging to this particular author, and so on. Collections maintain
+ // indexes of their models, both in order, and for lookup by `id`.
+
+ // Create a new **Collection**, perhaps to contain a specific type of `model`.
+ // If a `comparator` is specified, the Collection will maintain
+ // its models in sort order, as they're added and removed.
+ var Collection = Backbone.Collection = function(models, options) {
+ options || (options = {});
+ if (options.model) this.model = options.model;
+ if (options.comparator !== void 0) this.comparator = options.comparator;
+ this._reset();
+ this.initialize.apply(this, arguments);
+ if (models) this.reset(models, _.extend({silent: true}, options));
+ };
+
+ // Default options for `Collection#set`.
+ var setOptions = {add: true, remove: true, merge: true};
+ var addOptions = {add: true, remove: false};
+
+ // Define the Collection's inheritable methods.
+ _.extend(Collection.prototype, Events, {
+
+ // The default model for a collection is just a **Backbone.Model**.
+ // This should be overridden in most cases.
+ model: Model,
+
+ // Initialize is an empty function by default. Override it with your own
+ // initialization logic.
+ initialize: function(){},
+
+ // The JSON representation of a Collection is an array of the
+ // models' attributes.
+ toJSON: function(options) {
+ return this.map(function(model){ return model.toJSON(options); });
+ },
+
+ // Proxy `Backbone.sync` by default.
+ sync: function() {
+ return Backbone.sync.apply(this, arguments);
+ },
+
+ // Add a model, or list of models to the set.
+ add: function(models, options) {
+ return this.set(models, _.extend({merge: false}, options, addOptions));
+ },
+
+ // Remove a model, or a list of models from the set.
+ remove: function(models, options) {
+ var singular = !_.isArray(models);
+ models = singular ? [models] : _.clone(models);
+ options || (options = {});
+ var i, l, index, model;
+ for (i = 0, l = models.length; i < l; i++) {
+ model = models[i] = this.get(models[i]);
+ if (!model) continue;
+ delete this._byId[model.id];
+ delete this._byId[model.cid];
+ index = this.indexOf(model);
+ this.models.splice(index, 1);
+ this.length--;
+ if (!options.silent) {
+ options.index = index;
+ model.trigger('remove', model, this, options);
+ }
+ this._removeReference(model);
+ }
+ return singular ? models[0] : models;
+ },
+
+ // Update a collection by `set`-ing a new list of models, adding new ones,
+ // removing models that are no longer present, and merging models that
+ // already exist in the collection, as necessary. Similar to **Model#set**,
+ // the core operation for updating the data contained by the collection.
+ set: function(models, options) {
+ options = _.defaults({}, options, setOptions);
+ if (options.parse) models = this.parse(models, options);
+ var singular = !_.isArray(models);
+ models = singular ? (models ? [models] : []) : _.clone(models);
+ var i, l, id, model, attrs, existing, sort;
+ var at = options.at;
+ var targetModel = this.model;
+ var sortable = this.comparator && (at == null) && options.sort !== false;
+ var sortAttr = _.isString(this.comparator) ? this.comparator : null;
+ var toAdd = [], toRemove = [], modelMap = {};
+ var add = options.add, merge = options.merge, remove = options.remove;
+ var order = !sortable && add && remove ? [] : false;
+
+ // Turn bare objects into model references, and prevent invalid models
+ // from being added.
+ for (i = 0, l = models.length; i < l; i++) {
+ attrs = models[i];
+ if (attrs instanceof Model) {
+ id = model = attrs;
+ } else {
+ id = attrs[targetModel.prototype.idAttribute];
+ }
+
+ // If a duplicate is found, prevent it from being added and
+ // optionally merge it into the existing model.
+ if (existing = this.get(id)) {
+ if (remove) modelMap[existing.cid] = true;
+ if (merge) {
+ attrs = attrs === model ? model.attributes : attrs;
+ if (options.parse) attrs = existing.parse(attrs, options);
+ existing.set(attrs, options);
+ if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
+ }
+ models[i] = existing;
+
+ // If this is a new, valid model, push it to the `toAdd` list.
+ } else if (add) {
+ model = models[i] = this._prepareModel(attrs, options);
+ if (!model) continue;
+ toAdd.push(model);
+
+ // Listen to added models' events, and index models for lookup by
+ // `id` and by `cid`.
+ model.on('all', this._onModelEvent, this);
+ this._byId[model.cid] = model;
+ if (model.id != null) this._byId[model.id] = model;
+ }
+ if (order) order.push(existing || model);
+ }
+
+ // Remove nonexistent models if appropriate.
+ if (remove) {
+ for (i = 0, l = this.length; i < l; ++i) {
+ if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+ }
+ if (toRemove.length) this.remove(toRemove, options);
+ }
+
+ // See if sorting is needed, update `length` and splice in new models.
+ if (toAdd.length || (order && order.length)) {
+ if (sortable) sort = true;
+ this.length += toAdd.length;
+ if (at != null) {
+ for (i = 0, l = toAdd.length; i < l; i++) {
+ this.models.splice(at + i, 0, toAdd[i]);
+ }
+ } else {
+ if (order) this.models.length = 0;
+ var orderedModels = order || toAdd;
+ for (i = 0, l = orderedModels.length; i < l; i++) {
+ this.models.push(orderedModels[i]);
+ }
+ }
+ }
+
+ // Silently sort the collection if appropriate.
+ if (sort) this.sort({silent: true});
+
+ // Unless silenced, it's time to fire all appropriate add/sort events.
+ if (!options.silent) {
+ for (i = 0, l = toAdd.length; i < l; i++) {
+ (model = toAdd[i]).trigger('add', model, this, options);
+ }
+ if (sort || (order && order.length)) this.trigger('sort', this, options);
+ }
+
+ // Return the added (or merged) model (or models).
+ return singular ? models[0] : models;
+ },
+
+ // When you have more items than you want to add or remove individually,
+ // you can reset the entire set with a new list of models, without firing
+ // any granular `add` or `remove` events. Fires `reset` when finished.
+ // Useful for bulk operations and optimizations.
+ reset: function(models, options) {
+ options || (options = {});
+ for (var i = 0, l = this.models.length; i < l; i++) {
+ this._removeReference(this.models[i]);
+ }
+ options.previousModels = this.models;
+ this._reset();
+ models = this.add(models, _.extend({silent: true}, options));
+ if (!options.silent) this.trigger('reset', this, options);
+ return models;
+ },
+
+ // Add a model to the end of the collection.
+ push: function(model, options) {
+ return this.add(model, _.extend({at: this.length}, options));
+ },
+
+ // Remove a model from the end of the collection.
+ pop: function(options) {
+ var model = this.at(this.length - 1);
+ this.remove(model, options);
+ return model;
+ },
+
+ // Add a model to the beginning of the collection.
+ unshift: function(model, options) {
+ return this.add(model, _.extend({at: 0}, options));
+ },
+
+ // Remove a model from the beginning of the collection.
+ shift: function(options) {
+ var model = this.at(0);
+ this.remove(model, options);
+ return model;
+ },
+
+ // Slice out a sub-array of models from the collection.
+ slice: function() {
+ return slice.apply(this.models, arguments);
+ },
+
+ // Get a model from the set by id.
+ get: function(obj) {
+ if (obj == null) return void 0;
+ return this._byId[obj.id] || this._byId[obj.cid] || this._byId[obj];
+ },
+
+ // Get the model at the given index.
+ at: function(index) {
+ return this.models[index];
+ },
+
+ // Return models with matching attributes. Useful for simple cases of
+ // `filter`.
+ where: function(attrs, first) {
+ if (_.isEmpty(attrs)) return first ? void 0 : [];
+ return this[first ? 'find' : 'filter'](function(model) {
+ for (var key in attrs) {
+ if (attrs[key] !== model.get(key)) return false;
+ }
+ return true;
+ });
+ },
+
+ // Return the first model with matching attributes. Useful for simple cases
+ // of `find`.
+ findWhere: function(attrs) {
+ return this.where(attrs, true);
+ },
+
+ // Force the collection to re-sort itself. You don't need to call this under
+ // normal circumstances, as the set will maintain sort order as each item
+ // is added.
+ sort: function(options) {
+ if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+ options || (options = {});
+
+ // Run sort based on type of `comparator`.
+ if (_.isString(this.comparator) || this.comparator.length === 1) {
+ this.models = this.sortBy(this.comparator, this);
+ } else {
+ this.models.sort(_.bind(this.comparator, this));
+ }
+
+ if (!options.silent) this.trigger('sort', this, options);
+ return this;
+ },
+
+ // Pluck an attribute from each model in the collection.
+ pluck: function(attr) {
+ return _.invoke(this.models, 'get', attr);
+ },
+
+ // Fetch the default set of models for this collection, resetting the
+ // collection when they arrive. If `reset: true` is passed, the response
+ // data will be passed through the `reset` method instead of `set`.
+ fetch: function(options) {
+ options = options ? _.clone(options) : {};
+ if (options.parse === void 0) options.parse = true;
+ var success = options.success;
+ var collection = this;
+ options.success = function(resp) {
+ var method = options.reset ? 'reset' : 'set';
+ collection[method](resp, options);
+ if (success) success(collection, resp, options);
+ collection.trigger('sync', collection, resp, options);
+ };
+ wrapError(this, options);
+ return this.sync('read', this, options);
+ },
+
+ // Create a new instance of a model in this collection. Add the model to the
+ // collection immediately, unless `wait: true` is passed, in which case we
+ // wait for the server to agree.
+ create: function(model, options) {
+ options = options ? _.clone(options) : {};
+ if (!(model = this._prepareModel(model, options))) return false;
+ if (!options.wait) this.add(model, options);
+ var collection = this;
+ var success = options.success;
+ options.success = function(model, resp, options) {
+ if (options.wait) collection.add(model, options);
+ if (success) success(model, resp, options);
+ };
+ model.save(null, options);
+ return model;
+ },
+
+ // **parse** converts a response into a list of models to be added to the
+ // collection. The default implementation is just to pass it through.
+ parse: function(resp, options) {
+ return resp;
+ },
+
+ // Create a new collection with an identical list of models as this one.
+ clone: function() {
+ return new this.constructor(this.models);
+ },
+
+ // Private method to reset all internal state. Called when the collection
+ // is first initialized or reset.
+ _reset: function() {
+ this.length = 0;
+ this.models = [];
+ this._byId = {};
+ },
+
+ // Prepare a hash of attributes (or other model) to be added to this
+ // collection.
+ _prepareModel: function(attrs, options) {
+ if (attrs instanceof Model) {
+ if (!attrs.collection) attrs.collection = this;
+ return attrs;
+ }
+ options = options ? _.clone(options) : {};
+ options.collection = this;
+ var model = new this.model(attrs, options);
+ if (!model.validationError) return model;
+ this.trigger('invalid', this, model.validationError, options);
+ return false;
+ },
+
+ // Internal method to sever a model's ties to a collection.
+ _removeReference: function(model) {
+ if (this === model.collection) delete model.collection;
+ model.off('all', this._onModelEvent, this);
+ },
+
+ // Internal method called every time a model in the set fires an event.
+ // Sets need to update their indexes when models change ids. All other
+ // events simply proxy through. "add" and "remove" events that originate
+ // in other collections are ignored.
+ _onModelEvent: function(event, model, collection, options) {
+ if ((event === 'add' || event === 'remove') && collection !== this) return;
+ if (event === 'destroy') this.remove(model, options);
+ if (model && event === 'change:' + model.idAttribute) {
+ delete this._byId[model.previous(model.idAttribute)];
+ if (model.id != null) this._byId[model.id] = model;
+ }
+ this.trigger.apply(this, arguments);
+ }
+
+ });
+
+ // Underscore methods that we want to implement on the Collection.
+ // 90% of the core usefulness of Backbone Collections is actually implemented
+ // right here:
+ var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+ 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+ 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+ 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+ 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
+ 'lastIndexOf', 'isEmpty', 'chain'];
+
+ // Mix in each Underscore method as a proxy to `Collection#models`.
+ _.each(methods, function(method) {
+ Collection.prototype[method] = function() {
+ var args = slice.call(arguments);
+ args.unshift(this.models);
+ return _[method].apply(_, args);
+ };
+ });
+
+ // Underscore methods that take a property name as an argument.
+ var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+ // Use attributes instead of properties.
+ _.each(attributeMethods, function(method) {
+ Collection.prototype[method] = function(value, context) {
+ var iterator = _.isFunction(value) ? value : function(model) {
+ return model.get(value);
+ };
+ return _[method](this.models, iterator, context);
+ };
+ });
+
+ // Backbone.View
+ // -------------
+
+ // Backbone Views are almost more convention than they are actual code. A View
+ // is simply a JavaScript object that represents a logical chunk of UI in the
+ // DOM. This might be a single item, an entire list, a sidebar or panel, or
+ // even the surrounding frame which wraps your whole app. Defining a chunk of
+ // UI as a **View** allows you to define your DOM events declaratively, without
+ // having to worry about render order ... and makes it easy for the view to
+ // react to specific changes in the state of your models.
+
+ // Creating a Backbone.View creates its initial element outside of the DOM,
+ // if an existing element is not provided...
+ var View = Backbone.View = function(options) {
+ this.cid = _.uniqueId('view');
+ options || (options = {});
+ _.extend(this, _.pick(options, viewOptions));
+ this._ensureElement();
+ this.initialize.apply(this, arguments);
+ this.delegateEvents();
+ };
+
+ // Cached regex to split keys for `delegate`.
+ var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+ // List of view options to be merged as properties.
+ var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+ // Set up all inheritable **Backbone.View** properties and methods.
+ _.extend(View.prototype, Events, {
+
+ // The default `tagName` of a View's element is `"div"`.
+ tagName: 'div',
+
+ // jQuery delegate for element lookup, scoped to DOM elements within the
+ // current view. This should be preferred to global lookups where possible.
+ $: function(selector) {
+ return this.$el.find(selector);
+ },
+
+ // Initialize is an empty function by default. Override it with your own
+ // initialization logic.
+ initialize: function(){},
+
+ // **render** is the core function that your view should override, in order
+ // to populate its element (`this.el`), with the appropriate HTML. The
+ // convention is for **render** to always return `this`.
+ render: function() {
+ return this;
+ },
+
+ // Remove this view by taking the element out of the DOM, and removing any
+ // applicable Backbone.Events listeners.
+ remove: function() {
+ this.$el.remove();
+ this.stopListening();
+ return this;
+ },
+
+ // Change the view's element (`this.el` property), including event
+ // re-delegation.
+ setElement: function(element, delegate) {
+ if (this.$el) this.undelegateEvents();
+ this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
+ this.el = this.$el[0];
+ if (delegate !== false) this.delegateEvents();
+ return this;
+ },
+
+ // Set callbacks, where `this.events` is a hash of
+ //
+ // *{"event selector": "callback"}*
+ //
+ // {
+ // 'mousedown .title': 'edit',
+ // 'click .button': 'save',
+ // 'click .open': function(e) { ... }
+ // }
+ //
+ // pairs. Callbacks will be bound to the view, with `this` set properly.
+ // Uses event delegation for efficiency.
+ // Omitting the selector binds the event to `this.el`.
+ // This only works for delegate-able events: not `focus`, `blur`, and
+ // not `change`, `submit`, and `reset` in Internet Explorer.
+ delegateEvents: function(events) {
+ if (!(events || (events = _.result(this, 'events')))) return this;
+ this.undelegateEvents();
+ for (var key in events) {
+ var method = events[key];
+ if (!_.isFunction(method)) method = this[events[key]];
+ if (!method) continue;
+
+ var match = key.match(delegateEventSplitter);
+ var eventName = match[1], selector = match[2];
+ method = _.bind(method, this);
+ eventName += '.delegateEvents' + this.cid;
+ if (selector === '') {
+ this.$el.on(eventName, method);
+ } else {
+ this.$el.on(eventName, selector, method);
+ }
+ }
+ return this;
+ },
+
+ // Clears all callbacks previously bound to the view with `delegateEvents`.
+ // You usually don't need to use this, but may wish to if you have multiple
+ // Backbone views attached to the same DOM element.
+ undelegateEvents: function() {
+ this.$el.off('.delegateEvents' + this.cid);
+ return this;
+ },
+
+ // Ensure that the View has a DOM element to render into.
+ // If `this.el` is a string, pass it through `$()`, take the first
+ // matching element, and re-assign it to `el`. Otherwise, create
+ // an element from the `id`, `className` and `tagName` properties.
+ _ensureElement: function() {
+ if (!this.el) {
+ var attrs = _.extend({}, _.result(this, 'attributes'));
+ if (this.id) attrs.id = _.result(this, 'id');
+ if (this.className) attrs['class'] = _.result(this, 'className');
+ var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
+ this.setElement($el, false);
+ } else {
+ this.setElement(_.result(this, 'el'), false);
+ }
+ }
+
+ });
+
+ // Backbone.sync
+ // -------------
+
+ // Override this function to change the manner in which Backbone persists
+ // models to the server. You will be passed the type of request, and the
+ // model in question. By default, makes a RESTful Ajax request
+ // to the model's `url()`. Some possible customizations could be:
+ //
+ // * Use `setTimeout` to batch rapid-fire updates into a single request.
+ // * Send up the models as XML instead of JSON.
+ // * Persist models via WebSockets instead of Ajax.
+ //
+ // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
+ // as `POST`, with a `_method` parameter containing the true HTTP method,
+ // as well as all requests with the body as `application/x-www-form-urlencoded`
+ // instead of `application/json` with the model in a param named `model`.
+ // Useful when interfacing with server-side languages like **PHP** that make
+ // it difficult to read the body of `PUT` requests.
+ Backbone.sync = function(method, model, options) {
+ var type = methodMap[method];
+
+ // Default options, unless specified.
+ _.defaults(options || (options = {}), {
+ emulateHTTP: Backbone.emulateHTTP,
+ emulateJSON: Backbone.emulateJSON
+ });
+
+ // Default JSON-request options.
+ var params = {type: type, dataType: 'json'};
+
+ // Ensure that we have a URL.
+ if (!options.url) {
+ params.url = _.result(model, 'url') || urlError();
+ }
+
+ // Ensure that we have the appropriate request data.
+ if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+ params.contentType = 'application/json';
+ params.data = JSON.stringify(options.attrs || model.toJSON(options));
+ }
+
+ // For older servers, emulate JSON by encoding the request into an HTML-form.
+ if (options.emulateJSON) {
+ params.contentType = 'application/x-www-form-urlencoded';
+ params.data = params.data ? {model: params.data} : {};
+ }
+
+ // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+ // And an `X-HTTP-Method-Override` header.
+ if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+ params.type = 'POST';
+ if (options.emulateJSON) params.data._method = type;
+ var beforeSend = options.beforeSend;
+ options.beforeSend = function(xhr) {
+ xhr.setRequestHeader('X-HTTP-Method-Override', type);
+ if (beforeSend) return beforeSend.apply(this, arguments);
+ };
+ }
+
+ // Don't process data on a non-GET request.
+ if (params.type !== 'GET' && !options.emulateJSON) {
+ params.processData = false;
+ }
+
+ // If we're sending a `PATCH` request, and we're in an old Internet Explorer
+ // that still has ActiveX enabled by default, override jQuery to use that
+ // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
+ if (params.type === 'PATCH' && noXhrPatch) {
+ params.xhr = function() {
+ return new ActiveXObject("Microsoft.XMLHTTP");
+ };
+ }
+
+ // Make the request, allowing the user to override any Ajax options.
+ var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
+ model.trigger('request', model, xhr, options);
+ return xhr;
+ };
+
+ var noXhrPatch = typeof window !== 'undefined' && !!window.ActiveXObject && !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);
+
+ // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+ var methodMap = {
+ 'create': 'POST',
+ 'update': 'PUT',
+ 'patch': 'PATCH',
+ 'delete': 'DELETE',
+ 'read': 'GET'
+ };
+
+ // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+ // Override this if you'd like to use a different library.
+ Backbone.ajax = function() {
+ return Backbone.$.ajax.apply(Backbone.$, arguments);
+ };
+
+ // Backbone.Router
+ // ---------------
+
+ // Routers map faux-URLs to actions, and fire events when routes are
+ // matched. Creating a new one sets its `routes` hash, if not set statically.
+ var Router = Backbone.Router = function(options) {
+ options || (options = {});
+ if (options.routes) this.routes = options.routes;
+ this._bindRoutes();
+ this.initialize.apply(this, arguments);
+ };
+
+ // Cached regular expressions for matching named param parts and splatted
+ // parts of route strings.
+ var optionalParam = /\((.*?)\)/g;
+ var namedParam = /(\(\?)?:\w+/g;
+ var splatParam = /\*\w+/g;
+ var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+
+ // Set up all inheritable **Backbone.Router** properties and methods.
+ _.extend(Router.prototype, Events, {
+
+ // Initialize is an empty function by default. Override it with your own
+ // initialization logic.
+ initialize: function(){},
+
+ // Manually bind a single named route to a callback. For example:
+ //
+ // this.route('search/:query/p:num', 'search', function(query, num) {
+ // ...
+ // });
+ //
+ route: function(route, name, callback) {
+ if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+ if (_.isFunction(name)) {
+ callback = name;
+ name = '';
+ }
+ if (!callback) callback = this[name];
+ var router = this;
+ Backbone.history.route(route, function(fragment) {
+ var args = router._extractParameters(route, fragment);
+ callback && callback.apply(router, args);
+ router.trigger.apply(router, ['route:' + name].concat(args));
+ router.trigger('route', name, args);
+ Backbone.history.trigger('route', router, name, args);
+ });
+ return this;
+ },
+
+ // Simple proxy to `Backbone.history` to save a fragment into the history.
+ navigate: function(fragment, options) {
+ Backbone.history.navigate(fragment, options);
+ return this;
+ },
+
+ // Bind all defined routes to `Backbone.history`. We have to reverse the
+ // order of the routes here to support behavior where the most general
+ // routes can be defined at the bottom of the route map.
+ _bindRoutes: function() {
+ if (!this.routes) return;
+ this.routes = _.result(this, 'routes');
+ var route, routes = _.keys(this.routes);
+ while ((route = routes.pop()) != null) {
+ this.route(route, this.routes[route]);
+ }
+ },
+
+ // Convert a route string into a regular expression, suitable for matching
+ // against the current location hash.
+ _routeToRegExp: function(route) {
+ route = route.replace(escapeRegExp, '\\$&')
+ .replace(optionalParam, '(?:$1)?')
+ .replace(namedParam, function(match, optional) {
+ return optional ? match : '([^\/]+)';
+ })
+ .replace(splatParam, '(.*?)');
+ return new RegExp('^' + route + '$');
+ },
+
+ // Given a route, and a URL fragment that it matches, return the array of
+ // extracted decoded parameters. Empty or unmatched parameters will be
+ // treated as `null` to normalize cross-browser behavior.
+ _extractParameters: function(route, fragment) {
+ var params = route.exec(fragment).slice(1);
+ return _.map(params, function(param) {
+ return param ? decodeURIComponent(param) : null;
+ });
+ }
+
+ });
+
+ // Backbone.History
+ // ----------------
+
+ // Handles cross-browser history management, based on either
+ // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
+ // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
+ // and URL fragments. If the browser supports neither (old IE, natch),
+ // falls back to polling.
+ var History = Backbone.History = function() {
+ this.handlers = [];
+ _.bindAll(this, 'checkUrl');
+
+ // Ensure that `History` can be used outside of the browser.
+ if (typeof window !== 'undefined') {
+ this.location = window.location;
+ this.history = window.history;
+ }
+ };
+
+ // Cached regex for stripping a leading hash/slash and trailing space.
+ var routeStripper = /^[#\/]|\s+$/g;
+
+ // Cached regex for stripping leading and trailing slashes.
+ var rootStripper = /^\/+|\/+$/g;
+
+ // Cached regex for detecting MSIE.
+ var isExplorer = /msie [\w.]+/;
+
+ // Cached regex for removing a trailing slash.
+ var trailingSlash = /\/$/;
+
+ // Cached regex for stripping urls of hash and query.
+ var pathStripper = /[?#].*$/;
+
+ // Has the history handling already been started?
+ History.started = false;
+
+ // Set up all inheritable **Backbone.History** properties and methods.
+ _.extend(History.prototype, Events, {
+
+ // The default interval to poll for hash changes, if necessary, is
+ // twenty times a second.
+ interval: 50,
+
+ // Gets the true hash value. Cannot use location.hash directly due to bug
+ // in Firefox where location.hash will always be decoded.
+ getHash: function(window) {
+ var match = (window || this).location.href.match(/#(.*)$/);
+ return match ? match[1] : '';
+ },
+
+ // Get the cross-browser normalized URL fragment, either from the URL,
+ // the hash, or the override.
+ getFragment: function(fragment, forcePushState) {
+ if (fragment == null) {
+ if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+ fragment = this.location.pathname;
+ var root = this.root.replace(trailingSlash, '');
+ if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
+ } else {
+ fragment = this.getHash();
+ }
+ }
+ return fragment.replace(routeStripper, '');
+ },
+
+ // Start the hash change handling, returning `true` if the current URL matches
+ // an existing route, and `false` otherwise.
+ start: function(options) {
+ if (History.started) throw new Error("Backbone.history has already been started");
+ History.started = true;
+
+ // Figure out the initial configuration. Do we need an iframe?
+ // Is pushState desired ... is it available?
+ this.options = _.extend({root: '/'}, this.options, options);
+ this.root = this.options.root;
+ this._wantsHashChange = this.options.hashChange !== false;
+ this._wantsPushState = !!this.options.pushState;
+ this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);
+ var fragment = this.getFragment();
+ var docMode = document.documentMode;
+ var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+
+ // Normalize root to always include a leading and trailing slash.
+ this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+ if (oldIE && this._wantsHashChange) {
+ this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+ this.navigate(fragment);
+ }
+
+ // Depending on whether we're using pushState or hashes, and whether
+ // 'onhashchange' is supported, determine how we check the URL state.
+ if (this._hasPushState) {
+ Backbone.$(window).on('popstate', this.checkUrl);
+ } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
+ Backbone.$(window).on('hashchange', this.checkUrl);
+ } else if (this._wantsHashChange) {
+ this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+ }
+
+ // Determine if we need to change the base url, for a pushState link
+ // opened by a non-pushState browser.
+ this.fragment = fragment;
+ var loc = this.location;
+ var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
+
+ // Transition from hashChange to pushState or vice versa if both are
+ // requested.
+ if (this._wantsHashChange && this._wantsPushState) {
+
+ // If we've started off with a route from a `pushState`-enabled
+ // browser, but we're currently in a browser that doesn't support it...
+ if (!this._hasPushState && !atRoot) {
+ this.fragment = this.getFragment(null, true);
+ this.location.replace(this.root + this.location.search + '#' + this.fragment);
+ // Return immediately as browser will do redirect to new url
+ return true;
+
+ // Or if we've started out with a hash-based route, but we're currently
+ // in a browser where it could be `pushState`-based instead...
+ } else if (this._hasPushState && atRoot && loc.hash) {
+ this.fragment = this.getHash().replace(routeStripper, '');
+ this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
+ }
+
+ }
+
+ if (!this.options.silent) return this.loadUrl();
+ },
+
+ // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
+ // but possibly useful for unit testing Routers.
+ stop: function() {
+ Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+ clearInterval(this._checkUrlInterval);
+ History.started = false;
+ },
+
+ // Add a route to be tested when the fragment changes. Routes added later
+ // may override previous routes.
+ route: function(route, callback) {
+ this.handlers.unshift({route: route, callback: callback});
+ },
+
+ // Checks the current URL to see if it has changed, and if it has,
+ // calls `loadUrl`, normalizing across the hidden iframe.
+ checkUrl: function(e) {
+ var current = this.getFragment();
+ if (current === this.fragment && this.iframe) {
+ current = this.getFragment(this.getHash(this.iframe));
+ }
+ if (current === this.fragment) return false;
+ if (this.iframe) this.navigate(current);
+ this.loadUrl();
+ },
+
+ // Attempt to load the current URL fragment. If a route succeeds with a
+ // match, returns `true`. If no defined routes matches the fragment,
+ // returns `false`.
+ loadUrl: function(fragment) {
+ fragment = this.fragment = this.getFragment(fragment);
+ return _.any(this.handlers, function(handler) {
+ if (handler.route.test(fragment)) {
+ handler.callback(fragment);
+ return true;
+ }
+ });
+ },
+
+ // Save a fragment into the hash history, or replace the URL state if the
+ // 'replace' option is passed. You are responsible for properly URL-encoding
+ // the fragment in advance.
+ //
+ // The options object can contain `trigger: true` if you wish to have the
+ // route callback be fired (not usually desirable), or `replace: true`, if
+ // you wish to modify the current URL without adding an entry to the history.
+ navigate: function(fragment, options) {
+ if (!History.started) return false;
+ if (!options || options === true) options = {trigger: !!options};
+
+ var url = this.root + (fragment = this.getFragment(fragment || ''));
+
+ // Strip the fragment of the query and hash for matching.
+ fragment = fragment.replace(pathStripper, '');
+
+ if (this.fragment === fragment) return;
+ this.fragment = fragment;
+
+ // Don't include a trailing slash on the root.
+ if (fragment === '' && url !== '/') url = url.slice(0, -1);
+
+ // If pushState is available, we use it to set the fragment as a real URL.
+ if (this._hasPushState) {
+ this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
+
+ // If hash changes haven't been explicitly disabled, update the hash
+ // fragment to store history.
+ } else if (this._wantsHashChange) {
+ this._updateHash(this.location, fragment, options.replace);
+ if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+ // Opening and closing the iframe tricks IE7 and earlier to push a
+ // history entry on hash-tag change. When replace is true, we don't
+ // want this.
+ if(!options.replace) this.iframe.document.open().close();
+ this._updateHash(this.iframe.location, fragment, options.replace);
+ }
+
+ // If you've told us that you explicitly don't want fallback hashchange-
+ // based history, then `navigate` becomes a page refresh.
+ } else {
+ return this.location.assign(url);
+ }
+ if (options.trigger) return this.loadUrl(fragment);
+ },
+
+ // Update the hash location, either replacing the current entry, or adding
+ // a new one to the browser history.
+ _updateHash: function(location, fragment, replace) {
+ if (replace) {
+ var href = location.href.replace(/(javascript:|#).*$/, '');
+ location.replace(href + '#' + fragment);
+ } else {
+ // Some browsers require that `hash` contains a leading #.
+ location.hash = '#' + fragment;
+ }
+ }
+
+ });
+
+ // Create the default Backbone.history.
+ Backbone.history = new History;
+
+ // Helpers
+ // -------
+
+ // Helper function to correctly set up the prototype chain, for subclasses.
+ // Similar to `goog.inherits`, but uses a hash of prototype properties and
+ // class properties to be extended.
+ var extend = function(protoProps, staticProps) {
+ var parent = this;
+ var child;
+
+ // The constructor function for the new subclass is either defined by you
+ // (the "constructor" property in your `extend` definition), or defaulted
+ // by us to simply call the parent's constructor.
+ if (protoProps && _.has(protoProps, 'constructor')) {
+ child = protoProps.constructor;
+ } else {
+ child = function(){ return parent.apply(this, arguments); };
+ }
+
+ // Add static properties to the constructor function, if supplied.
+ _.extend(child, parent, staticProps);
+
+ // Set the prototype chain to inherit from `parent`, without calling
+ // `parent`'s constructor function.
+ var Surrogate = function(){ this.constructor = child; };
+ Surrogate.prototype = parent.prototype;
+ child.prototype = new Surrogate;
+
+ // Add prototype properties (instance properties) to the subclass,
+ // if supplied.
+ if (protoProps) _.extend(child.prototype, protoProps);
+
+ // Set a convenience property in case the parent's prototype is needed
+ // later.
+ child.__super__ = parent.prototype;
+
+ return child;
+ };
+
+ // Set up inheritance for the model, collection, router, view and history.
+ Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
+
+ // Throw an error when a URL is needed, and none is supplied.
+ var urlError = function() {
+ throw new Error('A "url" property or function must be specified');
+ };
+
+ // Wrap an optional error callback with a fallback error event.
+ var wrapError = function(model, options) {
+ var error = options.error;
+ options.error = function(resp) {
+ if (error) error(model, resp, options);
+ model.trigger('error', model, resp, options);
+ };
+ };
+
+}).call(this);
\ No newline at end of file
=== added directory 'web_unleashed/static/lib/jquery-addons'
=== added file 'web_unleashed/static/lib/jquery-addons/jquery.font_size.js'
--- web_unleashed/static/lib/jquery-addons/jquery.font_size.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/jquery-addons/jquery.font_size.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,11 @@
+(function(jQuery){
+
+ /*
+ * get the font size value
+ */
+ jQuery.fn.fontSize = function() {
+ return parseInt(this.css('fontSize').replace('px', ''));
+ };
+
+
+})($ || jQuery)
=== added file 'web_unleashed/static/lib/jquery-addons/jquery.form_reset.js'
--- web_unleashed/static/lib/jquery-addons/jquery.form_reset.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/jquery-addons/jquery.form_reset.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,13 @@
+(function(jQuery){
+
+ /*
+ * reset from values.
+ */
+ jQuery.fn.reset = function() {
+ this.find('input,textarea,select').each(function(index, el){
+ $(el).val('');
+ });
+ };
+
+
+})($ || jQuery)
=== added file 'web_unleashed/static/lib/jquery-addons/jquery.serialize_object.js'
--- web_unleashed/static/lib/jquery-addons/jquery.serialize_object.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/jquery-addons/jquery.serialize_object.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,17 @@
+(function(jQuery){
+
+ /*
+ * serialize a form into an Object.
+ */
+ $.fn.serializeObject = function(){
+ var data = this.serializeArray(),
+ obj = {}, i;
+
+ for(i=0 ; i < data.length ; i++){
+ obj[data[i]['name']] = $.isNumeric(data[i]['value']) ? parseInt(data[i]['value']) : data[i]['value'];
+ }
+
+ return obj;
+ };
+
+})($ || jQuery)
\ No newline at end of file
=== added file 'web_unleashed/static/lib/jquery-addons/jquery.when_all.js'
--- web_unleashed/static/lib/jquery-addons/jquery.when_all.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/jquery-addons/jquery.when_all.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,56 @@
+(function(jQuery){
+
+ /*
+ * add a helper for $.Deferred, to keep waiting until all deferrer are executed before firing the global deferrer, keep info of each deferrer.
+ */
+ jQuery.whenAll = function( firstParam ) {
+ var args = $.makeArray(arguments),
+ i = 0,
+ length = args.length,
+ pValues = new Array( length ),
+ count = length,
+ pCount = length,
+ deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
+ firstParam :
+ jQuery.Deferred(),
+ promise = deferred.promise(),
+ state = 'resolved';
+
+ function alwaysFunc( i ) {
+ return function( value ) {
+ args[ i ] = arguments.length > 1 ? $.makeArray(arguments) : value;
+ state = this.state() === "rejected" ? "rejected" : state;
+ if ( !( --count ) ) {
+ var method = (state === "rejected"? "reject": "resolve") + "With";
+ deferred[method]( deferred, args );
+ }
+ };
+ }
+
+ function progressFunc( i ) {
+ return function( value ) {
+ pValues[ i ] = arguments.length > 1 ? $.makeArray(arguments) : value;
+ deferred.notifyWith( promise, pValues );
+ };
+ }
+
+ if ( length > 1 ) {
+ for ( ; i < length; i++ ) {
+ if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
+ args[ i ].promise().always( alwaysFunc(i))
+ .progress(progressFunc(i));
+ } else {
+ --count;
+ }
+ }
+ if ( !count ) {
+ deferred.resolveWith( deferred, args );
+ }
+ } else if ( deferred !== firstParam ) {
+ deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
+ }
+ return promise;
+ };
+
+
+})($ || jQuery)
=== added directory 'web_unleashed/static/lib/marionette'
=== added file 'web_unleashed/static/lib/marionette/marionette.js'
--- web_unleashed/static/lib/marionette/marionette.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/marionette/marionette.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,2363 @@
+// MarionetteJS (Backbone.Marionette)
+// ----------------------------------
+// v1.1.0
+//
+// Copyright (c)2013 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+//
+// http://marionettejs.com
+
+
+
+/*!
+ * Includes BabySitter
+ * https://github.com/marionettejs/backbone.babysitter/
+ *
+ * Includes Wreqr
+ * https://github.com/marionettejs/backbone.wreqr/
+ */
+
+// Backbone.BabySitter
+// -------------------
+// v0.0.6
+//
+// Copyright (c)2013 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+//
+// http://github.com/babysitterjs/backbone.babysitter
+
+// Backbone.ChildViewContainer
+// ---------------------------
+//
+// Provide a container to store, retrieve and
+// shut down child views.
+
+Backbone.ChildViewContainer = (function(Backbone, _){
+
+ // Container Constructor
+ // ---------------------
+
+ var Container = function(views){
+ this._views = {};
+ this._indexByModel = {};
+ this._indexByCustom = {};
+ this._updateLength();
+
+ _.each(views, this.add, this);
+ };
+
+ // Container Methods
+ // -----------------
+
+ _.extend(Container.prototype, {
+
+ // Add a view to this container. Stores the view
+ // by `cid` and makes it searchable by the model
+ // cid (and model itself). Optionally specify
+ // a custom key to store an retrieve the view.
+ add: function(view, customIndex){
+ var viewCid = view.cid;
+
+ // store the view
+ this._views[viewCid] = view;
+
+ // index it by model
+ if (view.model){
+ this._indexByModel[view.model.cid] = viewCid;
+ }
+
+ // index by custom
+ if (customIndex){
+ this._indexByCustom[customIndex] = viewCid;
+ }
+
+ this._updateLength();
+ },
+
+ // Find a view by the model that was attached to
+ // it. Uses the model's `cid` to find it.
+ findByModel: function(model){
+ return this.findByModelCid(model.cid);
+ },
+
+ // Find a view by the `cid` of the model that was attached to
+ // it. Uses the model's `cid` to find the view `cid` and
+ // retrieve the view using it.
+ findByModelCid: function(modelCid){
+ var viewCid = this._indexByModel[modelCid];
+ return this.findByCid(viewCid);
+ },
+
+ // Find a view by a custom indexer.
+ findByCustom: function(index){
+ var viewCid = this._indexByCustom[index];
+ return this.findByCid(viewCid);
+ },
+
+ // Find by index. This is not guaranteed to be a
+ // stable index.
+ findByIndex: function(index){
+ return _.values(this._views)[index];
+ },
+
+ // retrieve a view by it's `cid` directly
+ findByCid: function(cid){
+ return this._views[cid];
+ },
+
+ // Remove a view
+ remove: function(view){
+ var viewCid = view.cid;
+
+ // delete model index
+ if (view.model){
+ delete this._indexByModel[view.model.cid];
+ }
+
+ // delete custom index
+ _.any(this._indexByCustom, function(cid, key) {
+ if (cid === viewCid) {
+ delete this._indexByCustom[key];
+ return true;
+ }
+ }, this);
+
+ // remove the view from the container
+ delete this._views[viewCid];
+
+ // update the length
+ this._updateLength();
+ },
+
+ // Call a method on every view in the container,
+ // passing parameters to the call method one at a
+ // time, like `function.call`.
+ call: function(method){
+ this.apply(method, _.tail(arguments));
+ },
+
+ // Apply a method on every view in the container,
+ // passing parameters to the call method one at a
+ // time, like `function.apply`.
+ apply: function(method, args){
+ _.each(this._views, function(view){
+ if (_.isFunction(view[method])){
+ view[method].apply(view, args || []);
+ }
+ });
+ },
+
+ // Update the `.length` attribute on this container
+ _updateLength: function(){
+ this.length = _.size(this._views);
+ }
+ });
+
+ // Borrowing this code from Backbone.Collection:
+ // http://backbonejs.org/docs/backbone.html#section-106
+ //
+ // Mix in methods from Underscore, for iteration, and other
+ // collection related features.
+ var methods = ['forEach', 'each', 'map', 'find', 'detect', 'filter',
+ 'select', 'reject', 'every', 'all', 'some', 'any', 'include',
+ 'contains', 'invoke', 'toArray', 'first', 'initial', 'rest',
+ 'last', 'without', 'isEmpty', 'pluck'];
+
+ _.each(methods, function(method) {
+ Container.prototype[method] = function() {
+ var views = _.values(this._views);
+ var args = [views].concat(_.toArray(arguments));
+ return _[method].apply(_, args);
+ };
+ });
+
+ // return the public API
+ return Container;
+})(Backbone, _);
+
+// Backbone.Wreqr (Backbone.Marionette)
+// ----------------------------------
+// v0.2.0
+//
+// Copyright (c)2013 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+//
+// http://github.com/marionettejs/backbone.wreqr
+
+
+Backbone.Wreqr = (function(Backbone, Marionette, _){
+ "use strict";
+ var Wreqr = {};
+
+ // Handlers
+// --------
+// A registry of functions to call, given a name
+
+Wreqr.Handlers = (function(Backbone, _){
+ "use strict";
+
+ // Constructor
+ // -----------
+
+ var Handlers = function(options){
+ this.options = options;
+ this._wreqrHandlers = {};
+
+ if (_.isFunction(this.initialize)){
+ this.initialize(options);
+ }
+ };
+
+ Handlers.extend = Backbone.Model.extend;
+
+ // Instance Members
+ // ----------------
+
+ _.extend(Handlers.prototype, Backbone.Events, {
+
+ // Add multiple handlers using an object literal configuration
+ setHandlers: function(handlers){
+ _.each(handlers, function(handler, name){
+ var context = null;
+
+ if (_.isObject(handler) && !_.isFunction(handler)){
+ context = handler.context;
+ handler = handler.callback;
+ }
+
+ this.setHandler(name, handler, context);
+ }, this);
+ },
+
+ // Add a handler for the given name, with an
+ // optional context to run the handler within
+ setHandler: function(name, handler, context){
+ var config = {
+ callback: handler,
+ context: context
+ };
+
+ this._wreqrHandlers[name] = config;
+
+ this.trigger("handler:add", name, handler, context);
+ },
+
+ // Determine whether or not a handler is registered
+ hasHandler: function(name){
+ return !! this._wreqrHandlers[name];
+ },
+
+ // Get the currently registered handler for
+ // the specified name. Throws an exception if
+ // no handler is found.
+ getHandler: function(name){
+ var config = this._wreqrHandlers[name];
+
+ if (!config){
+ throw new Error("Handler not found for '" + name + "'");
+ }
+
+ return function(){
+ var args = Array.prototype.slice.apply(arguments);
+ return config.callback.apply(config.context, args);
+ };
+ },
+
+ // Remove a handler for the specified name
+ removeHandler: function(name){
+ delete this._wreqrHandlers[name];
+ },
+
+ // Remove all handlers from this registry
+ removeAllHandlers: function(){
+ this._wreqrHandlers = {};
+ }
+ });
+
+ return Handlers;
+})(Backbone, _);
+
+ // Wreqr.CommandStorage
+// --------------------
+//
+// Store and retrieve commands for execution.
+Wreqr.CommandStorage = (function(){
+ "use strict";
+
+ // Constructor function
+ var CommandStorage = function(options){
+ this.options = options;
+ this._commands = {};
+
+ if (_.isFunction(this.initialize)){
+ this.initialize(options);
+ }
+ };
+
+ // Instance methods
+ _.extend(CommandStorage.prototype, Backbone.Events, {
+
+ // Get an object literal by command name, that contains
+ // the `commandName` and the `instances` of all commands
+ // represented as an array of arguments to process
+ getCommands: function(commandName){
+ var commands = this._commands[commandName];
+
+ // we don't have it, so add it
+ if (!commands){
+
+ // build the configuration
+ commands = {
+ command: commandName,
+ instances: []
+ };
+
+ // store it
+ this._commands[commandName] = commands;
+ }
+
+ return commands;
+ },
+
+ // Add a command by name, to the storage and store the
+ // args for the command
+ addCommand: function(commandName, args){
+ var command = this.getCommands(commandName);
+ command.instances.push(args);
+ },
+
+ // Clear all commands for the given `commandName`
+ clearCommands: function(commandName){
+ var command = this.getCommands(commandName);
+ command.instances = [];
+ }
+ });
+
+ return CommandStorage;
+})();
+
+ // Wreqr.Commands
+// --------------
+//
+// A simple command pattern implementation. Register a command
+// handler and execute it.
+Wreqr.Commands = (function(Wreqr){
+ "use strict";
+
+ return Wreqr.Handlers.extend({
+ // default storage type
+ storageType: Wreqr.CommandStorage,
+
+ constructor: function(options){
+ this.options = options || {};
+
+ this._initializeStorage(this.options);
+ this.on("handler:add", this._executeCommands, this);
+
+ var args = Array.prototype.slice.call(arguments);
+ Wreqr.Handlers.prototype.constructor.apply(this, args);
+ },
+
+ // Execute a named command with the supplied args
+ execute: function(name, args){
+ name = arguments[0];
+ args = Array.prototype.slice.call(arguments, 1);
+
+ if (this.hasHandler(name)){
+ this.getHandler(name).apply(this, args);
+ } else {
+ this.storage.addCommand(name, args);
+ }
+
+ },
+
+ // Internal method to handle bulk execution of stored commands
+ _executeCommands: function(name, handler, context){
+ var command = this.storage.getCommands(name);
+
+ // loop through and execute all the stored command instances
+ _.each(command.instances, function(args){
+ handler.apply(context, args);
+ });
+
+ this.storage.clearCommands(name);
+ },
+
+ // Internal method to initialize storage either from the type's
+ // `storageType` or the instance `options.storageType`.
+ _initializeStorage: function(options){
+ var storage;
+
+ var StorageType = options.storageType || this.storageType;
+ if (_.isFunction(StorageType)){
+ storage = new StorageType();
+ } else {
+ storage = StorageType;
+ }
+
+ this.storage = storage;
+ }
+ });
+
+})(Wreqr);
+
+ // Wreqr.RequestResponse
+// ---------------------
+//
+// A simple request/response implementation. Register a
+// request handler, and return a response from it
+Wreqr.RequestResponse = (function(Wreqr){
+ "use strict";
+
+ return Wreqr.Handlers.extend({
+ request: function(){
+ var name = arguments[0];
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ return this.getHandler(name).apply(this, args);
+ }
+ });
+
+})(Wreqr);
+
+ // Event Aggregator
+// ----------------
+// A pub-sub object that can be used to decouple various parts
+// of an application through event-driven architecture.
+
+Wreqr.EventAggregator = (function(Backbone, _){
+ "use strict";
+ var EA = function(){};
+
+ // Copy the `extend` function used by Backbone's classes
+ EA.extend = Backbone.Model.extend;
+
+ // Copy the basic Backbone.Events on to the event aggregator
+ _.extend(EA.prototype, Backbone.Events);
+
+ return EA;
+})(Backbone, _);
+
+
+ return Wreqr;
+})(Backbone, Backbone.Marionette, _);
+
+var Marionette = (function(global, Backbone, _){
+ "use strict";
+
+ // Define and export the Marionette namespace
+ var Marionette = {};
+ Backbone.Marionette = Marionette;
+
+ // Get the DOM manipulator for later use
+ Marionette.$ = Backbone.$;
+
+// Helpers
+// -------
+
+// For slicing `arguments` in functions
+var protoSlice = Array.prototype.slice;
+function slice(args) {
+ return protoSlice.call(args);
+}
+
+function throwError(message, name) {
+ var error = new Error(message);
+ error.name = name || 'Error';
+ throw error;
+}
+
+// Marionette.extend
+// -----------------
+
+// Borrow the Backbone `extend` method so we can use it as needed
+Marionette.extend = Backbone.Model.extend;
+
+// Marionette.getOption
+// --------------------
+
+// Retrieve an object, function or other value from a target
+// object or its `options`, with `options` taking precedence.
+Marionette.getOption = function(target, optionName){
+ if (!target || !optionName){ return; }
+ var value;
+
+ if (target.options && (optionName in target.options) && (target.options[optionName] !== undefined)){
+ value = target.options[optionName];
+ } else {
+ value = target[optionName];
+ }
+
+ return value;
+};
+
+// Trigger an event and/or a corresponding method name. Examples:
+//
+// `this.triggerMethod("foo")` will trigger the "foo" event and
+// call the "onFoo" method.
+//
+// `this.triggerMethod("foo:bar") will trigger the "foo:bar" event and
+// call the "onFooBar" method.
+Marionette.triggerMethod = (function(){
+
+ // split the event name on the :
+ var splitter = /(^|:)(\w)/gi;
+
+ // take the event section ("section1:section2:section3")
+ // and turn it in to uppercase name
+ function getEventName(match, prefix, eventName) {
+ return eventName.toUpperCase();
+ }
+
+ // actual triggerMethod name
+ var triggerMethod = function(event) {
+ // get the method name from the event name
+ var methodName = 'on' + event.replace(splitter, getEventName);
+ var method = this[methodName];
+
+ // trigger the event, if a trigger method exists
+ if(_.isFunction(this.trigger)) {
+ this.trigger.apply(this, arguments);
+ }
+
+ // call the onMethodName if it exists
+ if (_.isFunction(method)) {
+ // pass all arguments, except the event name
+ return method.apply(this, _.tail(arguments));
+ }
+ };
+
+ return triggerMethod;
+})();
+
+// DOMRefresh
+// ----------
+//
+// Monitor a view's state, and after it has been rendered and shown
+// in the DOM, trigger a "dom:refresh" event every time it is
+// re-rendered.
+
+Marionette.MonitorDOMRefresh = (function(){
+ // track when the view has been shown in the DOM,
+ // using a Marionette.Region (or by other means of triggering "show")
+ function handleShow(view){
+ view._isShown = true;
+ triggerDOMRefresh(view);
+ }
+
+ // track when the view has been rendered
+ function handleRender(view){
+ view._isRendered = true;
+ triggerDOMRefresh(view);
+ }
+
+ // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
+ function triggerDOMRefresh(view){
+ if (view._isShown && view._isRendered){
+ if (_.isFunction(view.triggerMethod)){
+ view.triggerMethod("dom:refresh");
+ }
+ }
+ }
+
+ // Export public API
+ return function(view){
+ view.listenTo(view, "show", function(){
+ handleShow(view);
+ });
+
+ view.listenTo(view, "render", function(){
+ handleRender(view);
+ });
+ };
+})();
+
+
+// Marionette.bindEntityEvents & unbindEntityEvents
+// ---------------------------
+//
+// These methods are used to bind/unbind a backbone "entity" (collection/model)
+// to methods on a target object.
+//
+// The first parameter, `target`, must have a `listenTo` method from the
+// EventBinder object.
+//
+// The second parameter is the entity (Backbone.Model or Backbone.Collection)
+// to bind the events from.
+//
+// The third parameter is a hash of { "event:name": "eventHandler" }
+// configuration. Multiple handlers can be separated by a space. A
+// function can be supplied instead of a string handler name.
+
+(function(Marionette){
+ "use strict";
+
+ // Bind the event to handlers specified as a string of
+ // handler names on the target object
+ function bindFromStrings(target, entity, evt, methods){
+ var methodNames = methods.split(/\s+/);
+
+ _.each(methodNames,function(methodName) {
+
+ var method = target[methodName];
+ if(!method) {
+ throwError("Method '"+ methodName +"' was configured as an event handler, but does not exist.");
+ }
+
+ target.listenTo(entity, evt, method, target);
+ });
+ }
+
+ // Bind the event to a supplied callback function
+ function bindToFunction(target, entity, evt, method){
+ target.listenTo(entity, evt, method, target);
+ }
+
+ // Bind the event to handlers specified as a string of
+ // handler names on the target object
+ function unbindFromStrings(target, entity, evt, methods){
+ var methodNames = methods.split(/\s+/);
+
+ _.each(methodNames,function(methodName) {
+ var method = target[methodName];
+ target.stopListening(entity, evt, method, target);
+ });
+ }
+
+ // Bind the event to a supplied callback function
+ function unbindToFunction(target, entity, evt, method){
+ target.stopListening(entity, evt, method, target);
+ }
+
+
+ // generic looping function
+ function iterateEvents(target, entity, bindings, functionCallback, stringCallback){
+ if (!entity || !bindings) { return; }
+
+ // allow the bindings to be a function
+ if (_.isFunction(bindings)){
+ bindings = bindings.call(target);
+ }
+
+ // iterate the bindings and bind them
+ _.each(bindings, function(methods, evt){
+
+ // allow for a function as the handler,
+ // or a list of event names as a string
+ if (_.isFunction(methods)){
+ functionCallback(target, entity, evt, methods);
+ } else {
+ stringCallback(target, entity, evt, methods);
+ }
+
+ });
+ }
+
+ // Export Public API
+ Marionette.bindEntityEvents = function(target, entity, bindings){
+ iterateEvents(target, entity, bindings, bindToFunction, bindFromStrings);
+ };
+
+ Marionette.unbindEntityEvents = function(target, entity, bindings){
+ iterateEvents(target, entity, bindings, unbindToFunction, unbindFromStrings);
+ };
+
+})(Marionette);
+
+
+// Callbacks
+// ---------
+
+// A simple way of managing a collection of callbacks
+// and executing them at a later point in time, using jQuery's
+// `Deferred` object.
+Marionette.Callbacks = function(){
+ this._deferred = Marionette.$.Deferred();
+ this._callbacks = [];
+};
+
+_.extend(Marionette.Callbacks.prototype, {
+
+ // Add a callback to be executed. Callbacks added here are
+ // guaranteed to execute, even if they are added after the
+ // `run` method is called.
+ add: function(callback, contextOverride){
+ this._callbacks.push({cb: callback, ctx: contextOverride});
+
+ this._deferred.done(function(context, options){
+ if (contextOverride){ context = contextOverride; }
+ callback.call(context, options);
+ });
+ },
+
+ // Run all registered callbacks with the context specified.
+ // Additional callbacks can be added after this has been run
+ // and they will still be executed.
+ run: function(options, context){
+ this._deferred.resolve(context, options);
+ },
+
+ // Resets the list of callbacks to be run, allowing the same list
+ // to be run multiple times - whenever the `run` method is called.
+ reset: function(){
+ var callbacks = this._callbacks;
+ this._deferred = Marionette.$.Deferred();
+ this._callbacks = [];
+
+ _.each(callbacks, function(cb){
+ this.add(cb.cb, cb.ctx);
+ }, this);
+ }
+});
+
+
+// Marionette Controller
+// ---------------------
+//
+// A multi-purpose object to use as a controller for
+// modules and routers, and as a mediator for workflow
+// and coordination of other objects, views, and more.
+Marionette.Controller = function(options){
+ this.triggerMethod = Marionette.triggerMethod;
+ this.options = options || {};
+
+ if (_.isFunction(this.initialize)){
+ this.initialize(this.options);
+ }
+};
+
+Marionette.Controller.extend = Marionette.extend;
+
+// Controller Methods
+// --------------
+
+// Ensure it can trigger events with Backbone.Events
+_.extend(Marionette.Controller.prototype, Backbone.Events, {
+ close: function(){
+ this.stopListening();
+ this.triggerMethod("close");
+ this.unbind();
+ }
+});
+
+// Region
+// ------
+//
+// Manage the visual regions of your composite application. See
+// http://lostechies.com/derickbailey/2011/12/12/composite-js-apps-regions-and-region-managers/
+
+Marionette.Region = function(options){
+ this.options = options || {};
+
+ this.el = Marionette.getOption(this, "el");
+
+ if (!this.el){
+ var err = new Error("An 'el' must be specified for a region.");
+ err.name = "NoElError";
+ throw err;
+ }
+
+ if (this.initialize){
+ var args = Array.prototype.slice.apply(arguments);
+ this.initialize.apply(this, args);
+ }
+};
+
+
+// Region Type methods
+// -------------------
+
+_.extend(Marionette.Region, {
+
+ // Build an instance of a region by passing in a configuration object
+ // and a default region type to use if none is specified in the config.
+ //
+ // The config object should either be a string as a jQuery DOM selector,
+ // a Region type directly, or an object literal that specifies both
+ // a selector and regionType:
+ //
+ // ```js
+ // {
+ // selector: "#foo",
+ // regionType: MyCustomRegion
+ // }
+ // ```
+ //
+ buildRegion: function(regionConfig, defaultRegionType){
+
+ var regionIsString = (typeof regionConfig === "string");
+ var regionSelectorIsString = (typeof regionConfig.selector === "string");
+ var regionTypeIsUndefined = (typeof regionConfig.regionType === "undefined");
+ var regionIsType = (typeof regionConfig === "function");
+
+ if (!regionIsType && !regionIsString && !regionSelectorIsString) {
+ throw new Error("Region must be specified as a Region type, a selector string or an object with selector property");
+ }
+
+ var selector, RegionType;
+
+ // get the selector for the region
+
+ if (regionIsString) {
+ selector = regionConfig;
+ }
+
+ if (regionConfig.selector) {
+ selector = regionConfig.selector;
+ }
+
+ // get the type for the region
+
+ if (regionIsType){
+ RegionType = regionConfig;
+ }
+
+ if (!regionIsType && regionTypeIsUndefined) {
+ RegionType = defaultRegionType;
+ }
+
+ if (regionConfig.regionType) {
+ RegionType = regionConfig.regionType;
+ }
+
+ // build the region instance
+ var region = new RegionType({
+ el: selector
+ });
+
+ // override the `getEl` function if we have a parentEl
+ // this must be overridden to ensure the selector is found
+ // on the first use of the region. if we try to assign the
+ // region's `el` to `parentEl.find(selector)` in the object
+ // literal to build the region, the element will not be
+ // guaranteed to be in the DOM already, and will cause problems
+ if (regionConfig.parentEl){
+
+ region.getEl = function(selector) {
+ var parentEl = regionConfig.parentEl;
+ if (_.isFunction(parentEl)){
+ parentEl = parentEl();
+ }
+ return parentEl.find(selector);
+ };
+ }
+
+ return region;
+ }
+
+});
+
+// Region Instance Methods
+// -----------------------
+
+_.extend(Marionette.Region.prototype, Backbone.Events, {
+
+ // Displays a backbone view instance inside of the region.
+ // Handles calling the `render` method for you. Reads content
+ // directly from the `el` attribute. Also calls an optional
+ // `onShow` and `close` method on your view, just after showing
+ // or just before closing the view, respectively.
+ show: function(view){
+
+ this.ensureEl();
+
+ var isViewClosed = view.isClosed || _.isUndefined(view.$el);
+
+ var isDifferentView = view !== this.currentView;
+
+ if (isDifferentView) {
+ this.close();
+ }
+
+ view.render();
+
+ if (isDifferentView || isViewClosed) {
+ this.open(view);
+ }
+
+ this.currentView = view;
+
+ Marionette.triggerMethod.call(this, "show", view);
+ Marionette.triggerMethod.call(view, "show");
+ },
+
+ ensureEl: function(){
+ if (!this.$el || this.$el.length === 0){
+ this.$el = this.getEl(this.el);
+ }
+ },
+
+ // Override this method to change how the region finds the
+ // DOM element that it manages. Return a jQuery selector object.
+ getEl: function(selector){
+ return Marionette.$(selector);
+ },
+
+ // Override this method to change how the new view is
+ // appended to the `$el` that the region is managing
+ open: function(view){
+ this.$el.empty().append(view.el);
+ },
+
+ // Close the current view, if there is one. If there is no
+ // current view, it does nothing and returns immediately.
+ close: function(){
+ var view = this.currentView;
+ if (!view || view.isClosed){ return; }
+
+ // call 'close' or 'remove', depending on which is found
+ if (view.close) { view.close(); }
+ else if (view.remove) { view.remove(); }
+
+ Marionette.triggerMethod.call(this, "close");
+
+ delete this.currentView;
+ },
+
+ // Attach an existing view to the region. This
+ // will not call `render` or `onShow` for the new view,
+ // and will not replace the current HTML for the `el`
+ // of the region.
+ attachView: function(view){
+ this.currentView = view;
+ },
+
+ // Reset the region by closing any existing view and
+ // clearing out the cached `$el`. The next time a view
+ // is shown via this region, the region will re-query the
+ // DOM for the region's `el`.
+ reset: function(){
+ this.close();
+ delete this.$el;
+ }
+});
+
+// Copy the `extend` function used by Backbone's classes
+Marionette.Region.extend = Marionette.extend;
+
+// Marionette.RegionManager
+// ------------------------
+//
+// Manage one or more related `Marionette.Region` objects.
+Marionette.RegionManager = (function(Marionette){
+
+ var RegionManager = Marionette.Controller.extend({
+ constructor: function(options){
+ this._regions = {};
+ Marionette.Controller.prototype.constructor.call(this, options);
+ },
+
+ // Add multiple regions using an object literal, where
+ // each key becomes the region name, and each value is
+ // the region definition.
+ addRegions: function(regionDefinitions, defaults){
+ var regions = {};
+
+ _.each(regionDefinitions, function(definition, name){
+ if (typeof definition === "string"){
+ definition = { selector: definition };
+ }
+
+ if (definition.selector){
+ definition = _.defaults({}, definition, defaults);
+ }
+
+ var region = this.addRegion(name, definition);
+ regions[name] = region;
+ }, this);
+
+ return regions;
+ },
+
+ // Add an individual region to the region manager,
+ // and return the region instance
+ addRegion: function(name, definition){
+ var region;
+
+ var isObject = _.isObject(definition);
+ var isString = _.isString(definition);
+ var hasSelector = !!definition.selector;
+
+ if (isString || (isObject && hasSelector)){
+ region = Marionette.Region.buildRegion(definition, Marionette.Region);
+ } else if (_.isFunction(definition)){
+ region = Marionette.Region.buildRegion(definition, Marionette.Region);
+ } else {
+ region = definition;
+ }
+
+ this._store(name, region);
+ this.triggerMethod("region:add", name, region);
+ return region;
+ },
+
+ // Get a region by name
+ get: function(name){
+ return this._regions[name];
+ },
+
+ // Remove a region by name
+ removeRegion: function(name){
+ var region = this._regions[name];
+ this._remove(name, region);
+ },
+
+ // Close all regions in the region manager, and
+ // remove them
+ removeRegions: function(){
+ _.each(this._regions, function(region, name){
+ this._remove(name, region);
+ }, this);
+ },
+
+ // Close all regions in the region manager, but
+ // leave them attached
+ closeRegions: function(){
+ _.each(this._regions, function(region, name){
+ region.close();
+ }, this);
+ },
+
+ // Close all regions and shut down the region
+ // manager entirely
+ close: function(){
+ this.removeRegions();
+ var args = Array.prototype.slice.call(arguments);
+ Marionette.Controller.prototype.close.apply(this, args);
+ },
+
+ // internal method to store regions
+ _store: function(name, region){
+ this._regions[name] = region;
+ this._setLength();
+ },
+
+ // internal method to remove a region
+ _remove: function(name, region){
+ region.close();
+ delete this._regions[name];
+ this._setLength();
+ this.triggerMethod("region:remove", name, region);
+ },
+
+ // set the number of regions current held
+ _setLength: function(){
+ this.length = _.size(this._regions);
+ }
+
+ });
+
+ // Borrowing this code from Backbone.Collection:
+ // http://backbonejs.org/docs/backbone.html#section-106
+ //
+ // Mix in methods from Underscore, for iteration, and other
+ // collection related features.
+ var methods = ['forEach', 'each', 'map', 'find', 'detect', 'filter',
+ 'select', 'reject', 'every', 'all', 'some', 'any', 'include',
+ 'contains', 'invoke', 'toArray', 'first', 'initial', 'rest',
+ 'last', 'without', 'isEmpty', 'pluck'];
+
+ _.each(methods, function(method) {
+ RegionManager.prototype[method] = function() {
+ var regions = _.values(this._regions);
+ var args = [regions].concat(_.toArray(arguments));
+ return _[method].apply(_, args);
+ };
+ });
+
+ return RegionManager;
+})(Marionette);
+
+
+// Template Cache
+// --------------
+
+// Manage templates stored in `<script>` blocks,
+// caching them for faster access.
+Marionette.TemplateCache = function(templateId){
+ this.templateId = templateId;
+};
+
+// TemplateCache object-level methods. Manage the template
+// caches from these method calls instead of creating
+// your own TemplateCache instances
+_.extend(Marionette.TemplateCache, {
+ templateCaches: {},
+
+ // Get the specified template by id. Either
+ // retrieves the cached version, or loads it
+ // from the DOM.
+ get: function(templateId){
+ var cachedTemplate = this.templateCaches[templateId];
+
+ if (!cachedTemplate){
+ cachedTemplate = new Marionette.TemplateCache(templateId);
+ this.templateCaches[templateId] = cachedTemplate;
+ }
+
+ return cachedTemplate.load();
+ },
+
+ // Clear templates from the cache. If no arguments
+ // are specified, clears all templates:
+ // `clear()`
+ //
+ // If arguments are specified, clears each of the
+ // specified templates from the cache:
+ // `clear("#t1", "#t2", "...")`
+ clear: function(){
+ var i;
+ var args = slice(arguments);
+ var length = args.length;
+
+ if (length > 0){
+ for(i=0; i<length; i++){
+ delete this.templateCaches[args[i]];
+ }
+ } else {
+ this.templateCaches = {};
+ }
+ }
+});
+
+// TemplateCache instance methods, allowing each
+// template cache object to manage its own state
+// and know whether or not it has been loaded
+_.extend(Marionette.TemplateCache.prototype, {
+
+ // Internal method to load the template
+ load: function(){
+ // Guard clause to prevent loading this template more than once
+ if (this.compiledTemplate){
+ return this.compiledTemplate;
+ }
+
+ // Load the template and compile it
+ var template = this.loadTemplate(this.templateId);
+ this.compiledTemplate = this.compileTemplate(template);
+
+ return this.compiledTemplate;
+ },
+
+ // Load a template from the DOM, by default. Override
+ // this method to provide your own template retrieval
+ // For asynchronous loading with AMD/RequireJS, consider
+ // using a template-loader plugin as described here:
+ // https://github.com/marionettejs/backbone.marionette/wiki/Using-marionette-with-requirejs
+ loadTemplate: function(templateId){
+ var template = Marionette.$(templateId).html();
+
+ if (!template || template.length === 0){
+ throwError("Could not find template: '" + templateId + "'", "NoTemplateError");
+ }
+
+ return template;
+ },
+
+ // Pre-compile the template before caching it. Override
+ // this method if you do not need to pre-compile a template
+ // (JST / RequireJS for example) or if you want to change
+ // the template engine used (Handebars, etc).
+ compileTemplate: function(rawTemplate){
+ return _.template(rawTemplate);
+ }
+});
+
+
+// Renderer
+// --------
+
+// Render a template with data by passing in the template
+// selector and the data to render.
+Marionette.Renderer = {
+
+ // Render a template with data. The `template` parameter is
+ // passed to the `TemplateCache` object to retrieve the
+ // template function. Override this method to provide your own
+ // custom rendering and template handling for all of Marionette.
+ render: function(template, data){
+
+ if (!template) {
+ var error = new Error("Cannot render the template since it's false, null or undefined.");
+ error.name = "TemplateNotFoundError";
+ throw error;
+ }
+
+ var templateFunc;
+ if (typeof template === "function"){
+ templateFunc = template;
+ } else {
+ templateFunc = Marionette.TemplateCache.get(template);
+ }
+
+ return templateFunc(data);
+ }
+};
+
+
+
+// Marionette.View
+// ---------------
+
+// The core view type that other Marionette views extend from.
+Marionette.View = Backbone.View.extend({
+
+ constructor: function(){
+ _.bindAll(this, "render");
+
+ var args = Array.prototype.slice.apply(arguments);
+ Backbone.View.prototype.constructor.apply(this, args);
+
+ Marionette.MonitorDOMRefresh(this);
+ this.listenTo(this, "show", this.onShowCalled, this);
+ },
+
+ // import the "triggerMethod" to trigger events with corresponding
+ // methods if the method exists
+ triggerMethod: Marionette.triggerMethod,
+
+ // Get the template for this view
+ // instance. You can set a `template` attribute in the view
+ // definition or pass a `template: "whatever"` parameter in
+ // to the constructor options.
+ getTemplate: function(){
+ return Marionette.getOption(this, "template");
+ },
+
+ // Mix in template helper methods. Looks for a
+ // `templateHelpers` attribute, which can either be an
+ // object literal, or a function that returns an object
+ // literal. All methods and attributes from this object
+ // are copies to the object passed in.
+ mixinTemplateHelpers: function(target){
+ target = target || {};
+ var templateHelpers = Marionette.getOption(this, "templateHelpers");
+ if (_.isFunction(templateHelpers)){
+ templateHelpers = templateHelpers.call(this);
+ }
+ return _.extend(target, templateHelpers);
+ },
+
+ // Configure `triggers` to forward DOM events to view
+ // events. `triggers: {"click .foo": "do:foo"}`
+ configureTriggers: function(){
+ if (!this.triggers) { return; }
+
+ var triggerEvents = {};
+
+ // Allow `triggers` to be configured as a function
+ var triggers = _.result(this, "triggers");
+
+ // Configure the triggers, prevent default
+ // action and stop propagation of DOM events
+ _.each(triggers, function(value, key){
+
+ // build the event handler function for the DOM event
+ triggerEvents[key] = function(e){
+
+ // stop the event in its tracks
+ if (e && e.preventDefault){ e.preventDefault(); }
+ if (e && e.stopPropagation){ e.stopPropagation(); }
+
+ // build the args for the event
+ var args = {
+ view: this,
+ model: this.model,
+ collection: this.collection
+ };
+
+ // trigger the event
+ this.triggerMethod(value, args);
+ };
+
+ }, this);
+
+ return triggerEvents;
+ },
+
+ // Overriding Backbone.View's delegateEvents to handle
+ // the `triggers`, `modelEvents`, and `collectionEvents` configuration
+ delegateEvents: function(events){
+ this._delegateDOMEvents(events);
+ Marionette.bindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
+ Marionette.bindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
+ },
+
+ // internal method to delegate DOM events and triggers
+ _delegateDOMEvents: function(events){
+ events = events || this.events;
+ if (_.isFunction(events)){ events = events.call(this); }
+
+ var combinedEvents = {};
+ var triggers = this.configureTriggers();
+ _.extend(combinedEvents, events, triggers);
+
+ Backbone.View.prototype.delegateEvents.call(this, combinedEvents);
+ },
+
+ // Overriding Backbone.View's undelegateEvents to handle unbinding
+ // the `triggers`, `modelEvents`, and `collectionEvents` config
+ undelegateEvents: function(){
+ var args = Array.prototype.slice.call(arguments);
+ Backbone.View.prototype.undelegateEvents.apply(this, args);
+
+ Marionette.unbindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
+ Marionette.unbindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
+ },
+
+ // Internal method, handles the `show` event.
+ onShowCalled: function(){},
+
+ // Default `close` implementation, for removing a view from the
+ // DOM and unbinding it. Regions will call this method
+ // for you. You can specify an `onClose` method in your view to
+ // add custom code that is called after the view is closed.
+ close: function(){
+ if (this.isClosed) { return; }
+
+ // allow the close to be stopped by returning `false`
+ // from the `onBeforeClose` method
+ var shouldClose = this.triggerMethod("before:close");
+ if (shouldClose === false){
+ return;
+ }
+
+ // mark as closed before doing the actual close, to
+ // prevent infinite loops within "close" event handlers
+ // that are trying to close other views
+ this.isClosed = true;
+ this.triggerMethod("close");
+
+ // unbind UI elements
+ this.unbindUIElements();
+
+ // remove the view from the DOM
+ this.remove();
+ },
+
+ // This method binds the elements specified in the "ui" hash inside the view's code with
+ // the associated jQuery selectors.
+ bindUIElements: function(){
+ if (!this.ui) { return; }
+
+ // store the ui hash in _uiBindings so they can be reset later
+ // and so re-rendering the view will be able to find the bindings
+ if (!this._uiBindings){
+ this._uiBindings = this.ui;
+ }
+
+ // get the bindings result, as a function or otherwise
+ var bindings = _.result(this, "_uiBindings");
+
+ // empty the ui so we don't have anything to start with
+ this.ui = {};
+
+ // bind each of the selectors
+ _.each(_.keys(bindings), function(key) {
+ var selector = bindings[key];
+ this.ui[key] = this.$(selector);
+ }, this);
+ },
+
+ // This method unbinds the elements specified in the "ui" hash
+ unbindUIElements: function(){
+ if (!this.ui || !this._uiBindings){ return; }
+
+ // delete all of the existing ui bindings
+ _.each(this.ui, function($el, name){
+ delete this.ui[name];
+ }, this);
+
+ // reset the ui element to the original bindings configuration
+ this.ui = this._uiBindings;
+ delete this._uiBindings;
+ }
+});
+
+// Item View
+// ---------
+
+// A single item view implementation that contains code for rendering
+// with underscore.js templates, serializing the view's model or collection,
+// and calling several methods on extended views, such as `onRender`.
+Marionette.ItemView = Marionette.View.extend({
+
+ // Setting up the inheritance chain which allows changes to
+ // Marionette.View.prototype.constructor which allows overriding
+ constructor: function(){
+ Marionette.View.prototype.constructor.apply(this, slice(arguments));
+ },
+
+ // Serialize the model or collection for the view. If a model is
+ // found, `.toJSON()` is called. If a collection is found, `.toJSON()`
+ // is also called, but is used to populate an `items` array in the
+ // resulting data. If both are found, defaults to the model.
+ // You can override the `serializeData` method in your own view
+ // definition, to provide custom serialization for your view's data.
+ serializeData: function(){
+ var data = {};
+
+ if (this.model) {
+ data = this.model.toJSON();
+ }
+ else if (this.collection) {
+ data = { items: this.collection.toJSON() };
+ }
+
+ return data;
+ },
+
+ // Render the view, defaulting to underscore.js templates.
+ // You can override this in your view definition to provide
+ // a very specific rendering for your view. In general, though,
+ // you should override the `Marionette.Renderer` object to
+ // change how Marionette renders views.
+ render: function(){
+ this.isClosed = false;
+
+ this.triggerMethod("before:render", this);
+ this.triggerMethod("item:before:render", this);
+
+ var data = this.serializeData();
+ data = this.mixinTemplateHelpers(data);
+
+ var template = this.getTemplate();
+ var html = Marionette.Renderer.render(template, data);
+
+ this.$el.html(html);
+ this.bindUIElements();
+
+ this.triggerMethod("render", this);
+ this.triggerMethod("item:rendered", this);
+
+ return this;
+ },
+
+ // Override the default close event to add a few
+ // more events that are triggered.
+ close: function(){
+ if (this.isClosed){ return; }
+
+ this.triggerMethod('item:before:close');
+
+ Marionette.View.prototype.close.apply(this, slice(arguments));
+
+ this.triggerMethod('item:closed');
+ }
+});
+
+// Collection View
+// ---------------
+
+// A view that iterates over a Backbone.Collection
+// and renders an individual ItemView for each model.
+Marionette.CollectionView = Marionette.View.extend({
+ // used as the prefix for item view events
+ // that are forwarded through the collectionview
+ itemViewEventPrefix: "itemview",
+
+ // constructor
+ constructor: function(options){
+ this._initChildViewStorage();
+
+ Marionette.View.prototype.constructor.apply(this, slice(arguments));
+
+ this._initialEvents();
+ },
+
+ // Configured the initial events that the collection view
+ // binds to. Override this method to prevent the initial
+ // events, or to add your own initial events.
+ _initialEvents: function(){
+ if (this.collection){
+ this.listenTo(this.collection, "add", this.addChildView, this);
+ this.listenTo(this.collection, "remove", this.removeItemView, this);
+ this.listenTo(this.collection, "reset", this.render, this);
+ }
+ },
+
+ // Handle a child item added to the collection
+ addChildView: function(item, collection, options){
+ this.closeEmptyView();
+ var ItemView = this.getItemView(item);
+ var index = this.collection.indexOf(item);
+ this.addItemView(item, ItemView, index);
+ },
+
+ // Override from `Marionette.View` to guarantee the `onShow` method
+ // of child views is called.
+ onShowCalled: function(){
+ this.children.each(function(child){
+ Marionette.triggerMethod.call(child, "show");
+ });
+ },
+
+ // Internal method to trigger the before render callbacks
+ // and events
+ triggerBeforeRender: function(){
+ this.triggerMethod("before:render", this);
+ this.triggerMethod("collection:before:render", this);
+ },
+
+ // Internal method to trigger the rendered callbacks and
+ // events
+ triggerRendered: function(){
+ this.triggerMethod("render", this);
+ this.triggerMethod("collection:rendered", this);
+ },
+
+ // Render the collection of items. Override this method to
+ // provide your own implementation of a render function for
+ // the collection view.
+ render: function(){
+ this.isClosed = false;
+ this.triggerBeforeRender();
+ this._renderChildren();
+ this.triggerRendered();
+ return this;
+ },
+
+ // Internal method. Separated so that CompositeView can have
+ // more control over events being triggered, around the rendering
+ // process
+ _renderChildren: function(){
+ this.closeEmptyView();
+ this.closeChildren();
+
+ if (this.collection && this.collection.length > 0) {
+ this.showCollection();
+ } else {
+ this.showEmptyView();
+ }
+ },
+
+ // Internal method to loop through each item in the
+ // collection view and show it
+ showCollection: function(){
+ var ItemView;
+ this.collection.each(function(item, index){
+ ItemView = this.getItemView(item);
+ this.addItemView(item, ItemView, index);
+ }, this);
+ },
+
+ // Internal method to show an empty view in place of
+ // a collection of item views, when the collection is
+ // empty
+ showEmptyView: function(){
+ var EmptyView = Marionette.getOption(this, "emptyView");
+
+ if (EmptyView && !this._showingEmptyView){
+ this._showingEmptyView = true;
+ var model = new Backbone.Model();
+ this.addItemView(model, EmptyView, 0);
+ }
+ },
+
+ // Internal method to close an existing emptyView instance
+ // if one exists. Called when a collection view has been
+ // rendered empty, and then an item is added to the collection.
+ closeEmptyView: function(){
+ if (this._showingEmptyView){
+ this.closeChildren();
+ delete this._showingEmptyView;
+ }
+ },
+
+ // Retrieve the itemView type, either from `this.options.itemView`
+ // or from the `itemView` in the object definition. The "options"
+ // takes precedence.
+ getItemView: function(item){
+ var itemView = Marionette.getOption(this, "itemView");
+
+ if (!itemView){
+ throwError("An `itemView` must be specified", "NoItemViewError");
+ }
+
+ return itemView;
+ },
+
+ // Render the child item's view and add it to the
+ // HTML for the collection view.
+ addItemView: function(item, ItemView, index){
+ // get the itemViewOptions if any were specified
+ var itemViewOptions = Marionette.getOption(this, "itemViewOptions");
+ if (_.isFunction(itemViewOptions)){
+ itemViewOptions = itemViewOptions.call(this, item, index);
+ }
+
+ // build the view
+ var view = this.buildItemView(item, ItemView, itemViewOptions);
+
+ // set up the child view event forwarding
+ this.addChildViewEventForwarding(view);
+
+ // this view is about to be added
+ this.triggerMethod("before:item:added", view);
+
+ // Store the child view itself so we can properly
+ // remove and/or close it later
+ this.children.add(view);
+
+ // Render it and show it
+ this.renderItemView(view, index);
+
+ // call the "show" method if the collection view
+ // has already been shown
+ if (this._isShown){
+ Marionette.triggerMethod.call(view, "show");
+ }
+
+ // this view was added
+ this.triggerMethod("after:item:added", view);
+ },
+
+ // Set up the child view event forwarding. Uses an "itemview:"
+ // prefix in front of all forwarded events.
+ addChildViewEventForwarding: function(view){
+ var prefix = Marionette.getOption(this, "itemViewEventPrefix");
+
+ // Forward all child item view events through the parent,
+ // prepending "itemview:" to the event name
+ this.listenTo(view, "all", function(){
+ var args = slice(arguments);
+ args[0] = prefix + ":" + args[0];
+ args.splice(1, 0, view);
+
+ Marionette.triggerMethod.apply(this, args);
+ }, this);
+ },
+
+ // render the item view
+ renderItemView: function(view, index) {
+ view.render();
+ this.appendHtml(this, view, index);
+ },
+
+ // Build an `itemView` for every model in the collection.
+ buildItemView: function(item, ItemViewType, itemViewOptions){
+ var options = _.extend({model: item}, itemViewOptions);
+ return new ItemViewType(options);
+ },
+
+ // get the child view by item it holds, and remove it
+ removeItemView: function(item){
+ var view = this.children.findByModel(item);
+ this.removeChildView(view);
+ this.checkEmpty();
+ },
+
+ // Remove the child view and close it
+ removeChildView: function(view){
+
+ // shut down the child view properly,
+ // including events that the collection has from it
+ if (view){
+ this.stopListening(view);
+
+ // call 'close' or 'remove', depending on which is found
+ if (view.close) { view.close(); }
+ else if (view.remove) { view.remove(); }
+
+ this.children.remove(view);
+ }
+
+ this.triggerMethod("item:removed", view);
+ },
+
+ // helper to show the empty view if the collection is empty
+ checkEmpty: function() {
+ // check if we're empty now, and if we are, show the
+ // empty view
+ if (!this.collection || this.collection.length === 0){
+ this.showEmptyView();
+ }
+ },
+
+ // Append the HTML to the collection's `el`.
+ // Override this method to do something other
+ // then `.append`.
+ appendHtml: function(collectionView, itemView, index){
+ collectionView.$el.append(itemView.el);
+ },
+
+ // Internal method to set up the `children` object for
+ // storing all of the child views
+ _initChildViewStorage: function(){
+ this.children = new Backbone.ChildViewContainer();
+ },
+
+ // Handle cleanup and other closing needs for
+ // the collection of views.
+ close: function(){
+ if (this.isClosed){ return; }
+
+ this.triggerMethod("collection:before:close");
+ this.closeChildren();
+ this.triggerMethod("collection:closed");
+
+ Marionette.View.prototype.close.apply(this, slice(arguments));
+ },
+
+ // Close the child views that this collection view
+ // is holding on to, if any
+ closeChildren: function(){
+ this.children.each(function(child){
+ this.removeChildView(child);
+ }, this);
+ this.checkEmpty();
+ }
+});
+
+
+// Composite View
+// --------------
+
+// Used for rendering a branch-leaf, hierarchical structure.
+// Extends directly from CollectionView and also renders an
+// an item view as `modelView`, for the top leaf
+Marionette.CompositeView = Marionette.CollectionView.extend({
+
+ // Setting up the inheritance chain which allows changes to
+ // Marionette.CollectionView.prototype.constructor which allows overriding
+ constructor: function(){
+ Marionette.CollectionView.prototype.constructor.apply(this, slice(arguments));
+ },
+
+ // Configured the initial events that the composite view
+ // binds to. Override this method to prevent the initial
+ // events, or to add your own initial events.
+ _initialEvents: function(){
+ if (this.collection){
+ this.listenTo(this.collection, "add", this.addChildView, this);
+ this.listenTo(this.collection, "remove", this.removeItemView, this);
+ this.listenTo(this.collection, "reset", this._renderChildren, this);
+ }
+ },
+
+ // Retrieve the `itemView` to be used when rendering each of
+ // the items in the collection. The default is to return
+ // `this.itemView` or Marionette.CompositeView if no `itemView`
+ // has been defined
+ getItemView: function(item){
+ var itemView = Marionette.getOption(this, "itemView") || this.constructor;
+
+ if (!itemView){
+ throwError("An `itemView` must be specified", "NoItemViewError");
+ }
+
+ return itemView;
+ },
+
+ // Serialize the collection for the view.
+ // You can override the `serializeData` method in your own view
+ // definition, to provide custom serialization for your view's data.
+ serializeData: function(){
+ var data = {};
+
+ if (this.model){
+ data = this.model.toJSON();
+ }
+
+ return data;
+ },
+
+ // Renders the model once, and the collection once. Calling
+ // this again will tell the model's view to re-render itself
+ // but the collection will not re-render.
+ render: function(){
+ this.isRendered = true;
+ this.isClosed = false;
+ this.resetItemViewContainer();
+
+ this.triggerBeforeRender();
+ var html = this.renderModel();
+ this.$el.html(html);
+ // the ui bindings is done here and not at the end of render since they
+ // will not be available until after the model is rendered, but should be
+ // available before the collection is rendered.
+ this.bindUIElements();
+ this.triggerMethod("composite:model:rendered");
+
+ this._renderChildren();
+
+ this.triggerMethod("composite:rendered");
+ this.triggerRendered();
+ return this;
+ },
+
+ _renderChildren: function(){
+ if (this.isRendered){
+ Marionette.CollectionView.prototype._renderChildren.call(this);
+ this.triggerMethod("composite:collection:rendered");
+ }
+ },
+
+ // Render an individual model, if we have one, as
+ // part of a composite view (branch / leaf). For example:
+ // a treeview.
+ renderModel: function(){
+ var data = {};
+ data = this.serializeData();
+ data = this.mixinTemplateHelpers(data);
+
+ var template = this.getTemplate();
+ return Marionette.Renderer.render(template, data);
+ },
+
+ // Appends the `el` of itemView instances to the specified
+ // `itemViewContainer` (a jQuery selector). Override this method to
+ // provide custom logic of how the child item view instances have their
+ // HTML appended to the composite view instance.
+ appendHtml: function(cv, iv, index){
+ var $container = this.getItemViewContainer(cv);
+ $container.append(iv.el);
+ },
+
+ // Internal method to ensure an `$itemViewContainer` exists, for the
+ // `appendHtml` method to use.
+ getItemViewContainer: function(containerView){
+ if ("$itemViewContainer" in containerView){
+ return containerView.$itemViewContainer;
+ }
+
+ var container;
+ var itemViewContainer = Marionette.getOption(containerView, "itemViewContainer");
+ if (itemViewContainer){
+
+ var selector = _.isFunction(itemViewContainer) ? itemViewContainer() : itemViewContainer;
+ container = containerView.$(selector);
+ if (container.length <= 0) {
+ throwError("The specified `itemViewContainer` was not found: " + containerView.itemViewContainer, "ItemViewContainerMissingError");
+ }
+
+ } else {
+ container = containerView.$el;
+ }
+
+ containerView.$itemViewContainer = container;
+ return container;
+ },
+
+ // Internal method to reset the `$itemViewContainer` on render
+ resetItemViewContainer: function(){
+ if (this.$itemViewContainer){
+ delete this.$itemViewContainer;
+ }
+ }
+});
+
+
+// Layout
+// ------
+
+// Used for managing application layouts, nested layouts and
+// multiple regions within an application or sub-application.
+//
+// A specialized view type that renders an area of HTML and then
+// attaches `Region` instances to the specified `regions`.
+// Used for composite view management and sub-application areas.
+Marionette.Layout = Marionette.ItemView.extend({
+ regionType: Marionette.Region,
+
+ // Ensure the regions are available when the `initialize` method
+ // is called.
+ constructor: function (options) {
+ options = options || {};
+
+ this._firstRender = true;
+ this._initializeRegions(options);
+
+ Marionette.ItemView.prototype.constructor.call(this, options);
+ },
+
+ // Layout's render will use the existing region objects the
+ // first time it is called. Subsequent calls will close the
+ // views that the regions are showing and then reset the `el`
+ // for the regions to the newly rendered DOM elements.
+ render: function(){
+
+ if (this.isClosed){
+ // a previously closed layout means we need to
+ // completely re-initialize the regions
+ this._initializeRegions();
+ }
+ if (this._firstRender) {
+ // if this is the first render, don't do anything to
+ // reset the regions
+ this._firstRender = false;
+ } else if (!this.isClosed){
+ // If this is not the first render call, then we need to
+ // re-initializing the `el` for each region
+ this._reInitializeRegions();
+ }
+
+ var args = Array.prototype.slice.apply(arguments);
+ var result = Marionette.ItemView.prototype.render.apply(this, args);
+
+ return result;
+ },
+
+ // Handle closing regions, and then close the view itself.
+ close: function () {
+ if (this.isClosed){ return; }
+ this.regionManager.close();
+ var args = Array.prototype.slice.apply(arguments);
+ Marionette.ItemView.prototype.close.apply(this, args);
+ },
+
+ // Add a single region, by name, to the layout
+ addRegion: function(name, definition){
+ var regions = {};
+ regions[name] = definition;
+ return this._buildRegions(regions)[name];
+ },
+
+ // Add multiple regions as a {name: definition, name2: def2} object literal
+ addRegions: function(regions){
+ this.regions = _.extend({}, this.regions, regions);
+ return this._buildRegions(regions);
+ },
+
+ // Remove a single region from the Layout, by name
+ removeRegion: function(name){
+ delete this.regions[name];
+ return this.regionManager.removeRegion(name);
+ },
+
+ // internal method to build regions
+ _buildRegions: function(regions){
+ var that = this;
+
+ var defaults = {
+ regionType: Marionette.getOption(this, "regionType"),
+ parentEl: function(){ return that.$el; }
+ };
+
+ return this.regionManager.addRegions(regions, defaults);
+ },
+
+ // Internal method to initialize the regions that have been defined in a
+ // `regions` attribute on this layout.
+ _initializeRegions: function (options) {
+ var regions;
+ this._initRegionManager();
+
+ if (_.isFunction(this.regions)) {
+ regions = this.regions(options);
+ } else {
+ regions = this.regions || {};
+ }
+
+ this.addRegions(regions);
+ },
+
+ // Internal method to re-initialize all of the regions by updating the `el` that
+ // they point to
+ _reInitializeRegions: function(){
+ this.regionManager.closeRegions();
+ this.regionManager.each(function(region){
+ region.reset();
+ });
+ },
+
+ // Internal method to initialize the region manager
+ // and all regions in it
+ _initRegionManager: function(){
+ this.regionManager = new Marionette.RegionManager();
+
+ this.listenTo(this.regionManager, "region:add", function(name, region){
+ this[name] = region;
+ this.trigger("region:add", name, region);
+ });
+
+ this.listenTo(this.regionManager, "region:remove", function(name, region){
+ delete this[name];
+ this.trigger("region:remove", name, region);
+ });
+ }
+});
+
+
+// AppRouter
+// ---------
+
+// Reduce the boilerplate code of handling route events
+// and then calling a single method on another object.
+// Have your routers configured to call the method on
+// your object, directly.
+//
+// Configure an AppRouter with `appRoutes`.
+//
+// App routers can only take one `controller` object.
+// It is recommended that you divide your controller
+// objects in to smaller pieces of related functionality
+// and have multiple routers / controllers, instead of
+// just one giant router and controller.
+//
+// You can also add standard routes to an AppRouter.
+
+Marionette.AppRouter = Backbone.Router.extend({
+
+ constructor: function(options){
+ Backbone.Router.prototype.constructor.apply(this, slice(arguments));
+
+ this.options = options || {};
+
+ var appRoutes = Marionette.getOption(this, "appRoutes");
+ var controller = this._getController();
+ this.processAppRoutes(controller, appRoutes);
+ },
+
+ // Similar to route method on a Backbone Router but
+ // method is called on the controller
+ appRoute: function(route, methodName) {
+ var controller = this._getController();
+ this._addAppRoute(controller, route, methodName);
+ },
+
+ // Internal method to process the `appRoutes` for the
+ // router, and turn them in to routes that trigger the
+ // specified method on the specified `controller`.
+ processAppRoutes: function(controller, appRoutes) {
+ if (!appRoutes){ return; }
+
+ var routeNames = _.keys(appRoutes).reverse(); // Backbone requires reverted order of routes
+
+ _.each(routeNames, function(route) {
+ this._addAppRoute(controller, route, appRoutes[route]);
+ }, this);
+ },
+
+ _getController: function(){
+ return Marionette.getOption(this, "controller");
+ },
+
+ _addAppRoute: function(controller, route, methodName){
+ var method = controller[methodName];
+
+ if (!method) {
+ throw new Error("Method '" + methodName + "' was not found on the controller");
+ }
+
+ this.route(route, methodName, _.bind(method, controller));
+ }
+});
+
+
+// Application
+// -----------
+
+// Contain and manage the composite application as a whole.
+// Stores and starts up `Region` objects, includes an
+// event aggregator as `app.vent`
+Marionette.Application = function(options){
+ this._initRegionManager();
+ this._initCallbacks = new Marionette.Callbacks();
+ this.vent = new Backbone.Wreqr.EventAggregator();
+ this.commands = new Backbone.Wreqr.Commands();
+ this.reqres = new Backbone.Wreqr.RequestResponse();
+ this.submodules = {};
+
+ _.extend(this, options);
+
+ this.triggerMethod = Marionette.triggerMethod;
+};
+
+_.extend(Marionette.Application.prototype, Backbone.Events, {
+ // Command execution, facilitated by Backbone.Wreqr.Commands
+ execute: function(){
+ var args = Array.prototype.slice.apply(arguments);
+ this.commands.execute.apply(this.commands, args);
+ },
+
+ // Request/response, facilitated by Backbone.Wreqr.RequestResponse
+ request: function(){
+ var args = Array.prototype.slice.apply(arguments);
+ return this.reqres.request.apply(this.reqres, args);
+ },
+
+ // Add an initializer that is either run at when the `start`
+ // method is called, or run immediately if added after `start`
+ // has already been called.
+ addInitializer: function(initializer){
+ this._initCallbacks.add(initializer);
+ },
+
+ // kick off all of the application's processes.
+ // initializes all of the regions that have been added
+ // to the app, and runs all of the initializer functions
+ start: function(options){
+ this.triggerMethod("initialize:before", options);
+ this._initCallbacks.run(options, this);
+ this.triggerMethod("initialize:after", options);
+
+ this.triggerMethod("start", options);
+ },
+
+ // Add regions to your app.
+ // Accepts a hash of named strings or Region objects
+ // addRegions({something: "#someRegion"})
+ // addRegions({something: Region.extend({el: "#someRegion"}) });
+ addRegions: function(regions){
+ return this._regionManager.addRegions(regions);
+ },
+
+ // Close all regions in the app, without removing them
+ closeRegions: function(){
+ this._regionManager.closeRegions();
+ },
+
+ // Removes a region from your app, by name
+ // Accepts the regions name
+ // removeRegion('myRegion')
+ removeRegion: function(region) {
+ this._regionManager.removeRegion(region);
+ },
+
+ // Provides alternative access to regions
+ // Accepts the region name
+ // getRegion('main')
+ getRegion: function(region) {
+ return this._regionManager.get(region);
+ },
+
+ // Create a module, attached to the application
+ module: function(moduleNames, moduleDefinition){
+ // slice the args, and add this application object as the
+ // first argument of the array
+ var args = slice(arguments);
+ args.unshift(this);
+
+ // see the Marionette.Module object for more information
+ return Marionette.Module.create.apply(Marionette.Module, args);
+ },
+
+ // Internal method to set up the region manager
+ _initRegionManager: function(){
+ this._regionManager = new Marionette.RegionManager();
+
+ this.listenTo(this._regionManager, "region:add", function(name, region){
+ this[name] = region;
+ });
+
+ this.listenTo(this._regionManager, "region:remove", function(name, region){
+ delete this[name];
+ });
+ }
+});
+
+// Copy the `extend` function used by Backbone's classes
+Marionette.Application.extend = Marionette.extend;
+
+// Module
+// ------
+
+// A simple module system, used to create privacy and encapsulation in
+// Marionette applications
+Marionette.Module = function(moduleName, app){
+ this.moduleName = moduleName;
+
+ // store sub-modules
+ this.submodules = {};
+
+ this._setupInitializersAndFinalizers();
+
+ // store the configuration for this module
+ this.app = app;
+ this.startWithParent = true;
+
+ this.triggerMethod = Marionette.triggerMethod;
+};
+
+// Extend the Module prototype with events / listenTo, so that the module
+// can be used as an event aggregator or pub/sub.
+_.extend(Marionette.Module.prototype, Backbone.Events, {
+
+ // Initializer for a specific module. Initializers are run when the
+ // module's `start` method is called.
+ addInitializer: function(callback){
+ this._initializerCallbacks.add(callback);
+ },
+
+ // Finalizers are run when a module is stopped. They are used to teardown
+ // and finalize any variables, references, events and other code that the
+ // module had set up.
+ addFinalizer: function(callback){
+ this._finalizerCallbacks.add(callback);
+ },
+
+ // Start the module, and run all of its initializers
+ start: function(options){
+ // Prevent re-starting a module that is already started
+ if (this._isInitialized){ return; }
+
+ // start the sub-modules (depth-first hierarchy)
+ _.each(this.submodules, function(mod){
+ // check to see if we should start the sub-module with this parent
+ if (mod.startWithParent){
+ mod.start(options);
+ }
+ });
+
+ // run the callbacks to "start" the current module
+ this.triggerMethod("before:start", options);
+
+ this._initializerCallbacks.run(options, this);
+ this._isInitialized = true;
+
+ this.triggerMethod("start", options);
+ },
+
+ // Stop this module by running its finalizers and then stop all of
+ // the sub-modules for this module
+ stop: function(){
+ // if we are not initialized, don't bother finalizing
+ if (!this._isInitialized){ return; }
+ this._isInitialized = false;
+
+ Marionette.triggerMethod.call(this, "before:stop");
+
+ // stop the sub-modules; depth-first, to make sure the
+ // sub-modules are stopped / finalized before parents
+ _.each(this.submodules, function(mod){ mod.stop(); });
+
+ // run the finalizers
+ this._finalizerCallbacks.run(undefined,this);
+
+ // reset the initializers and finalizers
+ this._initializerCallbacks.reset();
+ this._finalizerCallbacks.reset();
+
+ Marionette.triggerMethod.call(this, "stop");
+ },
+
+ // Configure the module with a definition function and any custom args
+ // that are to be passed in to the definition function
+ addDefinition: function(moduleDefinition, customArgs){
+ this._runModuleDefinition(moduleDefinition, customArgs);
+ },
+
+ // Internal method: run the module definition function with the correct
+ // arguments
+ _runModuleDefinition: function(definition, customArgs){
+ if (!definition){ return; }
+
+ // build the correct list of arguments for the module definition
+ var args = _.flatten([
+ this,
+ this.app,
+ Backbone,
+ Marionette,
+ Marionette.$, _,
+ customArgs
+ ]);
+
+ definition.apply(this, args);
+ },
+
+ // Internal method: set up new copies of initializers and finalizers.
+ // Calling this method will wipe out all existing initializers and
+ // finalizers.
+ _setupInitializersAndFinalizers: function(){
+ this._initializerCallbacks = new Marionette.Callbacks();
+ this._finalizerCallbacks = new Marionette.Callbacks();
+ }
+});
+
+// Type methods to create modules
+_.extend(Marionette.Module, {
+
+ // Create a module, hanging off the app parameter as the parent object.
+ create: function(app, moduleNames, moduleDefinition){
+ var module = app;
+
+ // get the custom args passed in after the module definition and
+ // get rid of the module name and definition function
+ var customArgs = slice(arguments);
+ customArgs.splice(0, 3);
+
+ // split the module names and get the length
+ moduleNames = moduleNames.split(".");
+ var length = moduleNames.length;
+
+ // store the module definition for the last module in the chain
+ var moduleDefinitions = [];
+ moduleDefinitions[length-1] = moduleDefinition;
+
+ // Loop through all the parts of the module definition
+ _.each(moduleNames, function(moduleName, i){
+ var parentModule = module;
+ module = this._getModule(parentModule, moduleName, app);
+ this._addModuleDefinition(parentModule, module, moduleDefinitions[i], customArgs);
+ }, this);
+
+ // Return the last module in the definition chain
+ return module;
+ },
+
+ _getModule: function(parentModule, moduleName, app, def, args){
+ // Get an existing module of this name if we have one
+ var module = parentModule[moduleName];
+
+ if (!module){
+ // Create a new module if we don't have one
+ module = new Marionette.Module(moduleName, app);
+ parentModule[moduleName] = module;
+ // store the module on the parent
+ parentModule.submodules[moduleName] = module;
+ }
+
+ return module;
+ },
+
+ _addModuleDefinition: function(parentModule, module, def, args){
+ var fn;
+ var startWithParent;
+
+ if (_.isFunction(def)){
+ // if a function is supplied for the module definition
+ fn = def;
+ startWithParent = true;
+
+ } else if (_.isObject(def)){
+ // if an object is supplied
+ fn = def.define;
+ startWithParent = def.startWithParent;
+
+ } else {
+ // if nothing is supplied
+ startWithParent = true;
+ }
+
+ // add module definition if needed
+ if (fn){
+ module.addDefinition(fn, args);
+ }
+
+ // `and` the two together, ensuring a single `false` will prevent it
+ // from starting with the parent
+ module.startWithParent = module.startWithParent && startWithParent;
+
+ // setup auto-start if needed
+ if (module.startWithParent && !module.startWithParentIsConfigured){
+
+ // only configure this once
+ module.startWithParentIsConfigured = true;
+
+ // add the module initializer config
+ parentModule.addInitializer(function(options){
+ if (module.startWithParent){
+ module.start(options);
+ }
+ });
+
+ }
+
+ }
+});
+
+
+
+ return Marionette;
+})(this, Backbone, _);
\ No newline at end of file
=== added directory 'web_unleashed/static/lib/underscore'
=== added directory 'web_unleashed/static/lib/underscore-addons'
=== added file 'web_unleashed/static/lib/underscore-addons/underscore.deep_extend.js'
--- web_unleashed/static/lib/underscore-addons/underscore.deep_extend.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/underscore-addons/underscore.deep_extend.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,52 @@
+/* Copyright (C) 2012-2013 Kurt Milam - http://xioup.com | Source: https://gist.github.com/1868955
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+
+// Based conceptually on the _.extend() function in underscore.js ( see http://documentcloud.github.com/underscore/#extend for more details )
+
+// source: https://gist.github.com/kurtmilam/1868955
+
+(function(Underscore){
+ var _ = Underscore;
+ var deepExtend = function(obj) {
+ var parentRE = /#{\s*?_\s*?}/, slice = Array.prototype.slice, hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ _.each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ if (hasOwnProperty.call(source, prop)) {
+ if (_.isUndefined(obj[prop]) || _.isFunction(obj[prop]) || _.isNull(source[prop])) {
+ obj[prop] = source[prop];
+ } else if (_.isString(source[prop]) && parentRE.test(source[prop])) {
+ if (_.isString(obj[prop])) {
+ obj[prop] = source[prop].replace(parentRE, obj[prop]);
+ }
+ } else if (_.isArray(obj[prop]) || _.isArray(source[prop])) {
+ if (!_.isArray(obj[prop]) || !_.isArray(source[prop])) {
+ throw 'Error: Trying to combine an array with a non-array (' + prop + ')';
+ } else {
+ obj[prop] = _.reject(_.deepExtend(obj[prop], source[prop]), function(item) {
+ return _.isNull(item);
+ });
+ }
+ } else if (_.isObject(obj[prop]) || _.isObject(source[prop])) {
+ if (!_.isObject(obj[prop]) || !_.isObject(source[prop])) {
+ throw 'Error: Trying to combine an object with a non-object (' + prop + ')';
+ } else {
+ obj[prop] = _.deepExtend(obj[prop], source[prop]);
+ }
+ } else {
+ obj[prop] = source[prop];
+ }
+ }
+ }
+ });
+ return obj;
+ };
+
+ Underscore.mixin({deepExtend: deepExtend});
+
+})(_ || Underscore)
\ No newline at end of file
=== added file 'web_unleashed/static/lib/underscore-addons/underscore.find_index_where.js'
--- web_unleashed/static/lib/underscore-addons/underscore.find_index_where.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/underscore-addons/underscore.find_index_where.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,25 @@
+(function(Underscore) {
+ var _ = Underscore;
+ var findIndexWhere = function(obj, find) {
+
+ var index = null, name;
+ _.each(obj, function(item, i) {
+ var found = true;
+ for(name in find){
+ if(item[name] !== find[name]){
+ found = false;
+ }
+ }
+ if(found){
+ index = i;
+ }
+ });
+
+ return obj;
+ };
+
+ Underscore.mixin({
+ findIndexWhere : findIndexWhere
+ });
+
+})(_ || Underscore)
\ No newline at end of file
=== added file 'web_unleashed/static/lib/underscore/underscore.js'
--- web_unleashed/static/lib/underscore/underscore.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/lib/underscore/underscore.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,1276 @@
+// Underscore.js 1.5.2
+// http://underscorejs.org
+// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+// Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `exports` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Establish the object that gets returned to break out of a loop iteration.
+ var breaker = {};
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var
+ push = ArrayProto.push,
+ slice = ArrayProto.slice,
+ concat = ArrayProto.concat,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeForEach = ArrayProto.forEach,
+ nativeMap = ArrayProto.map,
+ nativeReduce = ArrayProto.reduce,
+ nativeReduceRight = ArrayProto.reduceRight,
+ nativeFilter = ArrayProto.filter,
+ nativeEvery = ArrayProto.every,
+ nativeSome = ArrayProto.some,
+ nativeIndexOf = ArrayProto.indexOf,
+ nativeLastIndexOf = ArrayProto.lastIndexOf,
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) {
+ if (obj instanceof _) return obj;
+ if (!(this instanceof _)) return new _(obj);
+ this._wrapped = obj;
+ };
+
+ // Export the Underscore object for **Node.js**, with
+ // backwards-compatibility for the old `require()` API. If we're in
+ // the browser, add `_` as a global object via a string identifier,
+ // for Closure Compiler "advanced" mode.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else {
+ root._ = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.5.2';
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles objects with the built-in `forEach`, arrays, and raw objects.
+ // Delegates to **ECMAScript 5**'s native `forEach` if available.
+ var each = _.each = _.forEach = function(obj, iterator, context) {
+ if (obj == null) return;
+ if (nativeForEach && obj.forEach === nativeForEach) {
+ obj.forEach(iterator, context);
+ } else if (obj.length === +obj.length) {
+ for (var i = 0, length = obj.length; i < length; i++) {
+ if (iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ var keys = _.keys(obj);
+ for (var i = 0, length = keys.length; i < length; i++) {
+ if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
+ }
+ }
+ };
+
+ // Return the results of applying the iterator to each element.
+ // Delegates to **ECMAScript 5**'s native `map` if available.
+ _.map = _.collect = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+ each(obj, function(value, index, list) {
+ results.push(iterator.call(context, value, index, list));
+ });
+ return results;
+ };
+
+ var reduceError = 'Reduce of empty array with no initial value';
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+ _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduce && obj.reduce === nativeReduce) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+ }
+ each(obj, function(value, index, list) {
+ if (!initial) {
+ memo = value;
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, value, index, list);
+ }
+ });
+ if (!initial) throw new TypeError(reduceError);
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+ _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+ }
+ var length = obj.length;
+ if (length !== +length) {
+ var keys = _.keys(obj);
+ length = keys.length;
+ }
+ each(obj, function(value, index, list) {
+ index = keys ? keys[--length] : --length;
+ if (!initial) {
+ memo = obj[index];
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, obj[index], index, list);
+ }
+ });
+ if (!initial) throw new TypeError(reduceError);
+ return memo;
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, iterator, context) {
+ var result;
+ any(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Delegates to **ECMAScript 5**'s native `filter` if available.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+ each(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) results.push(value);
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, iterator, context) {
+ return _.filter(obj, function(value, index, list) {
+ return !iterator.call(context, value, index, list);
+ }, context);
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Delegates to **ECMAScript 5**'s native `every` if available.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = true;
+ if (obj == null) return result;
+ if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+ each(obj, function(value, index, list) {
+ if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Delegates to **ECMAScript 5**'s native `some` if available.
+ // Aliased as `any`.
+ var any = _.some = _.any = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = false;
+ if (obj == null) return result;
+ if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+ each(obj, function(value, index, list) {
+ if (result || (result = iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if the array or object contains a given value (using `===`).
+ // Aliased as `include`.
+ _.contains = _.include = function(obj, target) {
+ if (obj == null) return false;
+ if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+ return any(obj, function(value) {
+ return value === target;
+ });
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ var isFunc = _.isFunction(method);
+ return _.map(obj, function(value) {
+ return (isFunc ? method : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, function(value){ return value[key]; });
+ };
+
+ // Convenience version of a common use case of `filter`: selecting only objects
+ // containing specific `key:value` pairs.
+ _.where = function(obj, attrs, first) {
+ if (_.isEmpty(attrs)) return first ? void 0 : [];
+ return _[first ? 'find' : 'filter'](obj, function(value) {
+ for (var key in attrs) {
+ if (attrs[key] !== value[key]) return false;
+ }
+ return true;
+ });
+ };
+
+ // Convenience version of a common use case of `find`: getting the first object
+ // containing specific `key:value` pairs.
+ _.findWhere = function(obj, attrs) {
+ return _.where(obj, attrs, true);
+ };
+
+ // Return the maximum element or (element-based computation).
+ // Can't optimize arrays of integers longer than 65,535 elements.
+ // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
+ _.max = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+ return Math.max.apply(Math, obj);
+ }
+ if (!iterator && _.isEmpty(obj)) return -Infinity;
+ var result = {computed : -Infinity, value: -Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed > result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+ return Math.min.apply(Math, obj);
+ }
+ if (!iterator && _.isEmpty(obj)) return Infinity;
+ var result = {computed : Infinity, value: Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed < result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Shuffle an array, using the modern version of the
+ // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
+ _.shuffle = function(obj) {
+ var rand;
+ var index = 0;
+ var shuffled = [];
+ each(obj, function(value) {
+ rand = _.random(index++);
+ shuffled[index - 1] = shuffled[rand];
+ shuffled[rand] = value;
+ });
+ return shuffled;
+ };
+
+ // Sample **n** random values from an array.
+ // If **n** is not specified, returns a single random element from the array.
+ // The internal `guard` argument allows it to work with `map`.
+ _.sample = function(obj, n, guard) {
+ if (arguments.length < 2 || guard) {
+ return obj[_.random(obj.length - 1)];
+ }
+ return _.shuffle(obj).slice(0, Math.max(0, n));
+ };
+
+ // An internal function to generate lookup iterators.
+ var lookupIterator = function(value) {
+ return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+ };
+
+ // Sort the object's values by a criterion produced by an iterator.
+ _.sortBy = function(obj, value, context) {
+ var iterator = lookupIterator(value);
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value: value,
+ index: index,
+ criteria: iterator.call(context, value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria;
+ var b = right.criteria;
+ if (a !== b) {
+ if (a > b || a === void 0) return 1;
+ if (a < b || b === void 0) return -1;
+ }
+ return left.index - right.index;
+ }), 'value');
+ };
+
+ // An internal function used for aggregate "group by" operations.
+ var group = function(behavior) {
+ return function(obj, value, context) {
+ var result = {};
+ var iterator = value == null ? _.identity : lookupIterator(value);
+ each(obj, function(value, index) {
+ var key = iterator.call(context, value, index, obj);
+ behavior(result, key, value);
+ });
+ return result;
+ };
+ };
+
+ // Groups the object's values by a criterion. Pass either a string attribute
+ // to group by, or a function that returns the criterion.
+ _.groupBy = group(function(result, key, value) {
+ (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+ });
+
+ // Indexes the object's values by a criterion, similar to `groupBy`, but for
+ // when you know that your index values will be unique.
+ _.indexBy = group(function(result, key, value) {
+ result[key] = value;
+ });
+
+ // Counts instances of an object that group by a certain criterion. Pass
+ // either a string attribute to count by, or a function that returns the
+ // criterion.
+ _.countBy = group(function(result, key) {
+ _.has(result, key) ? result[key]++ : result[key] = 1;
+ });
+
+ // Use a comparator function to figure out the smallest index at which
+ // an object should be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iterator, context) {
+ iterator = iterator == null ? _.identity : lookupIterator(iterator);
+ var value = iterator.call(context, obj);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+ }
+ return low;
+ };
+
+ // Safely create a real, live array from anything iterable.
+ _.toArray = function(obj) {
+ if (!obj) return [];
+ if (_.isArray(obj)) return slice.call(obj);
+ if (obj.length === +obj.length) return _.map(obj, _.identity);
+ return _.values(obj);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ if (obj == null) return 0;
+ return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head` and `take`. The **guard** check
+ // allows it to work with `_.map`.
+ _.first = _.head = _.take = function(array, n, guard) {
+ if (array == null) return void 0;
+ return (n == null) || guard ? array[0] : slice.call(array, 0, n);
+ };
+
+ // Returns everything but the last entry of the array. Especially useful on
+ // the arguments object. Passing **n** will return all the values in
+ // the array, excluding the last N. The **guard** check allows it to work with
+ // `_.map`.
+ _.initial = function(array, n, guard) {
+ return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+ };
+
+ // Get the last element of an array. Passing **n** will return the last N
+ // values in the array. The **guard** check allows it to work with `_.map`.
+ _.last = function(array, n, guard) {
+ if (array == null) return void 0;
+ if ((n == null) || guard) {
+ return array[array.length - 1];
+ } else {
+ return slice.call(array, Math.max(array.length - n, 0));
+ }
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+ // Especially useful on the arguments object. Passing an **n** will return
+ // the rest N values in the array. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = _.drop = function(array, n, guard) {
+ return slice.call(array, (n == null) || guard ? 1 : n);
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, _.identity);
+ };
+
+ // Internal implementation of a recursive `flatten` function.
+ var flatten = function(input, shallow, output) {
+ if (shallow && _.every(input, _.isArray)) {
+ return concat.apply(output, input);
+ }
+ each(input, function(value) {
+ if (_.isArray(value) || _.isArguments(value)) {
+ shallow ? push.apply(output, value) : flatten(value, shallow, output);
+ } else {
+ output.push(value);
+ }
+ });
+ return output;
+ };
+
+ // Flatten out an array, either recursively (by default), or just one level.
+ _.flatten = function(array, shallow) {
+ return flatten(array, shallow, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ return _.difference(array, slice.call(arguments, 1));
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted, iterator, context) {
+ if (_.isFunction(isSorted)) {
+ context = iterator;
+ iterator = isSorted;
+ isSorted = false;
+ }
+ var initial = iterator ? _.map(array, iterator, context) : array;
+ var results = [];
+ var seen = [];
+ each(initial, function(value, index) {
+ if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+ seen.push(value);
+ results.push(array[index]);
+ }
+ });
+ return results;
+ };
+
+ // Produce an array that contains the union: each distinct element from all of
+ // the passed-in arrays.
+ _.union = function() {
+ return _.uniq(_.flatten(arguments, true));
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays.
+ _.intersection = function(array) {
+ var rest = slice.call(arguments, 1);
+ return _.filter(_.uniq(array), function(item) {
+ return _.every(rest, function(other) {
+ return _.indexOf(other, item) >= 0;
+ });
+ });
+ };
+
+ // Take the difference between one array and a number of other arrays.
+ // Only the elements present in just the first array will remain.
+ _.difference = function(array) {
+ var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+ return _.filter(array, function(value){ return !_.contains(rest, value); });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function() {
+ var length = _.max(_.pluck(arguments, "length").concat(0));
+ var results = new Array(length);
+ for (var i = 0; i < length; i++) {
+ results[i] = _.pluck(arguments, '' + i);
+ }
+ return results;
+ };
+
+ // Converts lists into objects. Pass either a single array of `[key, value]`
+ // pairs, or two parallel arrays of the same length -- one of keys, and one of
+ // the corresponding values.
+ _.object = function(list, values) {
+ if (list == null) return {};
+ var result = {};
+ for (var i = 0, length = list.length; i < length; i++) {
+ if (values) {
+ result[list[i]] = values[i];
+ } else {
+ result[list[i][0]] = list[i][1];
+ }
+ }
+ return result;
+ };
+
+ // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+ // we need this function. Return the position of the first occurrence of an
+ // item in an array, or -1 if the item is not included in the array.
+ // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i = 0, length = array.length;
+ if (isSorted) {
+ if (typeof isSorted == 'number') {
+ i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
+ } else {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ }
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+ for (; i < length; i++) if (array[i] === item) return i;
+ return -1;
+ };
+
+ // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+ _.lastIndexOf = function(array, item, from) {
+ if (array == null) return -1;
+ var hasIndex = from != null;
+ if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+ return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+ }
+ var i = (hasIndex ? from : array.length);
+ while (i--) if (array[i] === item) return i;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = arguments[2] || 1;
+
+ var length = Math.max(Math.ceil((stop - start) / step), 0);
+ var idx = 0;
+ var range = new Array(length);
+
+ while(idx < length) {
+ range[idx++] = start;
+ start += step;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Reusable constructor function for prototype setting.
+ var ctor = function(){};
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+ // available.
+ _.bind = function(func, context) {
+ var args, bound;
+ if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ if (!_.isFunction(func)) throw new TypeError;
+ args = slice.call(arguments, 2);
+ return bound = function() {
+ if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+ ctor.prototype = func.prototype;
+ var self = new ctor;
+ ctor.prototype = null;
+ var result = func.apply(self, args.concat(slice.call(arguments)));
+ if (Object(result) === result) return result;
+ return self;
+ };
+ };
+
+ // Partially apply a function by creating a version that has had some of its
+ // arguments pre-filled, without changing its dynamic `this` context.
+ _.partial = function(func) {
+ var args = slice.call(arguments, 1);
+ return function() {
+ return func.apply(this, args.concat(slice.call(arguments)));
+ };
+ };
+
+ // Bind all of an object's methods to that object. Useful for ensuring that
+ // all callbacks defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var funcs = slice.call(arguments, 1);
+ if (funcs.length === 0) throw new Error("bindAll must be passed function names");
+ each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memo = {};
+ hasher || (hasher = _.identity);
+ return function() {
+ var key = hasher.apply(this, arguments);
+ return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+ };
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){ return func.apply(null, args); }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time. Normally, the throttled function will run
+ // as much as it can, without ever going more than once per `wait` duration;
+ // but if you'd like to disable the execution on the leading edge, pass
+ // `{leading: false}`. To disable execution on the trailing edge, ditto.
+ _.throttle = function(func, wait, options) {
+ var context, args, result;
+ var timeout = null;
+ var previous = 0;
+ options || (options = {});
+ var later = function() {
+ previous = options.leading === false ? 0 : new Date;
+ timeout = null;
+ result = func.apply(context, args);
+ };
+ return function() {
+ var now = new Date;
+ if (!previous && options.leading === false) previous = now;
+ var remaining = wait - (now - previous);
+ context = this;
+ args = arguments;
+ if (remaining <= 0) {
+ clearTimeout(timeout);
+ timeout = null;
+ previous = now;
+ result = func.apply(context, args);
+ } else if (!timeout && options.trailing !== false) {
+ timeout = setTimeout(later, remaining);
+ }
+ return result;
+ };
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds. If `immediate` is passed, trigger the function on the
+ // leading edge, instead of the trailing.
+ _.debounce = function(func, wait, immediate) {
+ var timeout, args, context, timestamp, result;
+ return function() {
+ context = this;
+ args = arguments;
+ timestamp = new Date();
+ var later = function() {
+ var last = (new Date()) - timestamp;
+ if (last < wait) {
+ timeout = setTimeout(later, wait - last);
+ } else {
+ timeout = null;
+ if (!immediate) result = func.apply(context, args);
+ }
+ };
+ var callNow = immediate && !timeout;
+ if (!timeout) {
+ timeout = setTimeout(later, wait);
+ }
+ if (callNow) result = func.apply(context, args);
+ return result;
+ };
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = function(func) {
+ var ran = false, memo;
+ return function() {
+ if (ran) return memo;
+ ran = true;
+ memo = func.apply(this, arguments);
+ func = null;
+ return memo;
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return function() {
+ var args = [func];
+ push.apply(args, arguments);
+ return wrapper.apply(this, args);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var funcs = arguments;
+ return function() {
+ var args = arguments;
+ for (var i = funcs.length - 1; i >= 0; i--) {
+ args = [funcs[i].apply(this, args)];
+ }
+ return args[0];
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ return function() {
+ if (--times < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ };
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = nativeKeys || function(obj) {
+ if (obj !== Object(obj)) throw new TypeError('Invalid object');
+ var keys = [];
+ for (var key in obj) if (_.has(obj, key)) keys.push(key);
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ var keys = _.keys(obj);
+ var length = keys.length;
+ var values = new Array(length);
+ for (var i = 0; i < length; i++) {
+ values[i] = obj[keys[i]];
+ }
+ return values;
+ };
+
+ // Convert an object into a list of `[key, value]` pairs.
+ _.pairs = function(obj) {
+ var keys = _.keys(obj);
+ var length = keys.length;
+ var pairs = new Array(length);
+ for (var i = 0; i < length; i++) {
+ pairs[i] = [keys[i], obj[keys[i]]];
+ }
+ return pairs;
+ };
+
+ // Invert the keys and values of an object. The values must be serializable.
+ _.invert = function(obj) {
+ var result = {};
+ var keys = _.keys(obj);
+ for (var i = 0, length = keys.length; i < length; i++) {
+ result[obj[keys[i]]] = keys[i];
+ }
+ return result;
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ var names = [];
+ for (var key in obj) {
+ if (_.isFunction(obj[key])) names.push(key);
+ }
+ return names.sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ if (source) {
+ for (var prop in source) {
+ obj[prop] = source[prop];
+ }
+ }
+ });
+ return obj;
+ };
+
+ // Return a copy of the object only containing the whitelisted properties.
+ _.pick = function(obj) {
+ var copy = {};
+ var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+ each(keys, function(key) {
+ if (key in obj) copy[key] = obj[key];
+ });
+ return copy;
+ };
+
+ // Return a copy of the object without the blacklisted properties.
+ _.omit = function(obj) {
+ var copy = {};
+ var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+ for (var key in obj) {
+ if (!_.contains(keys, key)) copy[key] = obj[key];
+ }
+ return copy;
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ if (source) {
+ for (var prop in source) {
+ if (obj[prop] === void 0) obj[prop] = source[prop];
+ }
+ }
+ });
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Internal recursive comparison function for `isEqual`.
+ var eq = function(a, b, aStack, bStack) {
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+ if (a === b) return a !== 0 || 1 / a == 1 / b;
+ // A strict comparison is necessary because `null == undefined`.
+ if (a == null || b == null) return a === b;
+ // Unwrap any wrapped objects.
+ if (a instanceof _) a = a._wrapped;
+ if (b instanceof _) b = b._wrapped;
+ // Compare `[[Class]]` names.
+ var className = toString.call(a);
+ if (className != toString.call(b)) return false;
+ switch (className) {
+ // Strings, numbers, dates, and booleans are compared by value.
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return a == String(b);
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+ // other numeric values.
+ return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a == +b;
+ // RegExps are compared by their source patterns and flags.
+ case '[object RegExp]':
+ return a.source == b.source &&
+ a.global == b.global &&
+ a.multiline == b.multiline &&
+ a.ignoreCase == b.ignoreCase;
+ }
+ if (typeof a != 'object' || typeof b != 'object') return false;
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = aStack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (aStack[length] == a) return bStack[length] == b;
+ }
+ // Objects with different constructors are not equivalent, but `Object`s
+ // from different frames are.
+ var aCtor = a.constructor, bCtor = b.constructor;
+ if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+ _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+ return false;
+ }
+ // Add the first object to the stack of traversed objects.
+ aStack.push(a);
+ bStack.push(b);
+ var size = 0, result = true;
+ // Recursively compare objects and arrays.
+ if (className == '[object Array]') {
+ // Compare array lengths to determine if a deep comparison is necessary.
+ size = a.length;
+ result = size == b.length;
+ if (result) {
+ // Deep compare the contents, ignoring non-numeric properties.
+ while (size--) {
+ if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+ }
+ }
+ } else {
+ // Deep compare objects.
+ for (var key in a) {
+ if (_.has(a, key)) {
+ // Count the expected number of properties.
+ size++;
+ // Deep compare each member.
+ if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+ }
+ }
+ // Ensure that both objects contain the same number of properties.
+ if (result) {
+ for (key in b) {
+ if (_.has(b, key) && !(size--)) break;
+ }
+ result = !size;
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ aStack.pop();
+ bStack.pop();
+ return result;
+ };
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ return eq(a, b, [], []);
+ };
+
+ // Is a given array, string, or object empty?
+ // An "empty" object has no enumerable own-properties.
+ _.isEmpty = function(obj) {
+ if (obj == null) return true;
+ if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+ for (var key in obj) if (_.has(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType === 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) == '[object Array]';
+ };
+
+ // Is a given variable an object?
+ _.isObject = function(obj) {
+ return obj === Object(obj);
+ };
+
+ // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+ each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+ _['is' + name] = function(obj) {
+ return toString.call(obj) == '[object ' + name + ']';
+ };
+ });
+
+ // Define a fallback version of the method in browsers (ahem, IE), where
+ // there isn't any inspectable "Arguments" type.
+ if (!_.isArguments(arguments)) {
+ _.isArguments = function(obj) {
+ return !!(obj && _.has(obj, 'callee'));
+ };
+ }
+
+ // Optimize `isFunction` if appropriate.
+ if (typeof (/./) !== 'function') {
+ _.isFunction = function(obj) {
+ return typeof obj === 'function';
+ };
+ }
+
+ // Is a given object a finite number?
+ _.isFinite = function(obj) {
+ return isFinite(obj) && !isNaN(parseFloat(obj));
+ };
+
+ // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+ _.isNaN = function(obj) {
+ return _.isNumber(obj) && obj != +obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Shortcut function for checking if an object has a given property directly
+ // on itself (in other words, not on a prototype).
+ _.has = function(obj, key) {
+ return hasOwnProperty.call(obj, key);
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iterators.
+ _.identity = function(value) {
+ return value;
+ };
+
+ // Run a function **n** times.
+ _.times = function(n, iterator, context) {
+ var accum = Array(Math.max(0, n));
+ for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+ return accum;
+ };
+
+ // Return a random integer between min and max (inclusive).
+ _.random = function(min, max) {
+ if (max == null) {
+ max = min;
+ min = 0;
+ }
+ return min + Math.floor(Math.random() * (max - min + 1));
+ };
+
+ // List of HTML entities for escaping.
+ var entityMap = {
+ escape: {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ }
+ };
+ entityMap.unescape = _.invert(entityMap.escape);
+
+ // Regexes containing the keys and values listed immediately above.
+ var entityRegexes = {
+ escape: new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+ unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+ };
+
+ // Functions for escaping and unescaping strings to/from HTML interpolation.
+ _.each(['escape', 'unescape'], function(method) {
+ _[method] = function(string) {
+ if (string == null) return '';
+ return ('' + string).replace(entityRegexes[method], function(match) {
+ return entityMap[method][match];
+ });
+ };
+ });
+
+ // If the value of the named `property` is a function then invoke it with the
+ // `object` as context; otherwise, return it.
+ _.result = function(object, property) {
+ if (object == null) return void 0;
+ var value = object[property];
+ return _.isFunction(value) ? value.call(object) : value;
+ };
+
+ // Add your own custom functions to the Underscore object.
+ _.mixin = function(obj) {
+ each(_.functions(obj), function(name) {
+ var func = _[name] = obj[name];
+ _.prototype[name] = function() {
+ var args = [this._wrapped];
+ push.apply(args, arguments);
+ return result.call(this, func.apply(_, args));
+ };
+ });
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = ++idCounter + '';
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g,
+ escape : /<%-([\s\S]+?)%>/g
+ };
+
+ // When customizing `templateSettings`, if you don't want to define an
+ // interpolation, evaluation or escaping regex, we need one that is
+ // guaranteed not to match.
+ var noMatch = /(.)^/;
+
+ // Certain characters need to be escaped so that they can be put into a
+ // string literal.
+ var escapes = {
+ "'": "'",
+ '\\': '\\',
+ '\r': 'r',
+ '\n': 'n',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ _.template = function(text, data, settings) {
+ var render;
+ settings = _.defaults({}, settings, _.templateSettings);
+
+ // Combine delimiters into one regular expression via alternation.
+ var matcher = new RegExp([
+ (settings.escape || noMatch).source,
+ (settings.interpolate || noMatch).source,
+ (settings.evaluate || noMatch).source
+ ].join('|') + '|$', 'g');
+
+ // Compile the template source, escaping string literals appropriately.
+ var index = 0;
+ var source = "__p+='";
+ text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+ source += text.slice(index, offset)
+ .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+ if (escape) {
+ source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+ }
+ if (interpolate) {
+ source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+ }
+ if (evaluate) {
+ source += "';\n" + evaluate + "\n__p+='";
+ }
+ index = offset + match.length;
+ return match;
+ });
+ source += "';\n";
+
+ // If a variable is not specified, place data values in local scope.
+ if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+ source = "var __t,__p='',__j=Array.prototype.join," +
+ "print=function(){__p+=__j.call(arguments,'');};\n" +
+ source + "return __p;\n";
+
+ try {
+ render = new Function(settings.variable || 'obj', '_', source);
+ } catch (e) {
+ e.source = source;
+ throw e;
+ }
+
+ if (data) return render(data, _);
+ var template = function(data) {
+ return render.call(this, data, _);
+ };
+
+ // Provide the compiled function source as a convenience for precompilation.
+ template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+ return template;
+ };
+
+ // Add a "chain" function, which will delegate to the wrapper.
+ _.chain = function(obj) {
+ return _(obj).chain();
+ };
+
+ // OOP
+ // ---------------
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj) {
+ return this._chain ? _(obj).chain() : obj;
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ var obj = this._wrapped;
+ method.apply(obj, arguments);
+ if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+ return result.call(this, obj);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ return result.call(this, method.apply(this._wrapped, arguments));
+ };
+ });
+
+ _.extend(_.prototype, {
+
+ // Start chaining a wrapped Underscore object.
+ chain: function() {
+ this._chain = true;
+ return this;
+ },
+
+ // Extracts the result from a wrapped and chained object.
+ value: function() {
+ return this._wrapped;
+ }
+
+ });
+
+}).call(this);
\ No newline at end of file
=== added directory 'web_unleashed/static/src'
=== added directory 'web_unleashed/static/src/css'
=== added file 'web_unleashed/static/src/css/pager.css'
--- web_unleashed/static/src/css/pager.css 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/css/pager.css 2013-11-10 13:14:55 +0000
@@ -0,0 +1,4 @@
+.oe_pager_group a.disabled {
+ color: #999;
+ cursor: initial !important;
+}
=== added directory 'web_unleashed/static/src/img'
=== added file 'web_unleashed/static/src/img/icon.png'
Binary files web_unleashed/static/src/img/icon.png 1970-01-01 00:00:00 +0000 and web_unleashed/static/src/img/icon.png 2013-11-10 13:14:55 +0000 differ
=== added directory 'web_unleashed/static/src/js'
=== added directory 'web_unleashed/static/src/js/collections'
=== added file 'web_unleashed/static/src/js/collections/base.js'
--- web_unleashed/static/src/js/collections/base.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/collections/base.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,165 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var BaseModel = base.models('BaseModel');
+
+ var Collection = Backbone.Collection,
+ _super = Collection.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name BaseCollection
+ * @classdesc Base Collection, with OpenERP JSON-RPC API support
+ * @mixes Backbone.Collection
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var BaseCollection = Collection.extend({
+
+ /*
+ * @property {Function} sync use a JSON-RPC API sync method
+ * @see http://backbonejs.org/#Sync
+ */
+ sync: openerp.unleashed.sync,
+
+ /*
+ * @property {String} model_name OpenERP model name, used by the sync function to connect data with the JSON-RPC API
+ */
+ model_name: null,
+
+ /*
+ * @property {Backbone.Model} model default model used to create collection items
+ */
+ model: BaseModel,
+
+ /*
+ * @property {Object} query persistent query merged at search call, use persistent: true in a query parameter to keep it alive
+ */
+ query: {},
+
+ /*
+ * @property {GroupQuery} group_model Model use to populate the Collection with group_by query
+ */
+ group_model: base.models('GroupQuery'),
+
+
+ /*
+ * Check if the collection is grouped
+ *
+ * @returns {Boolean}
+ */
+ grouped: function(){
+ return this.every(function(model){
+ return model instanceof this.group_model;
+ }, this);
+ },
+
+ /*
+ * Get a model by looking in groups,
+ * use the default Collection.get method is the collection is not grouped
+ *
+ * @param {Integer|String|Backbone.Model} id an id, a cid, or by passing in a model
+ * @return {Backbone.Model}
+ */
+ getInGroup: function(id){
+ var collection = this, Model = this.model;
+ if(this.grouped()){
+ var query = this.find(function(model){
+ return model.group.get(id) instanceof Model;
+ });
+ collection = query ? query.group : collection;
+ }
+ return collection.get(id);
+ },
+
+ /*
+ * Count collection model with a JSON-RPC call
+ * no fetching, the deferrer is resolved with the number passed in parameter
+ *
+ * @param {Object} query JSON-RPC API query options
+ * @returns {jQuery.Deferred.promise}
+ */
+ count: function(query){
+ return this.sync('count', this, this.search(query));
+ },
+
+
+ /*
+ * Fetch data, by using the JSON-RPC API
+ * add support of persistent query parameters, useful to keep the search status
+ *
+ * @param {Object} query JSON-RPC API query options
+ * {
+ * filter: [],
+ * order: [] || "",
+ * limit: 1,
+ * offset: 1,
+ * context: {},
+ * persistent: false
+ * }
+ * @returns {jQuery.Deferred.promise}
+ * @see https://doc.openerp.com/trunk/web/rpc/#openerp.web.Query.context
+ */
+ fetch: function(query){
+ // check if the collection can fetch via the JSON-RPC API
+ if(!this.model_name){
+ throw new Error('The collection can not be connected via the API without the model_name property');
+ }
+ // add the QueryGroup model
+ if(query && query.group_by && query.group_by.length > 0){
+ query.group_model = this.group_model;
+ query.silent = false;
+ }
+
+ return _super.fetch.apply(this, [this.search(query)]);
+ },
+
+ /*
+ * Reset persistent query parameters
+ *
+ * @returns {BaseCollection}
+ */
+ resetQuery: function(){
+ this.query = {};
+ return this;
+ },
+
+ /*
+ * Extend a query with custom parameters
+ * Note: override this method to force default query parameters
+ *
+ * @returns {Object} JSON-RPC API query options
+ */
+ search: function(query){
+ query = query || {};
+
+ if(query.persistent){
+ this.query = _.clone(query);
+ }
+
+ return _.extend({}, this.query, query, {
+ // force some query parameters here...
+ });
+ },
+
+
+
+ /*
+ * Auto set the model_name for Model instanciated
+ *
+ * Warning: Backbone API could change, specially method prefixed by an underscore...
+ *
+ * @param {Backbone.Model|Object} attrs model attributes or a Backbone.Model
+ * @param {Object} options options passed at model instanciation
+ * @returns {Backbone.Model|Boolean} the model passed in parameter or created. False if the model is not valid.
+ */
+ _prepareModel: function(attrs, options) {
+ if(typeof this.model.prototype.model_name != 'string'){
+ this.model.prototype.model_name = this.model_name;
+ }
+ return _super._prepareModel.apply(this, arguments);
+ }
+ });
+
+ base.collections('BaseCollection', BaseCollection);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/collections/group.js'
--- web_unleashed/static/src/js/collections/group.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/collections/group.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,232 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone, base){
+
+ var BaseCollection = base.collections('BaseCollection'),
+ _super = BaseCollection.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name Group
+ * @classdesc keep the collection behavior but add a notion of grouped results in data namespace
+ * @mixes BaseCollection, PagerController
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var Group = BaseCollection.extend({
+
+ model_name: null,
+ group_by: null,
+
+ initialize: function(models, options){
+
+ this.options = _.extend({
+ group_by: this.group_by,
+ grouped: false,
+ parent: null,
+ index: null
+ }, options);
+
+ if(!this.options.grouped && !this.group_by){
+ throw new Error('group_by property is required for Group Collection');
+ }
+
+ this.status = {
+ updated: false,
+ created: true
+ };
+
+ this.data = _.extend({
+ groups: {},
+ removed: []
+ }, this.data || {});
+
+
+ // max group length in the collection
+ this.max = 0;
+
+
+ _super.initialize.apply(this, arguments);
+ },
+
+ groupRemoved: function(){
+ return this.data.removed;
+ },
+
+ groupChanged: function(){
+ return _.filter(this.groups(), function(group){ return group.status.created || group.status.updated; });
+ },
+
+ reset: function(){
+ if(!this.isGroup()){
+ this.eachGroup(function(group, index){
+ group.reset();
+ delete this.data.groups[index];
+ }, this);
+ }
+
+ this.max = 0;
+
+ _super.reset.apply(this, arguments);
+ },
+
+
+ fetch: function(){
+
+ if(!this.isGroup()){
+ this.eachGroup(function(group){
+ group.status = {
+ updated: false,
+ created: false
+ };
+ });
+ this.data.removed = [];
+ }
+
+ return _super.fetch.apply(this, arguments);
+ },
+
+
+ set: function(models, options){
+ options = _.extend({
+ group: true
+ }, options);
+
+ //ensure we have an array of Backbone.Model to keep a ref between the collection and groups
+ var singular = !_.isArray(models);
+ models = singular ? (models ? [models] : []) : _.clone(models);
+
+ var prepared = [];
+ _.each(models, function(model){
+ if(model = this._prepareModel(model, options)){
+ prepared.push(model);
+ }
+ }, this);
+
+ _super.set.apply(this, [prepared, options]);
+
+ this.status.updated = true;
+
+ if(options.group){
+ this.groupModels(prepared);
+ }
+ },
+
+ remove: function(models, options){
+ options = _.extend({
+ group: true
+ }, options);
+
+ //TODO: review this "technique"... method to know if a modification has been applied to the collection...
+ var lengths = {};
+ lengths.before = this.length;
+ _super.remove.apply(this, arguments);
+ lengths.after = this.length;
+
+ if(options.group){
+ this.ungroupModels(models, lengths);
+ }
+ },
+
+ isGroup: function(){
+ return this.options.grouped;
+ },
+
+ hasGroup: function(index){
+ return !!this.group(index);
+ },
+
+ group: function(index){
+ return this.data.groups[index];
+ },
+
+ groups: function(){
+ return this.data.groups;
+ },
+
+
+ eachGroup: function(callback, context){
+ return _.each(this.groups(), callback, context);
+ },
+
+
+ groupByIndice: function(model){
+ var indice = null, group_by = this.options.group_by;
+
+ var data = model instanceof Backbone.Model ? model.attributes : model;
+
+ if(_.isString(group_by)){
+ indice = data[group_by];
+ }
+ else if(_.isFunction(group_by)){
+ indice = group_by.apply(this, [data]);
+ }
+ return indice;
+ },
+
+ groupModels: function(models){
+ _.each(models, function(model){
+ var index = this.groupByIndice(model);
+
+ if(!this.isGroup()){
+ if(index){
+ this.addToGroup(model, index);
+ }
+ }
+ else {
+ if(this.options.index != index){
+ throw new Error('can not add a model in a group which has not the same index');
+ }
+ this.options.parent.add(model, {group: false});
+
+ this.options.parent.max = this.length > this.options.parent.max
+ ? this.length : this.options.parent.max;
+ }
+ }, this);
+ },
+
+ addToGroup: function(model, index){
+ var groups = this.data.groups;
+ groups[index] = groups[index] || new Group([], { group_by: this.group_by, grouped: true, parent: this, index: index });
+ groups[index].add(model, {group: false});
+
+ this.max = groups[index].length > this.max
+ ? groups[index].length : this.max;
+ },
+
+ ungroupModels: function(models, lengths){
+ if(!this.isGroup()){
+ this.eachGroup(function(group){
+ group.remove(models, {group: false});
+
+ if(group.length <= 0){
+ this.removeGroup(group.options.index);
+ }
+ }, this);
+ this.recalculateMax();
+ }
+ else if(lengths.before > lengths.after){
+ this.options.parent.remove(models, {group: false});
+ this.options.parent.recalculateMax();
+ }
+ },
+
+ recalculateMax: function(){
+ var max = 0;
+ this.eachGroup(function(group){
+ max = group.length > max ? group.length : max;
+ });
+ this.max = max;
+ },
+
+ removeGroup: function(index){
+ if(this.hasGroup(index)){
+ this.data.removed.push(index);
+ this.data.groups[index].reset();
+ delete this.data.groups[index];
+ }
+ }
+ });
+
+ base.collections('Group', Group);
+
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/collections/iterator.js'
--- web_unleashed/static/src/js/collections/iterator.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/collections/iterator.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,149 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var BaseCollection = base.collections('BaseCollection');
+ var Iterator = base.models('Iterator'),
+ _super = BaseCollection.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name IteratorsCollection
+ * @classdesc Collection with selectable model
+ * @mixes BaseCollection
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var Iterators = BaseCollection.extend({
+
+ /*
+ * @property {Backbone.Model} model default model used to create collection items
+ */
+ model: Iterator,
+
+ /*
+ * - initialize the position to an undefined index
+ * - bind events
+ */
+ initialize: function(){
+ this.current_index = null;
+ this.bind();
+
+ _super.initialize.apply(this, arguments);
+ },
+
+ /*
+ * bind model selection event, used to update the current selected element
+ */
+ bind: function(){
+ this.on('select', this.select, this);
+ },
+
+ /*
+ * unbind all event listeners
+ */
+ unbind: function(){
+ this.off(null, null, this);
+ },
+
+ /*
+ * select a model in the collection
+ *
+ * @param {Backbone.Model} model model to select in the collection
+ */
+ select: function(model){
+ var index = this.indexOf(model);
+ if(index < 0){
+ throw new Error('model can not be found in the collection');
+ }
+ this.current_index = index;
+
+ var previous_selected = this.where({selected: true});
+ if(previous_selected.length > 0){
+ _.each(previous_selected, function(model_selected){
+ model_selected.set({selected: false});
+ });
+ }
+ model.set({selected: true});
+ },
+
+ /*
+ * define the current index based on model index in the collection
+ *
+ * @param {Integer} val model index
+ * @returns {Integer} current selected index
+ */
+ index: function(val){
+ if(val != null){
+ if(!this.at(val)){
+ throw new Error('no item at index ' + val);
+ }
+ this.current_index = val;
+ }
+ if(this.current_index == null){
+ throw new Error('no item have been selected yet.');
+ }
+ return this.current_index;
+
+ },
+
+ /*
+ * get the first model
+ *
+ * @returns {Backbone.Model}
+ */
+ first: function(){
+ return this.at(0);
+ },
+
+ /*
+ * get the last model
+ *
+ * @returns {Backbone.Model}
+ */
+ last: function(){
+ return this.length > 0 ? this.at(this.length - 1) : null;
+ },
+
+ /*
+ * get the current selected model
+ *
+ * @returns {Backbone.Model}
+ */
+ current: function(){
+ return this.current != null ? this.at(this.index()) : null;
+ },
+
+ /*
+ * get the next model, or the first if the selected model is the last
+ *
+ * @returns {Backbone.Model}
+ */
+ next: function() {
+ return this.at((this.index() + 1) % _.size(this));
+ },
+
+ /*
+ * get the previous model, or the last if the selected model is the first
+ *
+ * @returns {Backbone.Model}
+ */
+ prev: function() {
+ var index = this.index() - 1;
+ return this.at(index > -1 ? index : _.size(this) - 1);
+ },
+
+ /*
+ * get all model ids
+ *
+ * @returns {Array}
+ */
+ ids: function(){
+ return this.map(function(model){
+ return model.get('id');
+ });
+ }
+ });
+
+ base.collections('Iterators', Iterators);
+
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/collections/pager.js'
--- web_unleashed/static/src/js/collections/pager.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/collections/pager.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,100 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var BaseCollection = base.collections('BaseCollection'),
+ _superCollection = BaseCollection.prototype;
+
+ var PagerController = base.controllers('Pager'),
+ _superPager = PagerController.prototype;
+
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name PagerCollection
+ * @classdesc Paginated collection, use JSON-RPC API to navigate between pages
+ * @mixes BaseCollection, PagerController
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+
+ /*
+ * inherit from BaseCollection and extends PagerController and BaseCollection prototypes
+ */
+ var MixedPagerCollection = function(){
+ BaseCollection.apply(this, arguments);
+ };
+
+ MixedPagerCollection.prototype = _.extend(
+ Object.create(_superPager),
+ Object.create(_superCollection)
+ );
+
+ MixedPagerCollection.prototype.constructor = MixedPagerCollection;
+ MixedPagerCollection.extend = BaseCollection.extend;
+
+ var PagerCollection = MixedPagerCollection.extend({
+
+ /*
+ * - initialize all extended objects
+ * - bind events
+ */
+ initialize: function(data, options){
+ _superCollection.initialize.apply(this, arguments);
+ _superPager.initialize.apply(this, [options]);
+ },
+
+
+ /*
+ * Override the Pager.checkEnabled
+ * Disable the pager for group_by queries
+ *
+ * @param {Object} query a search query
+ * @returns {Boolean} pager status
+ */
+ checkEnabled: function(query){
+ if(query && query.group_by && query.group_by.length > 0){
+ this.disable();
+ // force query reset
+ query.reset = true;
+ }
+ else {
+ this.enable();
+ }
+ return this.enabled();
+ },
+
+ /*
+ * Proxy between pager controller update method and base collection fetch
+ */
+ update: function(){
+ return _superCollection.fetch.apply(this, arguments);
+ },
+
+ /*
+ * Override the Collection.first method by the Pager Controller one
+ */
+ first: function(){
+ return _superPager.first.apply(this, arguments);
+ },
+
+ /*
+ * Override the Collection.last method by the Pager Controller one
+ */
+ last: function(){
+ return _superPager.last.apply(this, arguments);
+ },
+
+ /*
+ * Get the search query, depending of the current page
+ *
+ * @see PagerController.search
+ */
+ search: function(query){
+ query = _superCollection.search.apply(this, [query]);
+ return _superPager.search.apply(this, [query]);
+ }
+ });
+
+ base.collections('Pager', PagerCollection);
+
+});
\ No newline at end of file
=== added directory 'web_unleashed/static/src/js/controllers'
=== added file 'web_unleashed/static/src/js/controllers/pager.js'
--- web_unleashed/static/src/js/controllers/pager.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/controllers/pager.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,400 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var Controller = Marionette.Controller,
+ _super = Controller.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name PagerController
+ * @classdesc Abtracted Pager Controller, usable by any object able to implement the count and update methods
+ * @mixes Marionette.Controller
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var PagerController = Controller.extend({
+
+ /*
+ * Initialize the pagination
+ *
+ * @param {Object} options used to define the pager behavior
+ * @default
+ * {
+ * ranges: [10, 50, 100, 200, 'All'], // range available, used only by the default pager view
+ * page: 0, // current page (first page is 0)
+ * limit: 100, // number of item by page
+ * total: 0, // count of all pages, automatically updated at init call
+ * nb_pages: 0, // number of pages, automatically updated at init call
+ * }
+ *
+ * be careful to call it from the parent if the object that extend this
+ * controller take other parameters at initialization...
+ */
+ initialize: function(options){
+ this.pager = _.extend({
+ ranges: [10, 50, 100, 200, base._lt('All')],
+ page: 0,
+ limit: 100,
+ total: 0,
+ nb_pages: 0,
+ }, options);
+ },
+
+ /*
+ * This method is called when items have to be refreshed, return a deferrer
+ *
+ * @abstract
+ * @param {Object} query a search query
+ * @returns {jQuery.Deferred.promise}
+ */
+ update: function(query){
+ throw new Error('abstract object, you should implement here the way to get paginated data');
+ },
+
+ /*
+ * This method has to return a deferrer with the count of element in parameter
+ *
+ * @abstract
+ * @param {Object} query a search query
+ * @returns {jQuery.Deferred.promise}
+ */
+ count: function(query){
+ throw new Error('abstract object, you should implement here the way to get count data');
+ },
+
+ /*
+ * Check if the pager is enabled, override this method to define when the pager has to be disabled
+ * This method is executed before the execution of count and update queries
+ *
+ * @param {Object} query a search query
+ * @returns {Boolean} pager status
+ */
+ checkEnabled: function(query){
+ return this.enabled();
+ },
+
+
+ /*
+ * Internal update method, should never be called directly (use abstract method)
+ *
+ * @private
+ * @param {Object} query a search query
+ * @returns {jQuery.Deferred.promise}
+ */
+ _update: function(query){
+ return this.update(query);
+ },
+
+ /*
+ * Internal count method, should never be called directly (use abstract method)
+ *
+ * @private
+ * @param {Object} query a search query
+ * @returns {jQuery.Deferred.promise}
+ */
+ _count: function(query){
+ return this.count(query);
+ },
+
+ /*
+ * Initialize the pager by counting the nb of element to paginate
+ * Note: after promise resolving, the pagination is still not populated with elements
+ *
+ * @param {Object} query search query
+ * @fires ready
+ * @returns {jQuery.Deferred.promise}
+ */
+ init: function(query){
+ query = query || {};
+
+ var def = new $.Deferred();
+
+ if(this.checkEnabled(query)){
+ this._count(query).done(_.bind(function(nb_models){
+ this.changeCount(nb_models).refresh().trigger('ready');
+ def.resolveWith(this);
+ }, this));
+ }
+ else {
+ def.resolveWith(this);
+ }
+
+ return def.promise();
+ },
+
+ /*
+ * Init and load the current page
+ *
+ * @param {Object} query search query
+ * @returns {jQuery.Deferred.promise}
+ */
+ load: function(query){
+ var def = $.Deferred();
+
+ if(this.checkEnabled(query)){
+ this.init(_.clone(query)).done(function(){
+ this._update(_.clone(query)).done(function(){
+ def.resolve();
+ });
+ });
+ }
+ else {
+ this._update(_.clone(query)).done(function(){
+ def.resolve();
+ });
+ }
+
+ return def.promise();
+ },
+
+ /*
+ * Refresh pager parameters, based on the current count and limit
+ *
+ * @returns {PagerController}
+ */
+ refresh: function(){
+ this.pager.nb_pages = Math.ceil(this.pager.total / this.limit());
+
+ if(this.pager.page >= this.pager.nb_pages){
+ this.pager.page = this.pager.nb_pages - 1 >= 0 ? this.pager.nb_pages - 1 : 0;
+ }
+
+ return this;
+ },
+
+ /*
+ * @property {Boolean} isEnabled enable status of the pager
+ */
+ isEnabled: true,
+
+ /*
+ * Disable the pagination
+ */
+ disable: function(){
+ this.isEnabled = false;
+ this.trigger('disable');
+ },
+
+ /*
+ * Enable the pagination
+ */
+ enable: function(){
+ this.isEnabled = true;
+ this.trigger('enable');
+ },
+
+ /*
+ * Check if the pager is enabled
+ *
+ * @returns {Boolean}
+ */
+ enabled: function(){
+ return this.isEnabled;
+ },
+
+ /*
+ * Reset the number of element to paginate
+ *
+ * @param {Number} nb_models element count to paginate
+ * @returns {PagerController}
+ */
+ changeCount: function(nb_models){
+ this.pager.total = nb_models;
+ this.trigger('change change:count', this, this.pager);
+ return this;
+ },
+
+ /*
+ * Change the current limit and update the pager
+ *
+ * @param {Number} limit number of element by page
+ * @param {Object} options {silent: true/false}, if silent option, no pager update automatically done
+ * @fires change, change:limit
+ * @returns {jQuery.Deferred.promise}
+ */
+ changeLimit: function(limit, options){
+ options = options || {};
+ var promise;
+
+ if($.isNumeric(limit)){
+ limit = parseInt(limit);
+ }
+ else {
+ limit = this.pager.total;
+ }
+ this.pager.page = 0;
+ this.pager.limit = limit;
+
+ this.trigger('change change:limit', this, this.pager);
+
+ this.refresh();
+
+ if(options.silent){
+ promise = $.when();
+ }
+ else {
+ promise = this._update();
+ }
+
+ return promise;
+ },
+
+ /*
+ * Get the number of pages
+ *
+ * @returns {Number} nb_pages
+ */
+ nbPages: function(){
+ return this.pager.nb_pages;
+ },
+
+ /*
+ * Get the limit, if not numeric, return the total of elements
+ */
+ limit: function(){
+ // ensure limit is an integer, if possible
+ this.pager.limit = $.isNumeric(this.pager.limit) ? parseInt(this.pager.limit) : this.pager.limit;
+ return !$.isNumeric(this.pager.limit) ? this.pager.total : (this.pager.limit === 0 ? 100 : this.pager.limit);
+ },
+
+ /*
+ * Check if the pager has a previous page
+ * @returns {Boolean}
+ */
+ hasPrevious: function(){
+ return this.refresh().pager.page > 0;
+ },
+
+ /*
+ * Check if the pager has a next page
+ *
+ * @returns {Boolean}
+ */
+ hasNext: function(){
+ return this.refresh().pager.page + 1 < this.nbPages();
+ },
+
+ /*
+ * Check if the pager is on the first page
+ *
+ * @returns {Boolean}
+ */
+ isFirst: function(){
+ return this.pager.page == 0;
+ },
+
+ /*
+ * Check if the pager is on the last page
+ *
+ * @returns {Boolean}
+ */
+ isLast: function(){
+ return this.pager.page == this.pager.nb_pages - 1;
+ },
+
+ /*
+ * First index of the current page
+ *
+ * @returns {Integer}
+ */
+ firstIndex: function(){
+ return (this.pager.page * this.limit()) + 1;
+ },
+
+ /*
+ * Last index of the current page
+ *
+ * @returns {Integer}
+ */
+ lastIndex: function(){
+ var before = this.firstIndex() - 1,
+ next = this.pager.total - before;
+ return next < this.pager.limit ? before + next : before + this.limit();
+ },
+
+
+ /*
+ * Load the first page
+ *
+ * @fires change, change:first
+ * @returns {jQuery.Deferred.promise}
+ */
+ first: function(){
+ var def = null;
+ if(this.enabled() && !this.isFirst()){
+ this.pager.page = 0;
+ this.trigger('change change:first', this, this.pager);
+ def = this._update();
+ }
+ return $.when(def);
+ },
+
+ /*
+ * Load the last page
+ *
+ * @fires change, change:last
+ * @returns {jQuery.Deferred.promise}
+ */
+ last: function(){
+ var def = null;
+ if(this.enabled() && !this.isLast()){
+ this.pager.page = this.pager.nb_pages - 1;
+ this.trigger('change change:last', this, this.pager);
+ def = this._update();
+ }
+ return $.when(def);
+ },
+
+ /*
+ * Load the next page
+ *
+ * @fires change, change:next
+ * @returns {jQuery.Deferred.promise}
+ */
+ next: function(){
+ var def = null;
+ if(this.enabled() && this.hasNext()){
+ this.pager.page += 1;
+ this.trigger('change change:next', this, this.pager);
+ def = this._update();
+ }
+ return $.when(def);
+ },
+
+ /*
+ * Load the previous page
+ *
+ * @fires change, change:previous
+ * @returns {jQuery.Deferred.promise}
+ */
+ prev: function(){
+ var def = null;
+ if(this.enabled() && this.hasPrevious()){
+ this.pager.page -= 1;
+ this.trigger('change change:previous', this, this.pager);
+ def = this._update();
+ }
+ return $.when(def);
+ },
+
+
+ /*
+ * Define the search query according to the current page
+ *
+ * @returns {Object}
+ */
+ search: function(query){
+ if(this.checkEnabled(query)){
+ _.extend(query || {}, {
+ reset: true,
+ limit: this.limit(),
+ offset: this.pager.page * this.limit()
+ });
+ }
+ return query;
+ }
+ });
+
+ base.controllers('Pager', PagerController);
+
+});
\ No newline at end of file
=== added directory 'web_unleashed/static/src/js/core'
=== added file 'web_unleashed/static/src/js/core/unleashed.js'
--- web_unleashed/static/src/js/core/unleashed.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/core/unleashed.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,375 @@
+(function(openerp){
+
+ //FIXME: use Backbone and Underscore in no conflict mode to get the latest version for Unleashed
+ // should be removed when Backbone will be updated on OpenERP core...
+ var LatestBackbone = Backbone.noConflict(),
+ LatestUnderscore = _.noConflict(),
+ Marionette = LatestBackbone.Marionette;
+
+
+ /*
+ * Local helpers to access to objects defined in a module
+ *
+ * @module web_unleashed
+ * @name AttributeAccess
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var AttributeAccess = {
+
+ /*
+ * Add an object to the Class namespace
+ *
+ * @param {String} namespace subnamespace of Class, used to store the object
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ add: function(namespace, name, obj){
+
+ this.Class = this.Class || {};
+ this.Class[namespace] = this.Class[namespace] || {};
+
+ if(obj){
+ this.Class[namespace][name] = obj;
+ }
+
+ return AttributeAccess.get.apply(this, [namespace, name]);
+ },
+
+ /*
+ * Get an object in the Class namespace
+ *
+ * @param {String} namespace subnamespace of Class, used to store the object
+ * @param {String} name name to refer to the object
+ * @returns {Object} the stored object
+ */
+ get: function(namespace, name){
+ var obj = this.Class && this.Class[namespace] && this.Class[namespace][name] ? this.Class[namespace][name] : null;
+ if(!obj){
+ throw new Error('"' + namespace + '.' + name + '" can not be found in module "' + this.moduleName + '"');
+ }
+ return obj;
+ },
+ };
+
+
+ /*
+ * Local helpers to access to OpenERP instance.web method
+ *
+ * @module web_unleashed
+ * @name InstanceWebAccess
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var InstanceWebAccess = {
+ execute: function(name, args){
+ if(!this.methods){
+ throw new Error('the OpenERP instance.web wrapper is not ready yet.');
+ }
+
+ var path = /\./.test(name) ? name.split('.') : [name],
+ object = this.methods, level;
+
+ while(path.length){
+ level = path.shift();
+ if(typeof object[level] == 'object'){
+ object = object[level];
+ }
+ }
+
+ if(typeof object[level] != 'function'){
+ throw new Error(level + ' is not a method from OpenERP instance.web.' + name);
+ }
+ return object[level].apply(object, args);
+ },
+
+ methods: null
+ };
+
+
+ /*
+ * Add useful method to the Marionette.Module.prototype object:
+ * - accessor for object stored in the module namespace
+ * - helpers initialization
+ *
+ * @module web_unleashed
+ * @name Marionette.Module
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ _.extend(Marionette.Module.prototype, {
+
+ /*
+ * Wrap a module initializer and pass useful object to the callback
+ *
+ * @param {readyCallback} callback called when the module is initialized
+ *
+ * @callback readyCallback
+ * @param {Object} instance OpenERP instance, available when a module is ready, @see https://doc.openerp.com/trunk/web/module/#getting-things-done
+ * @param {Object} Underscore Latest version of underscore library, @see http://underscorejs.org/
+ * @param {Object} Backbone Latest version of backbone library, @see http://backbonejs.org/
+ * @param {Object} base the web_unleashed module, useful to inherit from useful basic object (ie. BaseCollection, ...)
+ */
+ ready: function(callback){
+ this.addInitializer(function(options){
+ var instance = options.instance;
+ callback.apply(this, [instance, this, LatestUnderscore, LatestBackbone, this.app.module('web_unleashed')]);
+ });
+ },
+
+
+ /*
+ * Get an object stored in the module namespace
+ *
+ * @param {String} namespace subnamespace of Class, used to store the object
+ * @param {String} name name to refer to the object
+ * @returns {Object} the stored object
+ */
+ get: function(namespace, name){
+ // handle no namespace definition
+ if(!name){
+ name = namespace;
+ namespace = 'Misc';
+ }
+ return AttributeAccess.get.apply(this, [namespace, name]);
+ },
+
+ /*
+ * Set an object stored in the module namespace
+ *
+ * @param {String} namespace subnamespace of Class, used to store the object, if omitted, use "Misc" namespace by default
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ set: function(namespace, name, obj){
+ // handle no namespace definition
+ if(!obj){
+ obj = name;
+ name = namespace;
+ namespace = 'Misc';
+ }
+ return AttributeAccess.add.apply(this, [namespace, name, obj]);
+ },
+
+ /*
+ * Helper: Get/Set an object in module's Models namespace
+ * if obj is passed in parameter, the method will set the object, if not, it will get it
+ *
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ models: function(name, obj){
+ return AttributeAccess.add.apply(this, ['Models', name, obj]);
+ },
+
+ /*
+ * Helper: Get/Set an object in module's Collections namespace
+ *
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ collections: function(name, obj){
+ return AttributeAccess.add.apply(this, ['Collections', name, obj]);
+ },
+
+ /*
+ * Helper: Get/Set an object in module's Views namespace
+ * if obj is passed in parameter, the method will set the object, if not, it will get it
+ *
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ views: function(name, obj){
+ return AttributeAccess.add.apply(this, ['Views', name, obj]);
+ },
+
+ /*
+ * Helper: Get/Set an object in module's Controllers namespace
+ * if obj is passed in parameter, the method will set the object, if not, it will get it
+ *
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ controllers: function(name, obj){
+ return AttributeAccess.add.apply(this, ['Controllers', name, obj]);
+ },
+
+ /*
+ * Helper: Get/Set an object in module's Utils namespace
+ * if obj is passed in parameter, the method will set the object, if not, it will get it
+ *
+ * @param {String} name name to refer to the object
+ * @param {Object} obj the object to store
+ * @returns {Object} the stored object
+ */
+ utils: function(name, obj){
+ return AttributeAccess.add.apply(this, ['Utils', name, obj]);
+ },
+
+ /*
+ * Wrap methods from OpenERP instance.web
+ */
+ _t: function(){ return InstanceWebAccess.execute('_t', arguments); },
+ _lt: function(){ return InstanceWebAccess.execute('_lt', arguments); },
+ render: function(){return InstanceWebAccess.execute('qweb.render', arguments); }
+
+ });
+
+
+ // keep a reference to the original Module.create function
+ var moduleCreate = Marionette.Module.create;
+
+
+ /*
+ * Add useful method to the Marionette.Module object:
+ * - Class namespace to store module's objects
+ * - override create function
+ *
+ * @module web_unleashed
+ * @name Marionette.Module
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ _.extend(Marionette.Module, {
+
+ // @property {Object} Class namespace to store module's objects, useful to split the architecture in different files and keep all organized in on object
+ Class: {},
+
+ /*
+ * Override the create module to autostart it when OpenERP module is ready, @see https://doc.openerp.com/trunk/web/module/#getting-things-done
+ *
+ * @param {Object} app Marionette Application object (openerp.unleashed)
+ * @param {String} moduleNames module name, used for module creation, the name has to be the same has the OpenERP module name
+ * @param {String} moduleDefinition module parameters
+ * @returns {Marionette.Module} the module
+ */
+ create: function(app, moduleNames, moduleDefinition){
+ var module = moduleCreate.apply(this, arguments);
+
+ openerp[moduleNames] = function(instance){
+ module.start({
+ instance: instance
+ });
+ };
+
+ return module;
+ }
+ });
+
+ // null until web_unleashed module is initialized...
+ var sync = null;
+
+ // create the Unleashed Marionette.Application, used to organize modules
+ var Unleashed = openerp.unleashed = new Marionette.Application();
+
+ // called at Unleashed start
+ Unleashed.addInitializer(function(options){
+
+ var module = this.module,
+ app = this;
+
+ /*
+ * Override the module creation function to have all modules in startWithParent false mode
+ *
+ * @param {String} name module name, has to be the same as the OpenERP module name
+ * @param {moduleCallback} callback use to declare new object in the module namespace (executed before module start)
+ * @returns {Marionette.Module} the module instance (singleton)
+ *
+ * @callback moduleCallback
+ * @param {Object} module the module instance (singleton)
+ * @param {Object} Underscore Latest version of underscore library, @see http://underscorejs.org/
+ * @param {Object} Backbone Latest version of backbone library, @see http://backbonejs.org/
+ * @param {Object} base the web_unleashed module, useful to inherit from useful basic object (ie. BaseCollection, ...)
+ */
+ this.module = function(name, callback){
+ var call = function(){
+ this.startWithParent = false;
+ if(callback){
+ callback.apply(this, [this, LatestUnderscore, LatestBackbone, this.app.module('web_unleashed')]);
+ }
+ };
+ return module.apply(app, [name, call]);
+ };
+
+
+ /*
+ * Sync method used by Backbone Model to be connected with data by the JSON-RPC API.
+ * Note: this method is available only when the "web_unleashed" model is initialized
+ *
+ * @param {String} method the Backbone CRUD method ("create", "read", "update", or "delete")
+ * @param {String} model a compatible Backbone.Model|Collection, with at least the "model_name" property set
+ * @param {Object} options JSON-RPC API query
+ * @returns {jQuery.Deferred.promise}
+ */
+ this.sync = function(method, model, options){
+ if(!sync){
+ throw new Error('Model ' + model + ' can not be sync (' + method + ') yet, waiting for OpenERP module initalization...');
+ }
+ else {
+ return sync.apply(this,[ method, model, options ]);
+ }
+ };
+ });
+
+ // start the Unleashed Application
+ Unleashed.start();
+
+ /*
+ * Setup core features required for all modules, but only available from the OpenERP instance object
+ */
+
+ Unleashed.module('web_unleashed').ready(function(instance, base, _, Backbone){
+
+ /*
+ * Setup access to OpenERP instance.web methods
+ */
+ InstanceWebAccess.methods = instance.web;
+
+ /*
+ * Setup the connection with JSON-RPC API for Backbone and define the specific sync method
+ * @see http://doc.openerp.com/trunk/developers/web/rpc/
+ * @see http://backbonejs.org/#Sync
+ */
+ var connection = instance.web.Model;
+ var Connector = base.utils('Connector');
+ sync = function(method, model, options){
+ return Connector[method].apply(Connector, [model, options, connection]);
+ };
+
+ /*
+ * Setup the QWeb rendering method for Backbone.Marionette
+ */
+ var QWeb = instance.web.qweb;
+ Marionette.Renderer.render = function( templateName, data ) {
+ return QWeb.render(templateName, data);
+ };
+
+ /*
+ * Display console.debug message only when OpenERP debug mode is on
+ */
+ console = console || {};
+
+ var console_debug = console.debug || function(){},
+ console_time = console.time || function(){},
+ console_timeEnd = console.timeEnd || function(){};
+
+ if(!instance.session.debug){
+ console.debug = console.time = console.timeEnd = function(){};
+ }
+ else {
+ console.debug = function(){
+ console_debug.apply(console, arguments);
+ };
+ console.time = function(){
+ console_time.apply(console, arguments);
+ };
+ console.timeEnd = function(){
+ console_timeEnd.apply(console, arguments);
+ };
+ }
+
+ });
+
+})(openerp);
\ No newline at end of file
=== added directory 'web_unleashed/static/src/js/models'
=== added file 'web_unleashed/static/src/js/models/base.js'
--- web_unleashed/static/src/js/models/base.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/models/base.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,78 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var _super = Backbone.Model.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name BaseModel
+ * @classdesc Base Model, with OpenERP JSON-RPC API support
+ * @mixes Backbone.Model
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var BaseModel = Backbone.Model.extend({
+
+ /*
+ * @property {Function} sync use a JSON-RPC API sync method
+ * @see http://backbonejs.org/#Sync
+ */
+ sync: openerp.unleashed.sync,
+
+ /*
+ * @property {String} model_name OpenERP model name, used by the sync function to connect data with the JSON-RPC API
+ */
+ model_name: null,
+
+
+
+ /*
+ * Fetch data, by using the JSON-RPC API
+ * Note: the model id has to be set to make it works
+ *
+ * @param {Object} query JSON-RPC API query options (@see https://doc.openerp.com/trunk/web/rpc/#openerp.web.Query.context):
+ * {
+ * filter: [],
+ * order: [] || "",
+ * limit: 1,
+ * offset: 1,
+ * context: {},
+ * persistent: false
+ * }
+ * @returns {jQuery.Deferred.promise}
+ */
+ fetch: function(query){
+ // check if the model can fetch via the JSON-RPC API
+ if(!this.model_name){
+ throw new Error('The model can not be connected via the API without the model_name property');
+ }
+ // check if the model has an id to fetch with
+ if(!this.has('id')){
+ throw new Error('The model ' + this.model_name + ' has no id, impossible to fetch data');
+ }
+ return _super.fetch.apply(this, [this.search(query)]);
+ },
+
+ /*
+ * Extend a query with custom parameters
+ * Note: override this method to force default query parameters
+ *
+ * @returns {Object} JSON-RPC API query options
+ */
+ search: function(query){
+ query = query || {};
+
+ var filter = query.filter || [];
+ if(this.has('id')){
+ filter.push(['id', '=', this.get('id')]);
+ }
+
+ return _.extend({
+ filter: filter,
+ type: 'first'
+ }, query);
+ }
+ });
+
+ base.models('BaseModel', BaseModel);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/models/iterator.js'
--- web_unleashed/static/src/js/models/iterator.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/models/iterator.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,51 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var BaseModel = base.models('BaseModel'),
+ _super = BaseModel.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name Iterator
+ * @classdesc Iterator Model, with selection support
+ * @mixes BaseModel
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var Iterator = BaseModel.extend({
+
+ /*
+ * Force to unselected state at initialization
+ */
+ initialize: function(){
+ this.set({selected: false});
+ _super.initialize.apply(this, arguments);
+ },
+
+ /*
+ * Select a model
+ *
+ * @param {Boolean} force force the selection of a model, even if the model is already selected
+ */
+ select: function(force){
+ if(!this.selected() || force){
+ this.set({
+ selected: true
+ });
+ this.trigger('select', this);
+ }
+ },
+
+ /*
+ * Get the model selection state
+ *
+ * @returns {Boolean} true if selected
+ */
+ selected: function(){
+ return this.get('selected') || false;
+ }
+
+ });
+
+ base.models('Iterator', Iterator);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/models/query.js'
--- web_unleashed/static/src/js/models/query.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/models/query.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,80 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var Model = Backbone.Model,
+ _super = Model.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name QueryGroup
+ * @classdesc OpenERP Group Query Model, used to populate group_by collection
+ * @mixes Backbone.Model
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var GroupQuery = Model.extend({
+
+ /*
+ * get OpenERP GroupQuery instance and
+ * set aggregates attributes on this model
+ */
+ initialize: function(model, options){
+ this.options = options.options;
+ this.groupQuery = options.groupQuery;
+
+ // in case the group value is a ref to a model like [id, name]
+ if(_.isArray(this.get('value')) && this.get('value').length >= 2){
+ this.set('value', this.get('value')[1]);
+ }
+
+ if(this.has('aggregates')){
+ this.set(model.aggregates);
+ this.unset('aggregates');
+ }
+
+ // listen to the add the collection (ensure this.collection is set)
+ this.once('add', this.createCollection, this);
+ },
+
+
+ /*
+ * Create a group collection based on the parent collection constructor.
+ * This collection will be populated with GroupQuery fetch results.
+ */
+ createCollection: function(){
+ var Constructor = this.collection.constructor;
+ this.group = new Constructor();
+ },
+
+
+ /*
+ * Fetch group results into the same type of collection
+ * than the parent of the GroupQuery
+ *
+ * @returns {jQuery.Deferred.promise}
+ */
+ fetch: function(){
+ return this.groupQuery.query(this.options.fields || undefined)
+ .all()
+ .done(_.bind(this.fetched, this));
+ },
+
+ /*
+ * process the fetch result
+ *
+ * @param {Array} results raw fetching results
+ */
+ fetched: function(results){
+ // add results to the group collection
+ this.group.reset(results);
+
+ // fire a special group:sync event directly on the parent
+ this.collection.trigger('group:sync', this, this.group);
+
+ // trick: set an id, so Backbone.Model.isNew method with return true ;)
+ this.id = _.uniqueId();
+ }
+ });
+
+ base.models('GroupQuery', GroupQuery);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/models/state.js'
--- web_unleashed/static/src/js/models/state.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/models/state.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,76 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var _super = Backbone.Model.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name State
+ * @classdesc manage the state of a view, useful to keep the state persistent by using URL parameters
+ * @mixes Backbone.Model
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var State = Backbone.Model.extend({
+
+ /*
+ * @property {Object} defaults URL parameters used by default
+ */
+ defaults: {
+ action: null,
+ menu_id: null,
+ model: null,
+ view_type: null,
+ },
+
+ /*
+ * @abstract
+ * Link some object with the state manager
+ */
+ link: function(){
+ },
+
+ /*
+ * @abstract
+ * Bind linked object events with the state and apply changes to the State model to push URL parameters
+ */
+ bind: function(){
+ },
+
+ /*
+ * @abstract
+ * Unbind listeners on linked objects
+ */
+ unbind: function(){
+ },
+
+ /*
+ * @abstract
+ * Configure linked object based on the current state
+ * @returns {jQuery.Deferred.promise}
+ */
+ process: function(){
+ this.set($.bbq.getState());
+ this.push();
+ return $.when();
+ },
+
+ /*
+ * @abstract
+ * Fire the "change" event to push the current state
+ */
+ push: function(){
+ this.trigger('change', this);
+ },
+
+ /*
+ * Destroy the state model and remove all listeners
+ */
+ destroy: function(){
+ this.unbind();
+ _super.destroy.apply(this, arguments);
+ }
+ });
+
+ base.models('State', State);
+});
\ No newline at end of file
=== added directory 'web_unleashed/static/src/js/utils'
=== added file 'web_unleashed/static/src/js/utils/connector.js'
--- web_unleashed/static/src/js/utils/connector.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/utils/connector.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,312 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+
+ var query = 0;
+
+ var fill = function(number, size) {
+ number = number.toString();
+ while (number.length < size) number = "0" + number;
+ return number;
+ };
+
+ var id = function(){
+ return fill(++query, 3);
+ };
+
+ var log = function(prefix){
+ return function(){
+ var args = _.toArray(arguments);
+ args.unshift('%c' + prefix + ':', 'color: #aaa');
+ console.debug.apply(console, args);
+ };
+ };
+
+ /*
+ * Connector object, interface to manage the sync of data between a Backbone.Model and the OpenERP JSON-RPC API.
+ * Support all CRUD method.
+ *
+ * @module web_unleashed
+ * @name Connector
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var Connector = {
+
+ /*
+ * Direct call to the Python method accessible by an API call
+ *
+ * @param {Backbone.Model} model the model who implement the custom method
+ * @param {Object} options parameters to pass to the Python method accessible by an API call
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ call: function(model, options, connection){
+ var prefix = '[Connector] [ call ] [' + id() + ']' + options.method,
+ logger = log(prefix);
+
+ if(!model.model_name){
+ throw new Error('the OpenERP "model_name" is not defined');
+ }
+
+ console.time(prefix);
+
+ var qdef = new connection(model.model_name).call(options.method, options.args);
+ qdef.done(function(result){
+ if(_.isArray(result)){
+ logger(result.length, 'result(s)', 'on', model.model_name);
+ }
+ else if(_.isNumber(result)){
+ logger(result, 'count', 'on', model.model_name);
+ }
+ else if(_.isObject(result)){
+ logger(result, 'object', 'on', model.model_name);
+ }
+ else {
+ logger('unknown response...', 'on', model.model_name);
+ }
+ });
+
+ return qdef.always(function(){ console.timeEnd('%c' + prefix, 'color: #900;'); });
+ },
+
+ /*
+ * Read model data by using the API
+ *
+ * @param {Backbone.Model} model the model to read
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ read: function(model, options, connection){
+ if(options && !options.type){
+ options.type = 'all';
+ }
+ return this.search(model, options, connection);
+ },
+
+ /*
+ * Count model data by using the API
+ *
+ * @param {Backbone.Model} model the model to count
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ count: function(model, options, connection){
+ options = _.extend(options || {}, {
+ type: 'count'
+ });
+ return this.search(model, options, connection);
+ },
+
+ /*
+ * Read API wrapper, process the options parameters to create a API client Query
+ *
+ * @param {Backbone.Model} model the model to count
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ search: function(model, options, connection){
+ options = options || {};
+
+ if(!model.model_name){
+ throw new Error('the OpenERP "model_name" is not defined for this model');
+ }
+
+ if(options.type && options.type == 'count'){
+ delete options.limit;
+ delete options.offset;
+ delete options.group_by;
+ delete options.order;
+ delete options.fields;
+ }
+
+ var q = new connection(model.model_name).query(options.fields || undefined);
+
+ var log_args = ['model:', model.model_name];
+
+ if(options.type){
+ log_args.push('type:', options.type);
+ }
+ if(options.fields){
+ log_args.push('fields:', options.fields);
+ }
+
+ // handle options has with OpenERP JSON-RPC web methods
+ if(options.filter){
+ q = q.filter(options.filter);
+ log_args.push('filter:', options.filter);
+ }
+ if(options.order){
+ q = $.isArray(options.order) ? q.order_by.apply(q, options.order) : q.order_by(options.order);
+ log_args.push('order:', options.order);
+ }
+ if(options.hasOwnProperty('limit')){
+ q = q.limit(options.limit);
+ log_args.push('limit:', options.limit);
+ }
+ if(options.hasOwnProperty('offset')){
+ q = q.offset(options.offset);
+ log_args.push('offset:', options.offset);
+ }
+ if(options.context){
+ q = q.context(options.context);
+ log_args.push('context:', options.context);
+ }
+
+
+ var def = $.Deferred();
+
+
+ //TODO: change the way group_by is implemented and avoid auto queries on each QueryGroup...
+ if(options.group_by && options.group_by.length > 0 && options.type != 'count'){
+
+ var qdef = q.group_by(options.group_by);
+
+ var prefix = '[Connector][ group ][' + id() + ']',
+ logger = log(prefix);
+
+ console.time(prefix);
+
+ log_args.push('group by:', options.group_by);
+ log_args.unshift('group on');
+
+ logger.apply(console, log_args);
+
+ qdef.done(function(groups){
+ // populate the collection with query groups
+ var queries = [], Query = options.group_model || base.models('GroupQuery');
+ _.each(groups, function(group){
+ queries.push(new Query(group.attributes, {
+ options: options,
+ groupQuery: group
+ }));
+ });
+
+ logger(queries.length, 'group(s)', 'on', model.model_name);
+
+ def.resolve(queries);
+ });
+ qdef.fail(function(){
+ def.reject.apply(def, _.toArray(arguments));
+ });
+ qdef.always(function(){ console.timeEnd(prefix); });
+ }
+ else {
+ var qdef = q[options.type]();
+
+ var prefix = '[Connector][ read ][' + id() + ']',
+ logger = log(prefix);
+
+ console.time(prefix);
+ log_args.unshift('execute on');
+ logger.apply(console, log_args);
+
+ qdef.done(function(result){
+ if(_.isArray(result)){
+ logger(result.length, 'result(s)', 'on', model.model_name);
+ }
+ else if(_.isNumber(result)){
+ logger('count', result, 'model(s) on', model.model_name);
+ }
+ else if(_.isObject(result)){
+ logger(result, 'object', 'on', model.model_name);
+ }
+ else {
+ logger('unknown response...', 'on', model.model_name);
+ }
+ def.resolve.apply(def, _.toArray(arguments));
+ });
+ qdef.fail(function(){
+ def.reject.apply(def, _.toArray(arguments));
+ });
+
+ qdef.always(function(){ console.timeEnd(prefix); });
+ }
+
+ return def.promise().then(options.success, options.error);
+ },
+
+ /*
+ * Create a model by using the API
+ *
+ * @param {Backbone.Model} model the model to create
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ create: function(model, options, connection){
+ var prefix = '[Connector][create][' + id() + ']',
+ logger = log(prefix);
+
+ console.time(prefix);
+ logger('execute on', 'model:', model.model_name, 'data:', model.attributes);
+ var q = new connection(model.model_name);
+ return q.call('create', [ model.attributes ], {context: q.context(options.context) })
+ .done(function(id, status){
+ if(status == "success"){
+ model.set({id: id});
+ }
+ else {
+ throw new Error('failed to save model ' + model.model_name);
+ }
+ logger('done on', 'model:', model.model_name, 'id:', id);
+ })
+ .then(options.success, options.error)
+ .always(function(){ console.timeEnd(prefix); });
+ },
+
+ /*
+ * Update a model by using the API
+ *
+ * @param {Backbone.Model} model the model to update
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ update: function(model, options, connection){
+ var prefix = '[Connector][update][' + id() + ']',
+ logger = log(prefix);
+
+ console.time(prefix);
+ logger('execute on', 'model:', model.model_name, 'id:', model.get('id'));
+ var q = new connection(model.model_name);
+ return q.call('write', [ [ model.get('id') ], model.attributes ], {context: q.context(options.context) })
+ .done(function(id, status){
+ if(status != "success"){
+ throw new Error('failed to save model ' + model.model_name);
+ }
+ logger('done on', 'model:', model.model_name, 'id:', id);
+ })
+ .then(options.success, options.error)
+ .always(function(){ console.timeEnd(prefix); });
+ },
+
+ /*
+ * Delete a model by using the API
+ *
+ * @param {Backbone.Model} model the model to delete
+ * @param {Object} options query parameters
+ * @param {Object} connection OpenERP JSON-RPC API Client
+ * @returns {jQuery.Deferred.promise}
+ */
+ "delete": function(model, options, connection){
+ var prefix = '[Connector][delete][' + id() + ']',
+ logger = log(prefix);
+
+ var model_id = model.get('id');
+ console.time(prefix);
+ logger('execute on', 'model:', model.model_name, 'id:', model_id);
+ var q = new connection(model.model_name);
+ return q.call('unlink', [ model.get('id') ], {context: q.context(options.context) })
+ .done(function(id, status){
+ logger('done on', 'model:', model.model_name, 'id:', model_id);
+ })
+ .then(options.success, options.error)
+ .always(function(){ console.timeEnd(prefix); });
+ },
+ };
+
+ base.utils('Connector', Connector);
+});
\ No newline at end of file
=== added directory 'web_unleashed/static/src/js/views'
=== added file 'web_unleashed/static/src/js/views/base.js'
--- web_unleashed/static/src/js/views/base.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/base.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,82 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ var _super = Backbone.View.prototype;
+
+ /*
+ * @class
+ * @depreciated
+ * @module web_unleashed
+ * @name BaseView
+ * @classdesc Depreciate: use Marionette Views instead. Basic View, with auto unbinding at destruction
+ * @mixes Backbone.View
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var BaseView = Backbone.View.extend({
+
+ /*
+ * Prepare the view:
+ * - set all object in options.ref into a ref property
+ * - define a deferrer to call a start method when the view is ready (at resetElement call...)
+ *
+ *
+ */
+ initialize: function(options){
+ if(options && options.ref){
+ this.ref = options.ref;
+ }
+
+ this.ready = $.Deferred();
+ this.ready.done($.proxy(this.start,this));
+
+ this.bind();
+
+ _super.initialize.apply(this, arguments);
+ },
+
+ /*
+ * Called when the view has a DOM element (resetElement)
+ *
+ * @abstract
+ */
+ start: function(){
+ },
+
+ /*
+ * Bind events
+ *
+ * @abstract
+ */
+ bind: function(){
+ },
+
+ /*
+ * Unbind events
+ *
+ * @abstract
+ */
+ unbind: function(){
+ },
+
+ /*
+ * Reset the view DOM Element
+ */
+ resetElement: function(){
+ this.setElement.apply(this, arguments);
+ this.ready.resolveWith(this);
+ },
+
+ /*
+ * Destroy the view, unbind and detach the DOM element
+ */
+ destroy: function(){
+ this.unbind();
+ this.undelegateEvents();
+ this.$el.removeData().unbind();
+ this.remove();
+ }
+ });
+
+ base.views('BaseView', BaseView);
+
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/views/pager.js'
--- web_unleashed/static/src/js/views/pager.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/pager.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,124 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+
+ var PagerController = base.controllers('Pager');
+
+ var ItemView = Backbone.Marionette.ItemView,
+ _super = ItemView.prototype;
+
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name PagerView
+ * @classdesc Display a Pager, similar than the OpenERP default pager on list
+ * @mixes BaseView
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var PagerView = ItemView.extend({
+
+ template: 'Base.Pager',
+
+ /*
+ * @property {String} className the class used to create the main pager DOM Element
+ */
+ className: 'unleashed-pager',
+
+
+ /*
+ * @property {Object} events DOM listeners
+ */
+ events: {
+ 'click .prev-page': 'previous',
+ 'click .next-page': 'next',
+ 'click .range-page': 'range',
+ 'change .range-selector': 'rangeChanged'
+ },
+
+ /*
+ * Set the model to work on
+ *
+ * @param {Object} options pass the model to work on
+ */
+ initialize: function(options){
+ // TODO: check because extending views are using options.model instead of options.collection (see dashboard/widgets/pager),
+ // should not be done because of a specific pager view...
+
+ this.data = options.collection ? options.collection : ( options.model ? options.model : null);
+ if(!this.data){
+ throw new Error('The Pager view has to be initialized with a model or a collection.');
+ }
+ },
+
+ /*
+ * Listen to data event to render the pager
+ */
+ onShow: function(){
+ this.listenTo(this.data, 'sync reset change', this.render);
+ },
+
+
+ /*
+ * Serialize pager data
+ *
+ * @returns {Object}
+ */
+ serializeData: function(){
+ var disabled = this.data.pager.nb_pages <= 1 ? true : false;
+ disabled = _.isFunction(this.data.grouped) ? this.data.grouped() : disabled;
+
+ return {
+ ranges: this.data.pager.ranges,
+ current_range: this.data.pager.limit,
+
+ firstIndex: this.data.firstIndex(),
+ lastIndex: this.data.lastIndex(),
+ total: this.data.pager.total,
+
+ disabled: disabled,
+ previous: this.data.hasPrevious(),
+ next: this.data.hasNext(),
+ };
+ },
+
+
+ // UI event
+
+ /*
+ * Go to previous page on the model
+ */
+ previous: function(){
+ this.data.prev();
+ },
+
+ /*
+ * Go to next page on the model
+ */
+ next: function(){
+ this.data.next();
+ },
+
+ /*
+ * Render the pager limit selector
+ */
+ range: function(e){
+ var $range = $(e.currentTarget);
+
+ $range.html(base.render('Base.Pager.range', {
+ ranges: this.data.pager.ranges,
+ current_range: this.data.pager.limit
+ }));
+ },
+
+ /*
+ * Change the pager limit
+ */
+ rangeChanged: function(e){
+ var $selector = $(e.currentTarget);
+ this.data.changeLimit($selector.val());
+ }
+ });
+
+ base.views('Pager', PagerView);
+});
=== added file 'web_unleashed/static/src/js/views/panel.js'
--- web_unleashed/static/src/js/views/panel.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/panel.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,42 @@
+openerp.unleashed.module('web_unleashed',function(base, _, Backbone, base){
+
+ var Region = base.views('Region');
+
+ var Layout = Backbone.Marionette.Layout,
+ _superLayout = Layout.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name PanelLayout
+ * @classdesc give Marionette.Layout access to all OpenERP view elements
+ * @mixes Marionette.Layout
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var PanelLayout = Layout.extend({
+
+ regionType: Region,
+
+ /*
+ * Setup regions based on options parameters
+ *
+ * @param {Object} options Layout option, pass all elements used by to build regions
+ */
+ initialize: function(options){
+ _superLayout.initialize.apply(this, arguments);
+
+ if(options.regions){
+ _(options.regions).each(function($element, name){
+ if($element instanceof jQuery && $element.length == 1){
+ this.addRegion(name, new Region({
+ el: $element
+ }));
+ }
+ }, this);
+ }
+ }
+ });
+
+ base.views('Panel', PanelLayout);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/views/region.js'
--- web_unleashed/static/src/js/views/region.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/region.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,53 @@
+openerp.unleashed.module('web_unleashed',function(base, _, Backbone, base){
+
+ var Region = Backbone.Marionette.Region,
+ _superRegion = Region.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name OpenRegion
+ * @classdesc Marionette Region build with existing jQuery element
+ * @mixes Marionette.Region
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var OpenRegion = Region.extend({
+
+ /*
+ * Set the region element based on $el parameter
+ *
+ * @param {Object} options Region option, options.$el is required
+ */
+ initialize: function(options){
+ if(this.el instanceof jQuery && this.el.length == 1){
+ this.$el = this.el;
+ }
+ },
+
+ /*
+ * Set the current region has the view element (avoid unnecessary DOM level)
+ *
+ * @param {Backbone.View} view the view to show in the region
+ */
+ directShow: function(view){
+ this.ensureEl();
+ view.setElement(this.$el);
+ this.attachView(view);
+
+ return _superRegion.show.apply(this, arguments);
+ },
+
+ /*
+ * Open a view in a Region only if the view has a different el than the region
+ */
+ open: function(view){
+ if(view.$el.get(0) != this.$el.get(0)){
+ _superRegion.open.apply(this, arguments);
+ }
+ }
+
+ });
+
+ base.views('Region', OpenRegion);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/views/unleashed.js'
--- web_unleashed/static/src/js/views/unleashed.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/unleashed.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,166 @@
+openerp.unleashed.module('web_unleashed').ready(function(instance, base, _, Backbone){
+
+ var View = instance.web.View,
+ _super = instance.web.View.prototype;
+
+ /*
+ * @class
+ * @module web_unleashed
+ * @name UnleashedView
+ * @classdesc Common operations simplifying the use of OpenERP Views
+ * @mixes instance.web.View
+ *
+ * @author Michel Meyer <michel[at]zazabe.com>
+ */
+ var UnleashedView = View.extend({
+
+ /*
+ * @property {Marionette.Module} mainly used as a event proxy, required to reset it
+ */
+ module: base,
+
+ /*
+ * @property {Marionette.Panel} default panel initialized
+ */
+ Panel: base.views('Panel'),
+
+ /*
+ * @property {Backbone.Model} default state manager model, change it to support custom state in your app
+ */
+ State: base.models('State'),
+
+ /*
+ * Initialize the View, called by OpenERP ViewManager
+ */
+ init: function(parent, dataset, view_id, options) {
+ this._super(parent, dataset, view_id, options);
+ this.context = dataset.get_context().eval();
+ this.on('view_loaded', this, this.ready);
+ },
+
+ /*
+ * Implement this method to do some actions when the view is ready
+ */
+ ready: function(data){},
+
+ /*
+ * Configure the view state
+ */
+ stateConfig: function(){},
+
+ /*
+ * Executed when the Unleashed View has been injected in the DOM
+ */
+ view_loading: function(data){
+ this.panel = new this.Panel({
+ el: $('.oe_application'),
+
+ regions: {
+ pager: this.options.$pager,
+ buttons: this.options.$buttons,
+ sidebar: this.options.$sidebar,
+ body: this.$el
+ }
+ });
+
+ var def = $.Deferred();
+ $.when(this._super(data)).done(_.bind(function(){
+ // setup the view state
+ this.stateInit().done(_.bind(function(){
+ this.stateChanged();
+ this.bindView();
+ def.resolve();
+ }, this));
+
+ }, this));
+
+ return def.promise();
+ },
+
+ /*
+ * Initialize the view state with current URL parameters and process it
+ */
+ stateInit: function(){
+ var data = $.bbq.getState();
+ _(data).each(function(val, name){
+ data[name] = $.isNumeric(val) ? parseInt(val) : val;
+ });
+ this.state = new this.State(data);
+ this.stateConfig();
+ return this.state.process();
+ },
+
+ /*
+ * Bind some default events, managing state changes and redirection
+ */
+ bindView: function(){
+ this.module.on('do:action', this.do_action, this);
+ this.module.on('open:record', this.openRecord, this);
+ this.module.on('open:list', this.openList, this);
+ this.module.on('state:change', this.stateChanged, this);
+ this.state.on('change', this.stateChanged, this);
+ },
+
+ /*
+ * Remove view listeners
+ */
+ unbindView: function(){
+ this.module.off(null, null, this);
+ this.state.off(null, null, this);
+ },
+
+ /*
+ * Push state changes into the URL
+ */
+ stateChanged: function(){
+ this.do_push_state(this.state.attributes);
+ },
+
+
+ /*
+ * Redirect to a form view on a specific record
+ *
+ * @param {String} model_name record model name
+ * @param {Integer} id record id
+ */
+ openRecord: function(model_name, id){
+ this.do_action({
+ type: 'ir.actions.act_window',
+ res_model: model_name,
+ res_id: id,
+ views: [[false, 'form']],
+ target: 'current',
+ context: this.context,
+ });
+ },
+
+ /*
+ * Redirect to a list view on a specific model
+ *
+ * @param {String} model_name record model name
+ */
+ openList: function(model_name){
+ this.do_action({
+ type: 'ir.actions.act_window',
+ res_model: model_name,
+ views: [[false, 'form']],
+ target: 'current',
+ context: this.context,
+ });
+ },
+
+ /*
+ * Properly destroy the view by stopping regions in the panel layout
+ */
+ destroy: function() {
+ this.unbindView();
+
+ if(this.panel && this.panel.regionManager){
+ this.panel.regionManager.closeRegions();
+ }
+ return this._super();
+ }
+ });
+
+ base.views('Unleashed', UnleashedView);
+});
\ No newline at end of file
=== added file 'web_unleashed/static/src/js/views/view.js'
--- web_unleashed/static/src/js/views/view.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/js/views/view.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,19 @@
+openerp.unleashed.module('web_unleashed',function(base, _, Backbone, base){
+
+ /*
+ * FIXBUG: https://github.com/marionettejs/backbone.marionette/pull/533
+ * CompositeView attempts to appendHtml of itemViews before itemViewContainer exists (before template is rendered)
+ */
+ _.extend(Backbone.Marionette.CompositeView.prototype, {
+ _initialEvents: function() {
+ this.once('render', function() {
+ if (this.collection) {
+ this.listenTo(this.collection, "add", this.addChildView, this);
+ this.listenTo(this.collection, "remove", this.removeItemView, this);
+ this.listenTo(this.collection, "reset", this._renderChildren, this);
+ }
+ }, this);
+ }
+ });
+
+});
\ No newline at end of file
=== added directory 'web_unleashed/static/src/templates'
=== added file 'web_unleashed/static/src/templates/base.xml'
--- web_unleashed/static/src/templates/base.xml 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/templates/base.xml 2013-11-10 13:14:55 +0000
@@ -0,0 +1,9 @@
+<template>
+
+
+ <!--
+ Empty template, useful for ItemView without element inside
+ -->
+ <t t-name="Base.Empty"></t>
+
+</template>
\ No newline at end of file
=== added file 'web_unleashed/static/src/templates/pager.xml'
--- web_unleashed/static/src/templates/pager.xml 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/templates/pager.xml 2013-11-10 13:14:55 +0000
@@ -0,0 +1,41 @@
+<template>
+
+ <!--
+ Pager view, based on default OpenERP pager
+ -->
+ <t t-name="Base.Pager">
+ <div class="oe_list_pager" colspan="3" style="">
+ <div class="range-page oe_pager_value">
+ <t t-if="!disabled">
+ <span class="oe_list_pager_state"><t t-esc="firstIndex" /> - <t t-esc="lastIndex" /> / <t t-esc="total" /></span>
+ </t>
+ </div>
+ <ul class="oe_pager_group">
+ <li>
+ <!-- could be simpler but QWeb and & char are not good friend (...) -->
+ <a t-att-class="'oe_i prev-page' + (previous ? (!disabled ? '' : ' disabled') : ' disabled')"
+ data-pager-action="previous"
+ type="button">(</a>
+ </li>
+ <li>
+ <a t-att-class="'oe_i next-page' + (next ? (!disabled ? '' : ' disabled') : ' disabled')"
+ data-pager-action="next"
+ type="button">)</a>
+ </li>
+ </ul>
+ </div>
+
+ </t>
+
+ <!--
+ Pager limit selector view
+ -->
+ <t t-name="Base.Pager.range">
+ <select class="range-selector">
+ <t t-foreach="ranges" t-as="range">
+ <option t-att-value="range" t-att-selected="(range == current_range ? 'selected' : undefined)"><t t-esc="range" /></option>
+ </t>
+ </select>
+ </t>
+
+</template>
\ No newline at end of file
=== added directory 'web_unleashed/static/src/tests'
=== added file 'web_unleashed/static/src/tests/connector.js'
--- web_unleashed/static/src/tests/connector.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/tests/connector.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,226 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ openerp.testing.section('JSON-RPC Backbone Sync Connector', function (test) {
+
+ var Connector = base.utils('Connector');
+ var connection = null;
+ var sync = function(method, model, options){
+ return Connector[method].apply(Connector, [model, options, connection]);
+ };
+
+ test('fetch', {templates: false, rpc: 'mock', asserts: 2}, function (instance, $fixture, mock) {
+
+ //fake response to JSON-RPC call
+ mock('/web/dataset/search_read', function (call) {
+ //return 100 items by default
+ var result = [];
+ for(var i=1 ; i <= 100 ; i++){
+ result.push({id: i, name: 'item ' + i});
+ }
+
+ return { records: result };
+
+
+ });
+
+ connection = instance.web.Model;
+
+ var List = Backbone.Collection.extend({
+ sync: sync,
+ model_name: 'unit.test',
+ });
+
+ var list = new List();
+
+ return list.fetch().done(function(results){
+ strictEqual(list.length, 100, '100 should be fetched');
+ strictEqual(list.get(42).get('name'), 'item 42', '42nd item should be named "item 42"');
+ });
+ });
+
+ test('fetch with filter', {templates: false, rpc: 'mock', asserts: 6}, function (instance, $fixture, mock) {
+
+ mock('/web/dataset/search_read', function (call) {
+ var result = [];
+
+ var offset = call.params.offset ? call.params.offset : 1;
+ var limit = call.params.limit ? call.params.limit : 100;
+ var reverse = !!(call.params.sort && call.params.sort != '');
+ var domain = call.params.domain.length > 0 ? call.params.domain[0] : null;
+
+ if(reverse){
+ var _offset = offset;
+ offset = limit;
+ limit = _offset;
+ }
+
+ for(var i = offset ; (reverse ? i >= limit : i <= (offset + limit) - 1) ; (reverse ? i-- : i++)){
+ if(!domain
+ || domain && domain[1] == '=' && domain[2] == i
+ || domain && domain[1] == '<=' && domain[2] >= i){
+ result.push({id: i, name: 'item ' + i});
+ }
+ }
+
+ return { records: result };
+ });
+
+
+ connection = instance.web.Model;
+
+ var List = Backbone.Collection.extend({
+ sync: sync,
+ model_name: 'unit.test',
+ });
+
+ var list = new List();
+
+ var t1 = list.fetch({
+ filter: [['id', '=', '42']]
+ })
+ .done(function(results){
+ strictEqual(list.length, 1, '1 item should be fetched');
+ strictEqual(list.at(0).get('name'), 'item 42', 'first item should be named "item 42"');
+ });
+
+ var t2 = list.fetch({
+ filter: [['id', '<=', '42']],
+ order: ['-id']
+ }).done(function(results){
+ strictEqual(list.length, 42, '42 items should be fetched');
+ strictEqual(list.at(0).get('name'), 'item 42', 'first item should be named "item 42"');
+ });
+
+ var t3 = list.fetch({
+ limit: 10,
+ offset: 42
+ }).done(function(results){
+ strictEqual(list.length, 10, '10 items should be fetched');
+ strictEqual(list.at(0).get('name'), 'item 42', 'first item should be named "item 42"');
+ });
+
+ return $.when(t1, t2, t3);
+ });
+
+ test('fetch with group_by', { templates: false, rpc: 'mock', asserts: 21 }, function (instance, $fixture, mock) {
+
+ var GroupQuery = instance.web.GroupQuery,
+ Query = base.models('GroupQuery');
+
+ //fake response to JSON-RPC call
+ var group_mock = function(call){
+ if(call.params.method == 'read_group'){
+ var arg = call.params.kwargs;
+ }
+ // fake group by, return 2 groups
+ return [
+ { category: 'cat1', count: 5, __domain: [[ 'category', '=', 'cat1' ]] },
+ { category: 'cat2', count: 10, __domain: [[ 'category', '=', 'cat2' ]] }];
+ };
+
+ // define 2 mocks, for prod and dev mode...
+ mock('/web/dataset/call_kw', group_mock);
+ mock('/web/dataset/call_kw/unit.test:read_group', group_mock);
+
+
+ mock('/web/dataset/search_read', function (call) {
+ var result = [];
+
+ var domain = call.params.domain[0][2],
+ offset = 0,
+ limit = 0;
+
+ if(domain == 'cat1'){
+ limit = 5;
+ }
+ else if(domain == 'cat2'){
+ offset = 5;
+ limit = 15;
+ }
+ else if(domain == 'not grouped'){
+ limit = 15;
+ }
+
+ for(var i = offset ; i < limit ; i++){
+ result.push({id: i, name: 'item ' + i, category: domain});
+ }
+
+ return { records: result };
+ });
+
+ connection = instance.web.Model;
+
+ var List = Backbone.Collection.extend({
+ sync: sync,
+ model_name: 'unit.test',
+ });
+
+ var def1 = $.Deferred();
+ var list = new List();
+
+ var t1 = list.fetch({
+ group_by: ['category']
+ }).done(function(results){
+ strictEqual(list.length, 2, '2 group queries');
+
+ strictEqual(list.at(0).get('value'), 'cat1', 'query group 1: category = cat1');
+ strictEqual(list.at(0).get('count'), 5, 'query group 1: 5 elements');
+
+ strictEqual(list.at(1).get('value'), 'cat2', 'query group 2: category = cat2');
+ strictEqual(list.at(1).get('count'), 10, 'query group 2: 10 elements');
+
+ var q1 = list.at(0), q2 = list.at(1);
+
+ var p1 = q1.fetch().done(function(){
+ strictEqual(q1.group instanceof List, true, 'group 1: is instance of List');
+ strictEqual(q1.group.length, 5, 'group 1: 5 group results');
+ strictEqual(q1.group.at(1).get('name'), 'item 1', 'group 1: correct name for 2nd group model');
+ strictEqual(q1.group.at(2).get('category'), 'cat1', 'group 1: correct category for 3nd group model');
+ strictEqual(q1.group.at(3).get('id'), 3, 'group 1: correct id for 4st group model');
+ });
+
+ var p2 = q2.fetch().done(function(){
+ strictEqual(q2.group instanceof List, true, 'group 2: is instance of List');
+ strictEqual(q2.group.length, 10, 'group 2: 10 group results');
+ strictEqual(q2.group.at(1).get('name'), 'item 6', 'group 2: correct name for 2nd group model');
+ strictEqual(q2.group.at(2).get('category'), 'cat2', 'group 2: correct category for 3nd group model');
+ strictEqual(q2.group.at(3).get('id'), 8, 'group 2: correct id for 4st group model');
+ });
+
+ $.when(p1, p2).done(function(){
+ def1.resolve();
+ });
+ });
+
+ var CustomQuery = Query.extend({
+ customGroupQueryMethod: function(){}
+ });
+
+ var t2 = list.fetch({
+ group_by: ['category'],
+ group_model: CustomQuery
+ })
+ .done(function(){
+ strictEqual(list.length, 2, '2 group queries');
+ strictEqual(list.at(0) instanceof CustomQuery, true, 'query group 1: is instance of CustomQuery');
+ strictEqual(list.at(1) instanceof CustomQuery, true, 'query group 2: is instance of CustomQuery');
+ strictEqual(_.isFunction(list.at(1).customGroupQueryMethod), true, 'query group 2: implement the custom method');
+ });
+
+
+ // test in without group_by again
+ var t3 = list.fetch({
+ filter: [['category', '=', 'not grouped']]
+ })
+ .done(function(){
+ strictEqual(list.length, 15, '15 items');
+ strictEqual(list.at(0) instanceof Query, false, 'first item is not an instance of Query');
+ });
+
+ return $.when(def1.promise(), t2, t3);
+ // test end
+ });
+
+ // section end
+ });
+});
=== added file 'web_unleashed/static/src/tests/group.js'
--- web_unleashed/static/src/tests/group.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/tests/group.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,250 @@
+openerp.unleashed.module('web_unleashed', function(base, _, Backbone){
+
+ openerp.testing.section('Group Collection', function (test) {
+
+ var Group = base.collections('Group');
+
+ test('fetch', {templates: false, rpc: 'mock', asserts: 50 }, function (instance, $fixture, mock) {
+
+ var nb_records = 105, nb_groups = 10;
+
+ //fake response to JSON-RPC call
+ mock('/web/dataset/search_read', function (call) {
+ var result = [], item_id = null;
+
+ for(var i= 1 ; i <= nb_records ; i++){
+ item_id = i % 10 == 0 ? 10 : i % 10;
+ result.push({id: i, name: 'item ' + i, item_id: item_id, str: 'item ' + item_id});
+ }
+
+ return { records: result };
+ });
+
+ // group by id
+
+ var def1 = $.Deferred();
+
+ var List1 = Group.extend({
+ model_name: 'unit.test',
+ group_by: 'item_id'
+ });
+
+ var list = new List1();
+
+ list.fetch().done(function(){
+ strictEqual(_.size(list.groups()), 10, 'collection has 10 groups');
+
+ strictEqual(list.isGroup(), false, 'list is not a group');
+ strictEqual(list.group(1).isGroup(), true, 'group 1 is a group');
+
+ strictEqual(list.group(1).length, 11, 'group with id 1 has 11 models');
+ strictEqual(list.group(10).length, 10, 'group with id 10 has 10 models');
+ strictEqual(list.group(10) instanceof Group, true, 'group 10 is an instance of Group');
+ strictEqual(list.group(10).where({name: 'item 20'}).length, 1, 'group 10 has a model named item 20');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ list.get(1).set({name: 'override name 1'});
+ strictEqual(list.get(1).get('name'), 'override name 1', 'reference is kept with the added model on the list');
+ strictEqual(list.group(1).get(1).get('name'), 'override name 1', 'reference is kept with the added model on the group');
+
+
+ var model1 = new Backbone.Model({
+ id: nb_records + 1,
+ name: 'item ' + (nb_records + 1),
+ item_id: 1
+ });
+ list.push(model1);
+
+ strictEqual(list.group(1).length, 12, 'group 1 has 12 models');
+
+ strictEqual(list.max, 12, 'collection group max size is 12');
+
+
+ var model2 = new Backbone.Model({
+ id: nb_records + 2,
+ name: 'item ' + (nb_records + 2),
+ item_id: 11
+ });
+ list.push(model2);
+
+ strictEqual(list.group(11).length, 1, 'group 11 has 1 model');
+
+ list.remove(model1);
+
+ strictEqual(list.group(1).length, 11, 'group 1 has 11 models');
+
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ list.remove(model2);
+
+ strictEqual(list.hasGroup(11), false, 'group 11 does not exist anymore');
+
+ list.group(1).push(model1);
+
+ strictEqual(list.group(1).length, 12, 'on model added to group 1, 12 models');
+ strictEqual(list.length, 106, 'list has 105 models + the model added to the group');
+
+ strictEqual(list.max, 12, 'collection group max size is 12');
+
+
+
+ model1.set({name: 'override name 2'});
+ strictEqual(list.get(106).get('name'), 'override name 2', 'reference is kept with the added model on the list');
+ strictEqual(list.group(1).get(106).get('name'), 'override name 2', 'reference is kept with the added model on the group');
+
+ list.group(1).remove(model1);
+
+ strictEqual(list.group(1).length, 11, 'on model removed from group 1, 11 models');
+ strictEqual(list.length, 105, 'list has 105 models again');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ var catched = false;
+ try {
+ list.group(1).push(model2);
+ }
+ catch(e){
+ catched = true;
+ }
+ strictEqual(catched, true, 'exception catched when a model is added to a group with a different index');
+
+ def1.resolve();
+ });
+
+ // group by string
+
+ var def2 = $.Deferred();
+
+ var List2 = Group.extend({
+ model_name: 'unit.test',
+ group_by: 'str'
+ });
+
+ var list = new List2();
+
+ list.fetch().done(function(){
+
+ strictEqual(_.size(list.groups()), 10, 'collection has 10 groups');
+
+ strictEqual(list.group('item 1').length, 11, 'group with id 1 has 11 models');
+ strictEqual(list.group('item 10').length, 10, 'group with id 10 has 10 models');
+ strictEqual(list.group('item 10') instanceof Group, true, 'group 10 is an instance of Group');
+ strictEqual(list.group('item 10').where({name: 'item 20'}).length, 1, 'group 10 has a model named item 20');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+
+ var model1 = new Backbone.Model({
+ id: nb_records + 1,
+ name: 'item ' + (nb_records + 1),
+ item_id: 1,
+ str: 'item ' + 1
+ });
+ list.push(model1);
+
+ strictEqual(list.group('item 1').length, 12, 'group "item 10" has 12 models');
+
+ strictEqual(list.max, 12, 'collection group max size is 12');
+
+
+ var model2 = new Backbone.Model({
+ id: nb_records + 2,
+ name: 'item ' + (nb_records + 2),
+ item_id: 11,
+ str: 'item ' + 11
+ });
+ list.push(model2);
+
+ strictEqual(list.group('item 11').length, 1, 'group "item 11" has 1 model');
+
+ list.remove(model1);
+
+ strictEqual(list.group('item 1').length, 11, 'group "item 1" has 11 models');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ def2.resolve();
+ });
+
+
+ // group by function
+
+ var def3 = $.Deferred();
+
+ var List3 = Group.extend({
+ model_name: 'unit.test',
+ group_by: function(model){
+ return model.str;
+ }
+ });
+
+ var list = new List3();
+
+ list.fetch().done(function(){
+
+ strictEqual(_.size(list.groups()), 10, 'collection has 10 groups');
+
+ strictEqual(list.group('item 1').length, 11, 'group with id 1 has 11 models');
+ strictEqual(list.group('item 10').length, 10, 'group with id 10 has 10 models');
+ strictEqual(list.group('item 10') instanceof Group, true, 'group 10 is an instance of Group');
+ strictEqual(list.group('item 10').where({name: 'item 20'}).length, 1, 'group 10 has a model named item 20');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ var model1 = new Backbone.Model({
+ id: nb_records + 1,
+ name: 'item ' + (nb_records + 1),
+ item_id: 1,
+ str: 'item ' + 1
+ });
+ list.push(model1);
+
+ strictEqual(list.group('item 1').length, 12, 'group "item 10" has 12 models');
+
+ strictEqual(list.max, 12, 'collection group max size is 12');
+
+
+ var model2 = new Backbone.Model({
+ id: nb_records + 2,
+ name: 'item ' + (nb_records + 2),
+ item_id: 11,
+ str: 'item ' + 11
+ });
+ list.push(model2);
+
+ strictEqual(list.group('item 11').length, 1, 'group "item 11" has 1 model');
+
+ list.remove(model1);
+
+ strictEqual(list.group('item 1').length, 11, 'group "item 1" has 11 models');
+
+ strictEqual(list.max, 11, 'collection group max size is 11');
+
+
+ list.reset();
+
+ strictEqual(_.size(list.groups()), 0, 'reset: no more groups');
+ strictEqual(list.length, 0, 'reset: no more models');
+ strictEqual(list.max, 0, 'collection group max size is 0');
+
+
+
+ def3.resolve();
+ });
+
+
+
+ return $.when(def1, def2, def3);
+ });
+
+ });
+
+});
=== added file 'web_unleashed/static/src/tests/pager.js'
--- web_unleashed/static/src/tests/pager.js 1970-01-01 00:00:00 +0000
+++ web_unleashed/static/src/tests/pager.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,274 @@
+openerp.unleashed.module('web_unleashed').ready(function(instance, base, _, Backbone){
+
+ var Pager = base.collections('Pager');
+
+ openerp.testing.section('Pager Collection', function (test) {
+
+ var Connector = base.utils('Connector');
+ var connection = null;
+ var sync = function(method, model, options){
+ return Connector[method].apply(Connector, [model, options, connection]);
+ };
+ var List = Pager.extend({
+ model_name: 'unit.test',
+ sync: sync,
+ });
+
+
+ test('fetch', {templates: false, rpc: 'mock', asserts: 79 }, function (instance, $fixture, mock) {
+
+ connection = instance.web.Model;
+
+ var nb_records = 123;
+
+ //fake response to JSON-RPC call
+ mock('/web/dataset/search_read', function (call) {
+ var result = [],
+ nb_before = call.params.offset,
+ nb_next = nb_records - nb_before,
+ limit = nb_next < call.params.limit ? nb_before + nb_next : nb_before + call.params.limit;
+
+ for(var i= nb_before + 1 ; i <= limit ; i++){
+ result.push({id: i, name: 'item ' + i});
+ }
+
+ return { records: result };
+ });
+
+
+ //fake response to JSON-RPC call
+ var group_mock = function(call){
+ if(call.params.method == 'read_group'){
+ return [
+ { category: 'cat1', count: 5, __domain: [[ 'category', '=', 'cat1' ]] },
+ { category: 'cat2', count: 10, __domain: [[ 'category', '=', 'cat2' ]] }];
+ }
+ else if(call.params.method == 'search_count'){
+ return nb_records;
+ }
+ };
+
+ // define 2 mocks, for prod and dev mode...
+ mock('/web/dataset/call_kw', group_mock);
+ mock('/web/dataset/call_kw/unit.test:read_group', group_mock);
+ mock('/web/dataset/call_kw/unit.test:search_count', group_mock);
+
+ var list = new List();
+
+
+ //helper to call deferred in a chain
+ var stack = {
+ current: 0,
+ obj: list,
+ calls: [],
+ def: $.Deferred(),
+ add: function(method, params, callback){
+ this.calls.push({
+ method: method,
+ params: typeof params == 'function' ? [] : params,
+ callback: typeof params == 'function' ? params : (callback || function(){})
+ });
+ return this;
+ },
+ exec: function(){
+ this.next();
+ return this.def.promise();
+ },
+ next: function(){
+ var call = stack.calls.shift();
+ if(call){
+ var def = list[call.method].apply(list, call.params);
+ def.done(function(){
+ call.callback.apply(this, [call.method]);
+ });
+ def.done(stack.next);
+ }
+ else {
+ stack.def.resolve();
+ }
+ }
+ };
+
+ list.load().done(function(){
+
+ strictEqual(list.pager.page, 0, 'init: page number is correct');
+ strictEqual(list.pager.total, nb_records, 'init: total number of item is correct');
+ strictEqual(list.pager.nb_pages, 2, 'init: number of pages is correct');
+ strictEqual(list.length, 100, 'init: number of items in the collection is correct');
+
+ strictEqual(list.hasPrevious(), false, 'init: pager has no previous');
+ strictEqual(list.hasNext(), true, 'init: pager has next');
+
+ strictEqual(list.at(0).get('name'), 'item 1', 'init: first item is correct');
+ strictEqual(list.at(99).get('name'), 'item 100', 'init: last item is correct');
+
+
+ list.on('change', function(){
+ list.off('change');
+ strictEqual(true, true, 'init: change page trigged');
+ });
+ list.on('change:next', function(){
+ list.off('change:next');
+ strictEqual(true, true, 'init: change:next page trigged');
+ });
+
+
+ stack.add('next', function(method){
+ strictEqual(list.pager.page, 1, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 2, method + ': number of pages is correct');
+ strictEqual(list.length, 23, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 101', method + ': first item is correct');
+ strictEqual(list.at(22).get('name'), 'item 123', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), true, method + ': pager has no previous');
+ strictEqual(list.hasNext(), false, method + ': pager has next');
+
+ });
+
+
+ stack.add('changeLimit', [10], function(method){
+ strictEqual(list.pager.page, 0, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 1', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 10', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), false, method + ': pager has no previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+ });
+
+ stack.add('last', function(method){
+ strictEqual(list.pager.page, 12, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 3, method + ': number of items in the collection is correct');
+
+ strictEqual(list.hasPrevious(), true, method + ': pager has no previous');
+ strictEqual(list.hasNext(), false, method + ': pager has next');
+
+ strictEqual(list.at(0).get('name'), 'item 121', method + ': first item is correct');
+ strictEqual(list.at(2).get('name'), 'item 123', method + ': last item is correct');
+
+ });
+
+ stack.add('prev', function(method){
+ strictEqual(list.pager.page, 11, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 111', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 120', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), true, method + ': pager has no previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+ });
+
+ var changed = false;
+ stack.add('first', function(method){
+ strictEqual(list.pager.page, 0, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 1', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 10', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), false, method + ': pager has no previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+
+ //listen for next stack call
+ list.on('change', function(){
+ list.off('change');
+ changed = true;
+ });
+ list.on('change:previous', function(){
+ list.off('change:previous');
+ changed = true;
+ });
+ });
+
+ stack.add('prev', function(method){
+ strictEqual(changed, false, method + ': has not affected the pager');
+
+ strictEqual(list.pager.page, 0, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 1', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 10', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), false, method + ': pager has no previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+
+ //listen for next stack call
+ list.on('change', function(){
+ list.off('change');
+ changed = true;
+ });
+ list.on('change:previous', function(){
+ list.off('change:previous');
+ changed = true;
+ });
+ });
+
+ stack.add('last').add('prev', function(method){
+ strictEqual(changed, true, method + ': has affected the pager');
+
+ strictEqual(list.pager.page, 11, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 111', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 120', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), true, method + ': pager has previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+ });
+
+
+ stack.add('load', [{ group_by: ['category'] }], function(method){
+ var Query = base.models('GroupQuery');
+
+ strictEqual(list.enabled(), false, 'group by: pager is disabled');
+ strictEqual(list.length, 2, 'group by: pager has 2 items');
+ strictEqual(list.at(0) instanceof Query, true, 'group by: item is an instance of GroupQuery');
+ });
+
+ // no effect, the pager is disabled
+ stack.add('last', function(){
+ list.enable();
+ });
+
+
+ stack.add('next').add('prev', function(method){
+ strictEqual(list.pager.page, 11, method + ': page number is correct');
+ strictEqual(list.pager.total, nb_records, method + ': total number of item is correct');
+ strictEqual(list.pager.nb_pages, 13, method + ': number of pages is correct');
+ strictEqual(list.length, 10, method + ': number of items in the collection is correct');
+
+ strictEqual(list.at(0).get('name'), 'item 111', method + ': first item is correct');
+ strictEqual(list.at(9).get('name'), 'item 120', method + ': last item is correct');
+
+ strictEqual(list.hasPrevious(), true, method + ': pager has previous');
+ strictEqual(list.hasNext(), true, method + ': pager has next');
+ });
+
+
+
+ stack.exec();
+ });
+
+ return stack.def.promise();
+
+ });
+
+ });
+
+});
=== added directory 'web_unleashed/tests'
=== added file 'web_unleashed/tests/__init__.py'
--- web_unleashed/tests/__init__.py 1970-01-01 00:00:00 +0000
+++ web_unleashed/tests/__init__.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+import test_js
\ No newline at end of file
=== added file 'web_unleashed/tests/test_js.py'
--- web_unleashed/tests/test_js.py 1970-01-01 00:00:00 +0000
+++ web_unleashed/tests/test_js.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,35 @@
+import urlparse
+from openerp import sql_db, tools
+from qunitsuite.suite import QUnitSuite
+
+class WebSuite(QUnitSuite):
+
+ def __init__(self):
+
+ url = urlparse.urlunsplit([
+ 'http',
+ 'localhost:{port}'.format(port=tools.config['xmlrpc_port']),
+ '/web/tests',
+ 'mod=web_unleashed&source={db}&supadmin={supadmin}&password={password}'.format(
+ db=tools.config['db_name'],
+ # al: i dont understand why both are needed, db_password is the
+ # password for postgres and should not appear here of that i'm
+ # sure
+ #
+ # But runbot provides it with this wrong key so i let it here
+ # until it's fixed
+ supadmin=tools.config['db_password'] or 'admin',
+ password=tools.config['admin_passwd'] or 'admin'),
+ ''
+ ])
+ super(WebSuite, self).__init__(url, 50000)
+
+ def run(self, result):
+
+ if sql_db._Pool is not None:
+ sql_db._Pool.close_all(sql_db.dsn(tools.config['db_name']))
+ return super(WebSuite, self).run(result)
+
+def load_tests(loader, standard_tests, _):
+ standard_tests.addTest(WebSuite())
+ return standard_tests
=== added directory 'web_unleashed_extra'
=== added file 'web_unleashed_extra/__init__.py'
--- web_unleashed_extra/__init__.py 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/__init__.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+
=== added file 'web_unleashed_extra/__openerp__.py'
--- web_unleashed_extra/__openerp__.py 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/__openerp__.py 2013-11-10 13:14:55 +0000
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+{
+ 'name': 'Web Unleashed - Extra',
+ 'version': '1.0',
+ 'category': 'Hidden',
+
+ 'description': """
+Extra components for unleashed module:
+
+- Twitter bootstrap 3.0, prefixed with a `bootstrap-scoped` css class: http://getbootstrap.com/
+- jQuery Transit (css3 animation): http://ricostacruz.com/jquery.transit/
+- NumeralJs lib: https://numeraljs.com/
+- MomentJs lib: http://momentjs.com/
+- Font Awesome lib: http://fortawesome.github.io/Font-Awesome/
+- Additional base models: period
+- Additional widgets for OpenERP: serialized
+
+ """,
+
+ 'author': 'Trobz',
+ 'website': 'http://trobz.com',
+
+ 'depends': [
+ 'web_unleashed'
+ ],
+
+ 'qweb' : [
+ 'static/src/templates/*.xml',
+ ],
+
+ 'css' : [
+ #bootstrap css
+ 'static/lib/bootstrap-scoped/bootstrap-reset-openerp.css',
+ 'static/lib/bootstrap-scoped/bootstrap-scoped.css',
+
+ #font awesome
+ 'static/lib/font-awesome/css/font-awesome.min.css',
+
+ # serialized widget
+ 'static/lib/jsoneditor/jsoneditor.css',
+ 'static/src/css/field_serialized.css',
+
+ # global css classes
+ 'static/src/css/global.css',
+ ],
+
+ 'js': [
+
+ # boostrap libs
+ 'static/lib/bootstrap-scoped/bootstrap.js',
+
+ # momentjs
+ 'static/lib/moment/moment.js',
+
+ # momentjs twix plugin
+ 'static/lib/moment-twix/twix.js',
+
+ # numeraljs
+ 'static/lib/numeral/numeral.js',
+
+ # jquery transit
+ 'static/lib/jquery-transit/jquery.transit.min.js',
+
+ # models
+ 'static/src/js/models/period.js',
+
+ # serialized widget
+ 'static/lib/jsoneditor/jsoneditor.js',
+ 'static/lib/jsoneditor/lib/jsonlint/jsonlint.js',
+ 'static/src/js/widgets/field_serialized.js',
+
+ ],
+
+ 'test': [
+ ]
+}
=== added directory 'web_unleashed_extra/static'
=== added directory 'web_unleashed_extra/static/lib'
=== added directory 'web_unleashed_extra/static/lib/bootstrap-scoped'
=== added file 'web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-reset-openerp.css'
--- web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-reset-openerp.css 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-reset-openerp.css 2013-11-10 13:14:55 +0000
@@ -0,0 +1,29 @@
+/*!
+ * reset css conflict between twitter bootstrap and OpenERP css
+ */
+
+
+.bootstrap_scope button:hover,
+.bootstrap_scope button {
+ background-color: none !important;
+ background-image: none !important;
+ -moz-border-radius: none !important;
+ -webkit-border-radius: none !important;
+ border-radius: none !important;
+ -moz-box-shadow: none !important;
+ -webkit-box-shadow: none !important;
+ box-shadow: none !important;
+ text-shadow: none !important;
+ -webkit-font-smoothing: none !important;
+ outline: none !important;
+}
+
+
+.bootstrap_scope .btn {
+ text-decoration: none !important;
+}
+
+.bootstrap_scope .btn-danger,
+.bootstrap_scope .btn-primary {
+color: #ffffff !important;
+}
\ No newline at end of file
=== added file 'web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-scoped.css'
--- web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-scoped.css 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap-scoped.css 2013-11-10 13:14:55 +0000
@@ -0,0 +1,4689 @@
+/*!
+ * customized and regenerated from twitter bootstrap sources:
+ *
+ * you can regenerate it by following these instructions:
+ * http://stackoverflow.com/questions/10568065/limit-the-scope-of-bootstrap-styles
+ *
+ * custom twitter bootstrap version, applied on limited elements by adding a .bootstrap-scope class to the parent
+ */
+
+/*!
+ * Bootstrap v3.0.0
+ *
+ * Copyright 2013 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world by @mdo and @fat.
+ */
+
+.bootstrap_scope {
+ /*! normalize.css v2.1.0 | MIT License | git.io/normalize */
+
+}
+
+.bootstrap_scope article,
+.bootstrap_scope aside,
+.bootstrap_scope details,
+.bootstrap_scope figcaption,
+.bootstrap_scope figure,
+.bootstrap_scope footer,
+.bootstrap_scope header,
+.bootstrap_scope hgroup,
+.bootstrap_scope main,
+.bootstrap_scope nav,
+.bootstrap_scope section,
+.bootstrap_scope summary {
+ display: block;
+}
+
+.bootstrap_scope audio,
+.bootstrap_scope canvas,
+.bootstrap_scope video {
+ display: inline-block;
+}
+
+.bootstrap_scope audio:not([controls]) {
+ display: none;
+ height: 0;
+}
+
+.bootstrap_scope [hidden] {
+ display: none;
+}
+
+.bootstrap_scope html {
+ font-family: sans-serif;
+ -webkit-text-size-adjust: 100%;
+ -ms-text-size-adjust: 100%;
+}
+
+.bootstrap_scope body {
+ margin: 0;
+}
+
+.bootstrap_scope a:focus {
+ outline: thin dotted;
+}
+
+.bootstrap_scope a:active,
+.bootstrap_scope a:hover {
+ outline: 0;
+}
+
+.bootstrap_scope h1 {
+ margin: 0.67em 0;
+ font-size: 2em;
+}
+
+.bootstrap_scope abbr[title] {
+ border-bottom: 1px dotted;
+}
+
+.bootstrap_scope b,
+.bootstrap_scope strong {
+ font-weight: bold;
+}
+
+.bootstrap_scope dfn {
+ font-style: italic;
+}
+
+.bootstrap_scope hr {
+ height: 0;
+ -moz-box-sizing: content-box;
+ box-sizing: content-box;
+}
+
+.bootstrap_scope mark {
+ color: #000;
+ background: #ff0;
+}
+
+.bootstrap_scope code,
+.bootstrap_scope kbd,
+.bootstrap_scope pre,
+.bootstrap_scope samp {
+ font-family: monospace, serif;
+ font-size: 1em;
+}
+
+.bootstrap_scope pre {
+ white-space: pre-wrap;
+}
+
+.bootstrap_scope q {
+ quotes: "\201C" "\201D" "\2018" "\2019";
+}
+
+.bootstrap_scope small {
+ font-size: 80%;
+}
+
+.bootstrap_scope sub,
+.bootstrap_scope sup {
+ position: relative;
+ font-size: 75%;
+ line-height: 0;
+ vertical-align: baseline;
+}
+
+.bootstrap_scope sup {
+ top: -0.5em;
+}
+
+.bootstrap_scope sub {
+ bottom: -0.25em;
+}
+
+.bootstrap_scope img {
+ border: 0;
+}
+
+.bootstrap_scope svg:not(:root) {
+ overflow: hidden;
+}
+
+.bootstrap_scope figure {
+ margin: 0;
+}
+
+.bootstrap_scope fieldset {
+ padding: 0.35em 0.625em 0.75em;
+ margin: 0 2px;
+ border: 1px solid #c0c0c0;
+}
+
+.bootstrap_scope legend {
+ padding: 0;
+ border: 0;
+}
+
+.bootstrap_scope button,
+.bootstrap_scope input,
+.bootstrap_scope select,
+.bootstrap_scope textarea {
+ margin: 0;
+ font-family: inherit;
+ font-size: 100%;
+}
+
+.bootstrap_scope button,
+.bootstrap_scope input {
+ line-height: normal;
+}
+
+.bootstrap_scope button,
+.bootstrap_scope select {
+ text-transform: none;
+}
+
+.bootstrap_scope button,
+.bootstrap_scope html input[type="button"],
+.bootstrap_scope input[type="reset"],
+.bootstrap_scope input[type="submit"] {
+ cursor: pointer;
+ -webkit-appearance: button;
+}
+
+.bootstrap_scope button[disabled],
+.bootstrap_scope html input[disabled] {
+ cursor: default;
+}
+
+.bootstrap_scope input[type="checkbox"],
+.bootstrap_scope input[type="radio"] {
+ padding: 0;
+ box-sizing: border-box;
+}
+
+.bootstrap_scope input[type="search"] {
+ -webkit-box-sizing: content-box;
+ -moz-box-sizing: content-box;
+ box-sizing: content-box;
+ -webkit-appearance: textfield;
+}
+
+.bootstrap_scope input[type="search"]::-webkit-search-cancel-button,
+.bootstrap_scope input[type="search"]::-webkit-search-decoration {
+ -webkit-appearance: none;
+}
+
+.bootstrap_scope button::-moz-focus-inner,
+.bootstrap_scope input::-moz-focus-inner {
+ padding: 0;
+ border: 0;
+}
+
+.bootstrap_scope textarea {
+ overflow: auto;
+ vertical-align: top;
+}
+
+.bootstrap_scope table {
+ border-collapse: collapse;
+ border-spacing: 0;
+}
+
+@media print {
+ .bootstrap_scope * {
+ color: #000 !important;
+ text-shadow: none !important;
+ background: transparent !important;
+ box-shadow: none !important;
+ }
+ .bootstrap_scope a,
+ .bootstrap_scope a:visited {
+ text-decoration: underline;
+ }
+ .bootstrap_scope a[href]:after {
+ content: " (" attr(href) ")";
+ }
+ .bootstrap_scope abbr[title]:after {
+ content: " (" attr(title) ")";
+ }
+ .bootstrap_scope .ir a:after,
+ .bootstrap_scope a[href^="javascript:"]:after,
+ .bootstrap_scope a[href^="#"]:after {
+ content: "";
+ }
+ .bootstrap_scope pre,
+ .bootstrap_scope blockquote {
+ border: 1px solid #999;
+ page-break-inside: avoid;
+ }
+ .bootstrap_scope thead {
+ display: table-header-group;
+ }
+ .bootstrap_scope tr,
+ .bootstrap_scope img {
+ page-break-inside: avoid;
+ }
+ .bootstrap_scope img {
+ max-width: 100% !important;
+ }
+ @page {
+ margin: 2cm .5cm;
+ }
+ .bootstrap_scope p,
+ .bootstrap_scope h2,
+ .bootstrap_scope h3 {
+ orphans: 3;
+ widows: 3;
+ }
+ .bootstrap_scope h2,
+ .bootstrap_scope h3 {
+ page-break-after: avoid;
+ }
+ .bootstrap_scope .navbar {
+ display: none;
+ }
+ .bootstrap_scope .table td,
+ .bootstrap_scope .table th {
+ background-color: #fff !important;
+ }
+ .bootstrap_scope .btn > .caret,
+ .bootstrap_scope .dropup > .btn > .caret {
+ border-top-color: #000 !important;
+ }
+ .bootstrap_scope .label {
+ border: 1px solid #000;
+ }
+ .bootstrap_scope .table {
+ border-collapse: collapse !important;
+ }
+ .bootstrap_scope .table-bordered th,
+ .bootstrap_scope .table-bordered td {
+ border: 1px solid #ddd !important;
+ }
+}
+
+.bootstrap_scope * {
+ -webkit-box-sizing: border-box;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+}
+
+.bootstrap_scope html {
+ font-size: 62.5%;
+ -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+
+.bootstrap_scope body {
+ font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+ font-size: 14px;
+ line-height: 1.428571429;
+ color: #333333;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope input,
+.bootstrap_scope button,
+.bootstrap_scope select,
+.bootstrap_scope textarea {
+ font-family: inherit;
+ font-size: inherit;
+ line-height: inherit;
+}
+
+.bootstrap_scope a {
+ color: #428bca;
+ text-decoration: none;
+}
+
+.bootstrap_scope a:hover,
+.bootstrap_scope a:focus {
+ color: #2a6496;
+ text-decoration: underline;
+}
+
+.bootstrap_scope a:focus {
+ outline: thin dotted #333;
+ outline: 5px auto -webkit-focus-ring-color;
+ outline-offset: -2px;
+}
+
+.bootstrap_scope img {
+ vertical-align: middle;
+}
+
+.bootstrap_scope .img-responsive {
+ display: inline-block;
+ height: auto;
+ max-width: 100%;
+}
+
+.bootstrap_scope .img-rounded {
+ border-radius: 6px;
+}
+
+.bootstrap_scope .img-circle {
+ border-radius: 500px;
+}
+
+.bootstrap_scope hr {
+ margin-top: 20px;
+ margin-bottom: 20px;
+ border: 0;
+ border-top: 1px solid #eeeeee;
+}
+
+.bootstrap_scope p {
+ margin: 0 0 10px;
+}
+
+.bootstrap_scope .lead {
+ margin-bottom: 20px;
+ font-size: 16.099999999999998px;
+ font-weight: 200;
+ line-height: 1.4;
+}
+
+@media (min-width: 768px) {
+ .bootstrap_scope .lead {
+ font-size: 21px;
+ }
+}
+
+.bootstrap_scope small {
+ font-size: 85%;
+}
+
+.bootstrap_scope cite {
+ font-style: normal;
+}
+
+.bootstrap_scope .text-muted {
+ color: #999999;
+}
+
+.bootstrap_scope .text-primary {
+ color: #428bca;
+}
+
+.bootstrap_scope .text-warning {
+ color: #c09853;
+}
+
+.bootstrap_scope .text-danger {
+ color: #b94a48;
+}
+
+.bootstrap_scope .text-success {
+ color: #468847;
+}
+
+.bootstrap_scope .text-info {
+ color: #3a87ad;
+}
+
+.bootstrap_scope .text-left {
+ text-align: left;
+}
+
+.bootstrap_scope .text-right {
+ text-align: right;
+}
+
+.bootstrap_scope .text-center {
+ text-align: center;
+}
+
+.bootstrap_scope h1,
+.bootstrap_scope h2,
+.bootstrap_scope h3,
+.bootstrap_scope h4,
+.bootstrap_scope h5,
+.bootstrap_scope h6,
+.bootstrap_scope .h1,
+.bootstrap_scope .h2,
+.bootstrap_scope .h3,
+.bootstrap_scope .h4,
+.bootstrap_scope .h5,
+.bootstrap_scope .h6 {
+ font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+ font-weight: 500;
+ line-height: 1.1;
+}
+
+.bootstrap_scope h1 small,
+.bootstrap_scope h2 small,
+.bootstrap_scope h3 small,
+.bootstrap_scope h4 small,
+.bootstrap_scope h5 small,
+.bootstrap_scope h6 small,
+.bootstrap_scope .h1 small,
+.bootstrap_scope .h2 small,
+.bootstrap_scope .h3 small,
+.bootstrap_scope .h4 small,
+.bootstrap_scope .h5 small,
+.bootstrap_scope .h6 small {
+ font-weight: normal;
+ line-height: 1;
+ color: #999999;
+}
+
+.bootstrap_scope h1,
+.bootstrap_scope h2,
+.bootstrap_scope h3 {
+ margin-top: 20px;
+ margin-bottom: 10px;
+}
+
+.bootstrap_scope h4,
+.bootstrap_scope h5,
+.bootstrap_scope h6 {
+ margin-top: 10px;
+ margin-bottom: 10px;
+}
+
+.bootstrap_scope h1,
+.bootstrap_scope .h1 {
+ font-size: 38px;
+}
+
+.bootstrap_scope h2,
+.bootstrap_scope .h2 {
+ font-size: 32px;
+}
+
+.bootstrap_scope h3,
+.bootstrap_scope .h3 {
+ font-size: 24px;
+}
+
+.bootstrap_scope h4,
+.bootstrap_scope .h4 {
+ font-size: 18px;
+}
+
+.bootstrap_scope h5,
+.bootstrap_scope .h5 {
+ font-size: 14px;
+}
+
+.bootstrap_scope h6,
+.bootstrap_scope .h6 {
+ font-size: 12px;
+}
+
+.bootstrap_scope h1 small,
+.bootstrap_scope .h1 small {
+ font-size: 24px;
+}
+
+.bootstrap_scope h2 small,
+.bootstrap_scope .h2 small {
+ font-size: 18px;
+}
+
+.bootstrap_scope h3 small,
+.bootstrap_scope .h3 small,
+.bootstrap_scope h4 small,
+.bootstrap_scope .h4 small {
+ font-size: 14px;
+}
+
+.bootstrap_scope .page-header {
+ padding-bottom: 9px;
+ margin: 40px 0 20px;
+ border-bottom: 1px solid #eeeeee;
+}
+
+.bootstrap_scope ul,
+.bootstrap_scope ol {
+ margin-top: 0;
+ margin-bottom: 10px;
+}
+
+.bootstrap_scope ul ul,
+.bootstrap_scope ol ul,
+.bootstrap_scope ul ol,
+.bootstrap_scope ol ol {
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .list-unstyled {
+ padding-left: 0;
+ list-style: none;
+}
+
+.bootstrap_scope .list-inline {
+ padding-left: 0;
+ list-style: none;
+}
+
+.bootstrap_scope .list-inline > li {
+ display: inline-block;
+ padding-right: 5px;
+ padding-left: 5px;
+}
+
+.bootstrap_scope dl {
+ margin-bottom: 20px;
+}
+
+.bootstrap_scope dt,
+.bootstrap_scope dd {
+ line-height: 1.428571429;
+}
+
+.bootstrap_scope dt {
+ font-weight: bold;
+}
+
+.bootstrap_scope dd {
+ margin-left: 0;
+}
+
+.bootstrap_scope .dl-horizontal dt {
+ float: left;
+ width: 160px;
+ overflow: hidden;
+ clear: left;
+ text-align: right;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+.bootstrap_scope .dl-horizontal dd {
+ margin-left: 180px;
+}
+
+.bootstrap_scope .dl-horizontal dd:before,
+.bootstrap_scope .dl-horizontal dd:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .dl-horizontal dd:after {
+ clear: both;
+}
+
+.bootstrap_scope .dl-horizontal dd:before,
+.bootstrap_scope .dl-horizontal dd:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .dl-horizontal dd:after {
+ clear: both;
+}
+
+.bootstrap_scope abbr[title],
+.bootstrap_scope abbr[data-original-title] {
+ cursor: help;
+ border-bottom: 1px dotted #999999;
+}
+
+.bootstrap_scope abbr.initialism {
+ font-size: 90%;
+ text-transform: uppercase;
+}
+
+.bootstrap_scope blockquote {
+ padding: 10px 20px;
+ margin: 0 0 20px;
+ border-left: 5px solid #eeeeee;
+}
+
+.bootstrap_scope blockquote p {
+ font-size: 17.5px;
+ font-weight: 300;
+ line-height: 1.25;
+}
+
+.bootstrap_scope blockquote p:last-child {
+ margin-bottom: 0;
+}
+
+.bootstrap_scope blockquote small {
+ display: block;
+ line-height: 1.428571429;
+ color: #999999;
+}
+
+.bootstrap_scope blockquote small:before {
+ content: '\2014 \00A0';
+}
+
+.bootstrap_scope blockquote.pull-right {
+ float: right;
+ padding-right: 15px;
+ padding-left: 0;
+ border-right: 5px solid #eeeeee;
+ border-left: 0;
+}
+
+.bootstrap_scope blockquote.pull-right p,
+.bootstrap_scope blockquote.pull-right small {
+ text-align: right;
+}
+
+.bootstrap_scope blockquote.pull-right small:before {
+ content: '';
+}
+
+.bootstrap_scope blockquote.pull-right small:after {
+ content: '\00A0 \2014';
+}
+
+.bootstrap_scope q:before,
+.bootstrap_scope q:after,
+.bootstrap_scope blockquote:before,
+.bootstrap_scope blockquote:after {
+ content: "";
+}
+
+.bootstrap_scope address {
+ display: block;
+ margin-bottom: 20px;
+ font-style: normal;
+ line-height: 1.428571429;
+}
+
+.bootstrap_scope code,
+.bootstrap_scope pre {
+ font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
+}
+
+.bootstrap_scope code {
+ padding: 2px 4px;
+ font-size: 90%;
+ color: #c7254e;
+ white-space: nowrap;
+ background-color: #f9f2f4;
+ border-radius: 4px;
+}
+
+.bootstrap_scope pre {
+ display: block;
+ padding: 9.5px;
+ margin: 0 0 10px;
+ font-size: 13px;
+ line-height: 1.428571429;
+ color: #333333;
+ word-break: break-all;
+ word-wrap: break-word;
+ background-color: #f5f5f5;
+ border: 1px solid #cccccc;
+ border-radius: 4px;
+}
+
+.bootstrap_scope pre.prettyprint {
+ margin-bottom: 20px;
+}
+
+.bootstrap_scope pre code {
+ padding: 0;
+ color: inherit;
+ white-space: pre-wrap;
+ background-color: transparent;
+ border: 0;
+}
+
+.bootstrap_scope .pre-scrollable {
+ max-height: 340px;
+ overflow-y: scroll;
+}
+
+.bootstrap_scope .container {
+ margin-right: auto;
+ margin-left: auto;
+}
+
+.bootstrap_scope .container:before,
+.bootstrap_scope .container:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .container:after {
+ clear: both;
+}
+
+.bootstrap_scope .container:before,
+.bootstrap_scope .container:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .container:after {
+ clear: both;
+}
+
+.bootstrap_scope .row:before,
+.bootstrap_scope .row:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .row:after {
+ clear: both;
+}
+
+.bootstrap_scope .row:before,
+.bootstrap_scope .row:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .row:after {
+ clear: both;
+}
+
+@media (min-width: 768px) {
+ .bootstrap_scope .row {
+ margin-right: -15px;
+ margin-left: -15px;
+ }
+}
+
+.bootstrap_scope .row .row {
+ margin-right: -15px;
+ margin-left: -15px;
+}
+
+.bootstrap_scope .col-1,
+.bootstrap_scope .col-2,
+.bootstrap_scope .col-3,
+.bootstrap_scope .col-4,
+.bootstrap_scope .col-5,
+.bootstrap_scope .col-6,
+.bootstrap_scope .col-7,
+.bootstrap_scope .col-8,
+.bootstrap_scope .col-9,
+.bootstrap_scope .col-10,
+.bootstrap_scope .col-11,
+.bootstrap_scope .col-12,
+.bootstrap_scope .col-sm-1,
+.bootstrap_scope .col-sm-2,
+.bootstrap_scope .col-sm-3,
+.bootstrap_scope .col-sm-4,
+.bootstrap_scope .col-sm-5,
+.bootstrap_scope .col-sm-6,
+.bootstrap_scope .col-sm-7,
+.bootstrap_scope .col-sm-8,
+.bootstrap_scope .col-sm-9,
+.bootstrap_scope .col-sm-10,
+.bootstrap_scope .col-sm-11,
+.bootstrap_scope .col-sm-12,
+.bootstrap_scope .col-lg-1,
+.bootstrap_scope .col-lg-2,
+.bootstrap_scope .col-lg-3,
+.bootstrap_scope .col-lg-4,
+.bootstrap_scope .col-lg-5,
+.bootstrap_scope .col-lg-6,
+.bootstrap_scope .col-lg-7,
+.bootstrap_scope .col-lg-8,
+.bootstrap_scope .col-lg-9,
+.bootstrap_scope .col-lg-10,
+.bootstrap_scope .col-lg-11,
+.bootstrap_scope .col-lg-12 {
+ position: relative;
+ min-height: 1px;
+ padding-right: 15px;
+ padding-left: 15px;
+}
+
+.bootstrap_scope .col-1,
+.bootstrap_scope .col-2,
+.bootstrap_scope .col-3,
+.bootstrap_scope .col-4,
+.bootstrap_scope .col-5,
+.bootstrap_scope .col-6,
+.bootstrap_scope .col-7,
+.bootstrap_scope .col-8,
+.bootstrap_scope .col-9,
+.bootstrap_scope .col-10,
+.bootstrap_scope .col-11,
+.bootstrap_scope .col-12 {
+ float: left;
+}
+
+.bootstrap_scope .col-1 {
+ width: 8.333333333333332%;
+}
+
+.bootstrap_scope .col-2 {
+ width: 16.666666666666664%;
+}
+
+.bootstrap_scope .col-3 {
+ width: 25%;
+}
+
+.bootstrap_scope .col-4 {
+ width: 33.33333333333333%;
+}
+
+.bootstrap_scope .col-5 {
+ width: 41.66666666666667%;
+}
+
+.bootstrap_scope .col-6 {
+ width: 50%;
+}
+
+.bootstrap_scope .col-7 {
+ width: 58.333333333333336%;
+}
+
+.bootstrap_scope .col-8 {
+ width: 66.66666666666666%;
+}
+
+.bootstrap_scope .col-9 {
+ width: 75%;
+}
+
+.bootstrap_scope .col-10 {
+ width: 83.33333333333334%;
+}
+
+.bootstrap_scope .col-11 {
+ width: 91.66666666666666%;
+}
+
+.bootstrap_scope .col-12 {
+ width: 100%;
+}
+
+@media (min-width: 768px) {
+ .bootstrap_scope .container {
+ max-width: 728px;
+ }
+ .bootstrap_scope .col-sm-1,
+ .bootstrap_scope .col-sm-2,
+ .bootstrap_scope .col-sm-3,
+ .bootstrap_scope .col-sm-4,
+ .bootstrap_scope .col-sm-5,
+ .bootstrap_scope .col-sm-6,
+ .bootstrap_scope .col-sm-7,
+ .bootstrap_scope .col-sm-8,
+ .bootstrap_scope .col-sm-9,
+ .bootstrap_scope .col-sm-10,
+ .bootstrap_scope .col-sm-11,
+ .bootstrap_scope .col-sm-12 {
+ float: left;
+ }
+ .bootstrap_scope .col-sm-1 {
+ width: 8.333333333333332%;
+ }
+ .bootstrap_scope .col-sm-2 {
+ width: 16.666666666666664%;
+ }
+ .bootstrap_scope .col-sm-3 {
+ width: 25%;
+ }
+ .bootstrap_scope .col-sm-4 {
+ width: 33.33333333333333%;
+ }
+ .bootstrap_scope .col-sm-5 {
+ width: 41.66666666666667%;
+ }
+ .bootstrap_scope .col-sm-6 {
+ width: 50%;
+ }
+ .bootstrap_scope .col-sm-7 {
+ width: 58.333333333333336%;
+ }
+ .bootstrap_scope .col-sm-8 {
+ width: 66.66666666666666%;
+ }
+ .bootstrap_scope .col-sm-9 {
+ width: 75%;
+ }
+ .bootstrap_scope .col-sm-10 {
+ width: 83.33333333333334%;
+ }
+ .bootstrap_scope .col-sm-11 {
+ width: 91.66666666666666%;
+ }
+ .bootstrap_scope .col-sm-12 {
+ width: 100%;
+ }
+ .bootstrap_scope .col-push-1 {
+ left: 8.333333333333332%;
+ }
+ .bootstrap_scope .col-push-2 {
+ left: 16.666666666666664%;
+ }
+ .bootstrap_scope .col-push-3 {
+ left: 25%;
+ }
+ .bootstrap_scope .col-push-4 {
+ left: 33.33333333333333%;
+ }
+ .bootstrap_scope .col-push-5 {
+ left: 41.66666666666667%;
+ }
+ .bootstrap_scope .col-push-6 {
+ left: 50%;
+ }
+ .bootstrap_scope .col-push-7 {
+ left: 58.333333333333336%;
+ }
+ .bootstrap_scope .col-push-8 {
+ left: 66.66666666666666%;
+ }
+ .bootstrap_scope .col-push-9 {
+ left: 75%;
+ }
+ .bootstrap_scope .col-push-10 {
+ left: 83.33333333333334%;
+ }
+ .bootstrap_scope .col-push-11 {
+ left: 91.66666666666666%;
+ }
+ .bootstrap_scope .col-pull-1 {
+ right: 8.333333333333332%;
+ }
+ .bootstrap_scope .col-pull-2 {
+ right: 16.666666666666664%;
+ }
+ .bootstrap_scope .col-pull-3 {
+ right: 25%;
+ }
+ .bootstrap_scope .col-pull-4 {
+ right: 33.33333333333333%;
+ }
+ .bootstrap_scope .col-pull-5 {
+ right: 41.66666666666667%;
+ }
+ .bootstrap_scope .col-pull-6 {
+ right: 50%;
+ }
+ .bootstrap_scope .col-pull-7 {
+ right: 58.333333333333336%;
+ }
+ .bootstrap_scope .col-pull-8 {
+ right: 66.66666666666666%;
+ }
+ .bootstrap_scope .col-pull-9 {
+ right: 75%;
+ }
+ .bootstrap_scope .col-pull-10 {
+ right: 83.33333333333334%;
+ }
+ .bootstrap_scope .col-pull-11 {
+ right: 91.66666666666666%;
+ }
+}
+
+@media (min-width: 992px) {
+ .bootstrap_scope .container {
+ max-width: 940px;
+ }
+ .bootstrap_scope .col-lg-1,
+ .bootstrap_scope .col-lg-2,
+ .bootstrap_scope .col-lg-3,
+ .bootstrap_scope .col-lg-4,
+ .bootstrap_scope .col-lg-5,
+ .bootstrap_scope .col-lg-6,
+ .bootstrap_scope .col-lg-7,
+ .bootstrap_scope .col-lg-8,
+ .bootstrap_scope .col-lg-9,
+ .bootstrap_scope .col-lg-10,
+ .bootstrap_scope .col-lg-11,
+ .bootstrap_scope .col-lg-12 {
+ float: left;
+ }
+ .bootstrap_scope .col-lg-1 {
+ width: 8.333333333333332%;
+ }
+ .bootstrap_scope .col-lg-2 {
+ width: 16.666666666666664%;
+ }
+ .bootstrap_scope .col-lg-3 {
+ width: 25%;
+ }
+ .bootstrap_scope .col-lg-4 {
+ width: 33.33333333333333%;
+ }
+ .bootstrap_scope .col-lg-5 {
+ width: 41.66666666666667%;
+ }
+ .bootstrap_scope .col-lg-6 {
+ width: 50%;
+ }
+ .bootstrap_scope .col-lg-7 {
+ width: 58.333333333333336%;
+ }
+ .bootstrap_scope .col-lg-8 {
+ width: 66.66666666666666%;
+ }
+ .bootstrap_scope .col-lg-9 {
+ width: 75%;
+ }
+ .bootstrap_scope .col-lg-10 {
+ width: 83.33333333333334%;
+ }
+ .bootstrap_scope .col-lg-11 {
+ width: 91.66666666666666%;
+ }
+ .bootstrap_scope .col-lg-12 {
+ width: 100%;
+ }
+ .bootstrap_scope .col-offset-1 {
+ margin-left: 8.333333333333332%;
+ }
+ .bootstrap_scope .col-offset-2 {
+ margin-left: 16.666666666666664%;
+ }
+ .bootstrap_scope .col-offset-3 {
+ margin-left: 25%;
+ }
+ .bootstrap_scope .col-offset-4 {
+ margin-left: 33.33333333333333%;
+ }
+ .bootstrap_scope .col-offset-5 {
+ margin-left: 41.66666666666667%;
+ }
+ .bootstrap_scope .col-offset-6 {
+ margin-left: 50%;
+ }
+ .bootstrap_scope .col-offset-7 {
+ margin-left: 58.333333333333336%;
+ }
+ .bootstrap_scope .col-offset-8 {
+ margin-left: 66.66666666666666%;
+ }
+ .bootstrap_scope .col-offset-9 {
+ margin-left: 75%;
+ }
+ .bootstrap_scope .col-offset-10 {
+ margin-left: 83.33333333333334%;
+ }
+ .bootstrap_scope .col-offset-11 {
+ margin-left: 91.66666666666666%;
+ }
+}
+
+@media (min-width: 1200px) {
+ .bootstrap_scope .container {
+ max-width: 1170px;
+ }
+}
+
+.bootstrap_scope table {
+ max-width: 100%;
+ background-color: transparent;
+}
+
+.bootstrap_scope th {
+ text-align: left;
+}
+
+.bootstrap_scope .table {
+ width: 100%;
+ margin-bottom: 20px;
+}
+
+.bootstrap_scope .table thead > tr > th,
+.bootstrap_scope .table tbody > tr > th,
+.bootstrap_scope .table tfoot > tr > th,
+.bootstrap_scope .table thead > tr > td,
+.bootstrap_scope .table tbody > tr > td,
+.bootstrap_scope .table tfoot > tr > td {
+ padding: 8px;
+ line-height: 1.428571429;
+ vertical-align: top;
+ border-top: 1px solid #dddddd;
+}
+
+.bootstrap_scope .table thead > tr > th {
+ vertical-align: bottom;
+}
+
+.bootstrap_scope .table caption + thead tr:first-child th,
+.bootstrap_scope .table colgroup + thead tr:first-child th,
+.bootstrap_scope .table thead:first-child tr:first-child th,
+.bootstrap_scope .table caption + thead tr:first-child td,
+.bootstrap_scope .table colgroup + thead tr:first-child td,
+.bootstrap_scope .table thead:first-child tr:first-child td {
+ border-top: 0;
+}
+
+.bootstrap_scope .table tbody + tbody {
+ border-top: 2px solid #dddddd;
+}
+
+.bootstrap_scope .table .table {
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .table-condensed thead > tr > th,
+.bootstrap_scope .table-condensed tbody > tr > th,
+.bootstrap_scope .table-condensed tfoot > tr > th,
+.bootstrap_scope .table-condensed thead > tr > td,
+.bootstrap_scope .table-condensed tbody > tr > td,
+.bootstrap_scope .table-condensed tfoot > tr > td {
+ padding: 5px;
+}
+
+.bootstrap_scope .table-bordered {
+ border: 1px solid #dddddd;
+}
+
+.bootstrap_scope .table-bordered > thead > tr > th,
+.bootstrap_scope .table-bordered > tbody > tr > th,
+.bootstrap_scope .table-bordered > tfoot > tr > th,
+.bootstrap_scope .table-bordered > thead > tr > td,
+.bootstrap_scope .table-bordered > tbody > tr > td,
+.bootstrap_scope .table-bordered > tfoot > tr > td {
+ border: 1px solid #dddddd;
+}
+
+.bootstrap_scope .table-striped > tbody > tr:nth-child(odd) > td,
+.bootstrap_scope .table-striped > tbody > tr:nth-child(odd) > th {
+ background-color: #f9f9f9;
+}
+
+.bootstrap_scope .table-hover > tbody > tr:hover > td,
+.bootstrap_scope .table-hover > tbody > tr:hover > th {
+ background-color: #f5f5f5;
+}
+
+.bootstrap_scope table col[class^="col-"] {
+ display: table-column;
+ float: none;
+}
+
+.bootstrap_scope table td[class^="col-"],
+.bootstrap_scope table th[class^="col-"] {
+ display: table-cell;
+ float: none;
+}
+
+.bootstrap_scope .table > thead > tr > td.active,
+.bootstrap_scope .table > tbody > tr > td.active,
+.bootstrap_scope .table > tfoot > tr > td.active,
+.bootstrap_scope .table > thead > tr > th.active,
+.bootstrap_scope .table > tbody > tr > th.active,
+.bootstrap_scope .table > tfoot > tr > th.active,
+.bootstrap_scope .table > thead > tr.active > td,
+.bootstrap_scope .table > tbody > tr.active > td,
+.bootstrap_scope .table > tfoot > tr.active > td,
+.bootstrap_scope .table > thead > tr.active > th,
+.bootstrap_scope .table > tbody > tr.active > th,
+.bootstrap_scope .table > tfoot > tr.active > th {
+ background-color: #f5f5f5;
+}
+
+.bootstrap_scope .table > thead > tr > td.success,
+.bootstrap_scope .table > tbody > tr > td.success,
+.bootstrap_scope .table > tfoot > tr > td.success,
+.bootstrap_scope .table > thead > tr > th.success,
+.bootstrap_scope .table > tbody > tr > th.success,
+.bootstrap_scope .table > tfoot > tr > th.success,
+.bootstrap_scope .table > thead > tr.success > td,
+.bootstrap_scope .table > tbody > tr.success > td,
+.bootstrap_scope .table > tfoot > tr.success > td,
+.bootstrap_scope .table > thead > tr.success > th,
+.bootstrap_scope .table > tbody > tr.success > th,
+.bootstrap_scope .table > tfoot > tr.success > th {
+ background-color: #dff0d8;
+ border-color: #d6e9c6;
+}
+
+.bootstrap_scope .table > thead > tr > td.danger,
+.bootstrap_scope .table > tbody > tr > td.danger,
+.bootstrap_scope .table > tfoot > tr > td.danger,
+.bootstrap_scope .table > thead > tr > th.danger,
+.bootstrap_scope .table > tbody > tr > th.danger,
+.bootstrap_scope .table > tfoot > tr > th.danger,
+.bootstrap_scope .table > thead > tr.danger > td,
+.bootstrap_scope .table > tbody > tr.danger > td,
+.bootstrap_scope .table > tfoot > tr.danger > td,
+.bootstrap_scope .table > thead > tr.danger > th,
+.bootstrap_scope .table > tbody > tr.danger > th,
+.bootstrap_scope .table > tfoot > tr.danger > th {
+ background-color: #f2dede;
+ border-color: #eed3d7;
+}
+
+.bootstrap_scope .table > thead > tr > td.warning,
+.bootstrap_scope .table > tbody > tr > td.warning,
+.bootstrap_scope .table > tfoot > tr > td.warning,
+.bootstrap_scope .table > thead > tr > th.warning,
+.bootstrap_scope .table > tbody > tr > th.warning,
+.bootstrap_scope .table > tfoot > tr > th.warning,
+.bootstrap_scope .table > thead > tr.warning > td,
+.bootstrap_scope .table > tbody > tr.warning > td,
+.bootstrap_scope .table > tfoot > tr.warning > td,
+.bootstrap_scope .table > thead > tr.warning > th,
+.bootstrap_scope .table > tbody > tr.warning > th,
+.bootstrap_scope .table > tfoot > tr.warning > th {
+ background-color: #fcf8e3;
+ border-color: #fbeed5;
+}
+
+.bootstrap_scope .table-hover > tbody > tr > td.success:hover,
+.bootstrap_scope .table-hover > tbody > tr > th.success:hover,
+.bootstrap_scope .table-hover > tbody > tr.success:hover > td {
+ background-color: #d0e9c6;
+ border-color: #c9e2b3;
+}
+
+.bootstrap_scope .table-hover > tbody > tr > td.danger:hover,
+.bootstrap_scope .table-hover > tbody > tr > th.danger:hover,
+.bootstrap_scope .table-hover > tbody > tr.danger:hover > td {
+ background-color: #ebcccc;
+ border-color: #e6c1c7;
+}
+
+.bootstrap_scope .table-hover > tbody > tr > td.warning:hover,
+.bootstrap_scope .table-hover > tbody > tr > th.warning:hover,
+.bootstrap_scope .table-hover > tbody > tr.warning:hover > td {
+ background-color: #faf2cc;
+ border-color: #f8e5be;
+}
+
+.bootstrap_scope fieldset {
+ padding: 0;
+ margin: 0;
+ border: 0;
+}
+
+.bootstrap_scope legend {
+ display: block;
+ width: 100%;
+ padding: 0;
+ margin-bottom: 20px;
+ font-size: 21px;
+ line-height: inherit;
+ color: #333333;
+ border: 0;
+ border-bottom: 1px solid #e5e5e5;
+}
+
+.bootstrap_scope label {
+ display: inline-block;
+ margin-bottom: 5px;
+ font-weight: bold;
+}
+
+.bootstrap_scope input[type="search"] {
+ -webkit-box-sizing: border-box;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+}
+
+.bootstrap_scope input[type="radio"],
+.bootstrap_scope input[type="checkbox"] {
+ margin: 4px 0 0;
+ margin-top: 1px \9;
+ /* IE8-9 */
+
+ line-height: normal;
+}
+
+.bootstrap_scope input[type="file"] {
+ display: block;
+}
+
+.bootstrap_scope select[multiple],
+.bootstrap_scope select[size] {
+ height: auto;
+}
+
+.bootstrap_scope select optgroup {
+ font-family: inherit;
+ font-size: inherit;
+ font-style: inherit;
+}
+
+.bootstrap_scope input[type="file"]:focus,
+.bootstrap_scope input[type="radio"]:focus,
+.bootstrap_scope input[type="checkbox"]:focus {
+ outline: thin dotted #333;
+ outline: 5px auto -webkit-focus-ring-color;
+ outline-offset: -2px;
+}
+
+.bootstrap_scope input[type="number"]::-webkit-outer-spin-button,
+.bootstrap_scope input[type="number"]::-webkit-inner-spin-button {
+ height: auto;
+}
+
+.bootstrap_scope .form-control:-moz-placeholder {
+ color: #999999;
+}
+
+.bootstrap_scope .form-control::-moz-placeholder {
+ color: #999999;
+}
+
+.bootstrap_scope .form-control:-ms-input-placeholder {
+ color: #999999;
+}
+
+.bootstrap_scope .form-control::-webkit-input-placeholder {
+ color: #999999;
+}
+
+.bootstrap_scope .form-control {
+ display: block;
+ width: 100%;
+ height: 38px;
+ padding: 8px 12px;
+ font-size: 14px;
+ line-height: 1.428571429;
+ color: #555555;
+ vertical-align: middle;
+ background-color: #ffffff;
+ border: 1px solid #cccccc;
+ border-radius: 4px;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+ -webkit-transition: border-color ease-in-out 0.15s, box-shadow ease-in-out 0.15s;
+ transition: border-color ease-in-out 0.15s, box-shadow ease-in-out 0.15s;
+}
+
+.bootstrap_scope .form-control:focus {
+ border-color: rgba(82, 168, 236, 0.8);
+ outline: 0;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+}
+
+.bootstrap_scope .form-control[disabled],
+.bootstrap_scope .form-control[readonly],
+fieldset[disabled] .bootstrap_scope .form-control {
+ cursor: not-allowed;
+ background-color: #eeeeee;
+}
+
+textarea.bootstrap_scope .form-control {
+ height: auto;
+}
+
+.bootstrap_scope .form-group {
+ margin-bottom: 15px;
+}
+
+.bootstrap_scope .radio,
+.bootstrap_scope .checkbox {
+ display: block;
+ min-height: 20px;
+ padding-left: 20px;
+ margin-top: 10px;
+ margin-bottom: 10px;
+ vertical-align: middle;
+}
+
+.bootstrap_scope .radio label,
+.bootstrap_scope .checkbox label {
+ display: inline;
+ margin-bottom: 0;
+ font-weight: normal;
+ cursor: pointer;
+}
+
+.bootstrap_scope .radio input[type="radio"],
+.bootstrap_scope .radio-inline input[type="radio"],
+.bootstrap_scope .checkbox input[type="checkbox"],
+.bootstrap_scope .checkbox-inline input[type="checkbox"] {
+ float: left;
+ margin-left: -20px;
+}
+
+.bootstrap_scope .radio + .radio,
+.bootstrap_scope .checkbox + .checkbox {
+ margin-top: -5px;
+}
+
+.bootstrap_scope .radio-inline,
+.bootstrap_scope .checkbox-inline {
+ display: inline-block;
+ padding-left: 20px;
+ margin-bottom: 0;
+ font-weight: normal;
+ vertical-align: middle;
+ cursor: pointer;
+}
+
+.bootstrap_scope .radio-inline + .radio-inline,
+.bootstrap_scope .checkbox-inline + .checkbox-inline {
+ margin-top: 0;
+ margin-left: 10px;
+}
+
+.bootstrap_scope .form-control.input-large {
+ height: 56px;
+ padding: 14px 16px;
+ font-size: 18px;
+ border-radius: 6px;
+}
+
+.bootstrap_scope .form-control.input-small {
+ height: 30px;
+ padding: 5px 10px;
+ font-size: 12px;
+ border-radius: 3px;
+}
+
+.bootstrap_scope select.input-large {
+ height: 56px;
+ line-height: 56px;
+}
+
+.bootstrap_scope select.input-small {
+ height: 30px;
+ line-height: 30px;
+}
+
+.bootstrap_scope .has-warning .help-block,
+.bootstrap_scope .has-warning .control-label {
+ color: #c09853;
+}
+
+.bootstrap_scope .has-warning .form-control {
+ padding-right: 32px;
+ border-color: #c09853;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.bootstrap_scope .has-warning .form-control:focus {
+ border-color: #a47e3c;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+}
+
+.bootstrap_scope .has-warning .input-group-addon {
+ color: #c09853;
+ background-color: #fcf8e3;
+ border-color: #c09853;
+}
+
+.bootstrap_scope .has-error .help-block,
+.bootstrap_scope .has-error .control-label {
+ color: #b94a48;
+}
+
+.bootstrap_scope .has-error .form-control {
+ padding-right: 32px;
+ border-color: #b94a48;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.bootstrap_scope .has-error .form-control:focus {
+ border-color: #953b39;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+}
+
+.bootstrap_scope .has-error .input-group-addon {
+ color: #b94a48;
+ background-color: #f2dede;
+ border-color: #b94a48;
+}
+
+.bootstrap_scope .has-success .help-block,
+.bootstrap_scope .has-success .control-label {
+ color: #468847;
+}
+
+.bootstrap_scope .has-success .form-control {
+ padding-right: 32px;
+ border-color: #468847;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.bootstrap_scope .has-success .form-control:focus {
+ border-color: #356635;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+}
+
+.bootstrap_scope .has-success .input-group-addon {
+ color: #468847;
+ background-color: #dff0d8;
+ border-color: #468847;
+}
+
+.bootstrap_scope .help-block {
+ display: block;
+ margin-top: 5px;
+ margin-bottom: 10px;
+ color: #737373;
+}
+
+.bootstrap_scope .input-group {
+ display: table;
+ border-collapse: separate;
+}
+
+.bootstrap_scope .input-group.col {
+ float: none;
+ padding-right: 0;
+ padding-left: 0;
+}
+
+.bootstrap_scope .input-group .form-control {
+ width: 100%;
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .input-group-addon,
+.bootstrap_scope .input-group-btn,
+.bootstrap_scope .input-group .form-control {
+ display: table-cell;
+}
+
+.bootstrap_scope .input-group-addon:not(:first-child):not(:last-child),
+.bootstrap_scope .input-group-btn:not(:first-child):not(:last-child),
+.bootstrap_scope .input-group .form-control:not(:first-child):not(:last-child) {
+ border-radius: 0;
+}
+
+.bootstrap_scope .input-group-addon,
+.bootstrap_scope .input-group-btn {
+ width: 1%;
+ white-space: nowrap;
+ vertical-align: middle;
+}
+
+.bootstrap_scope .input-group-addon {
+ padding: 8px 12px;
+ font-size: 14px;
+ font-weight: normal;
+ line-height: 1.428571429;
+ text-align: center;
+ background-color: #eeeeee;
+ border: 1px solid #cccccc;
+ border-radius: 4px;
+ -webkit-box-sizing: border-box;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+}
+
+.bootstrap_scope .input-group-addon.input-small {
+ padding: 5px 10px;
+ font-size: 12px;
+ border-radius: 3px;
+}
+
+.bootstrap_scope .input-group-addon.input-large {
+ padding: 14px 16px;
+ font-size: 18px;
+ border-radius: 6px;
+}
+
+.bootstrap_scope .input-group .form-control:first-child,
+.bootstrap_scope .input-group-addon:first-child,
+.bootstrap_scope .input-group-btn:first-child > .btn,
+.bootstrap_scope .input-group-btn:first-child > .dropdown-toggle,
+.bootstrap_scope .input-group-btn:last-child > .btn:not(:last-child):not(.dropdown-toggle) {
+ border-top-right-radius: 0;
+ border-bottom-right-radius: 0;
+}
+
+.bootstrap_scope .input-group-addon:first-child {
+ border-right: 0;
+}
+
+.bootstrap_scope .input-group .form-control:last-child,
+.bootstrap_scope .input-group-addon:last-child,
+.bootstrap_scope .input-group-btn:last-child > .btn,
+.bootstrap_scope .input-group-btn:last-child > .dropdown-toggle,
+.bootstrap_scope .input-group-btn:first-child > .btn:not(:first-child) {
+ border-bottom-left-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .input-group-addon:last-child {
+ border-left: 0;
+}
+
+.bootstrap_scope .input-group-btn {
+ position: relative;
+ white-space: nowrap;
+}
+
+.bootstrap_scope .input-group-btn > .btn {
+ position: relative;
+}
+
+.bootstrap_scope .input-group-btn > .btn + .btn {
+ margin-left: -4px;
+}
+
+.bootstrap_scope .input-group-btn > .btn:hover,
+.bootstrap_scope .input-group-btn > .btn:active {
+ z-index: 2;
+}
+
+.bootstrap_scope .form-inline .form-control,
+.bootstrap_scope .form-inline .radio,
+.bootstrap_scope .form-inline .checkbox {
+ display: inline-block;
+}
+
+.bootstrap_scope .form-inline .radio,
+.bootstrap_scope .form-inline .checkbox {
+ margin-top: 0;
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .form-horizontal .control-label {
+ padding-top: 6px;
+}
+
+.bootstrap_scope .form-horizontal .form-group:before,
+.bootstrap_scope .form-horizontal .form-group:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .form-horizontal .form-group:after {
+ clear: both;
+}
+
+.bootstrap_scope .form-horizontal .form-group:before,
+.bootstrap_scope .form-horizontal .form-group:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .form-horizontal .form-group:after {
+ clear: both;
+}
+
+@media (min-width: 768px) {
+ .bootstrap_scope .form-horizontal .form-group {
+ margin-right: -15px;
+ margin-left: -15px;
+ }
+}
+
+.bootstrap_scope .form-horizontal .form-group .row {
+ margin-right: -15px;
+ margin-left: -15px;
+}
+
+@media (min-width: 768px) {
+ .bootstrap_scope .form-horizontal .control-label {
+ text-align: right;
+ }
+}
+
+.bootstrap_scope .btn {
+ display: inline-block;
+ padding: 8px 12px;
+ margin-bottom: 0;
+ font-size: 14px;
+ font-weight: 500;
+ line-height: 1.428571429;
+ text-align: center;
+ white-space: nowrap;
+ vertical-align: middle;
+ cursor: pointer;
+ border: 1px solid transparent;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .btn:focus {
+ outline: thin dotted #333;
+ outline: 5px auto -webkit-focus-ring-color;
+ outline-offset: -2px;
+}
+
+.bootstrap_scope .btn:hover,
+.bootstrap_scope .btn:focus {
+ color: #ffffff;
+ text-decoration: none;
+}
+
+.bootstrap_scope .btn:active,
+.bootstrap_scope .btn.active {
+ outline: 0;
+ -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+ box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+}
+
+.bootstrap_scope .btn.disabled,
+.bootstrap_scope .btn[disabled],
+fieldset[disabled] .bootstrap_scope .btn {
+ pointer-events: none;
+ cursor: default;
+ opacity: 0.65;
+ filter: alpha(opacity=65);
+ -webkit-box-shadow: none;
+ box-shadow: none;
+}
+
+.bootstrap_scope .btn-default {
+ color: #ffffff;
+ background-color: #474949;
+ border-color: #474949;
+}
+
+.bootstrap_scope .btn-default:hover,
+.bootstrap_scope .btn-default:focus,
+.bootstrap_scope .btn-default:active,
+.bootstrap_scope .btn-default.active {
+ background-color: #3a3c3c;
+ border-color: #2e2f2f;
+}
+
+.bootstrap_scope .btn-default.disabled,
+.bootstrap_scope .btn-default[disabled],
+fieldset[disabled] .bootstrap_scope .btn-default,
+.bootstrap_scope .btn-default.disabled:hover,
+.bootstrap_scope .btn-default[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-default:hover,
+.bootstrap_scope .btn-default.disabled:focus,
+.bootstrap_scope .btn-default[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-default:focus,
+.bootstrap_scope .btn-default.disabled:active,
+.bootstrap_scope .btn-default[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-default:active,
+.bootstrap_scope .btn-default.disabled.active,
+.bootstrap_scope .btn-default[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-default.active {
+ background-color: #474949;
+ border-color: #474949;
+}
+
+.bootstrap_scope .btn-primary {
+ color: #ffffff;
+ background-color: #428bca;
+ border-color: #428bca;
+}
+
+.bootstrap_scope .btn-primary:hover,
+.bootstrap_scope .btn-primary:focus,
+.bootstrap_scope .btn-primary:active,
+.bootstrap_scope .btn-primary.active {
+ background-color: #357ebd;
+ border-color: #3071a9;
+}
+
+.bootstrap_scope .btn-primary.disabled,
+.bootstrap_scope .btn-primary[disabled],
+fieldset[disabled] .bootstrap_scope .btn-primary,
+.bootstrap_scope .btn-primary.disabled:hover,
+.bootstrap_scope .btn-primary[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-primary:hover,
+.bootstrap_scope .btn-primary.disabled:focus,
+.bootstrap_scope .btn-primary[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-primary:focus,
+.bootstrap_scope .btn-primary.disabled:active,
+.bootstrap_scope .btn-primary[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-primary:active,
+.bootstrap_scope .btn-primary.disabled.active,
+.bootstrap_scope .btn-primary[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-primary.active {
+ background-color: #428bca;
+ border-color: #428bca;
+}
+
+.bootstrap_scope .btn-warning {
+ color: #ffffff;
+ background-color: #f0ad4e;
+ border-color: #f0ad4e;
+}
+
+.bootstrap_scope .btn-warning:hover,
+.bootstrap_scope .btn-warning:focus,
+.bootstrap_scope .btn-warning:active,
+.bootstrap_scope .btn-warning.active {
+ background-color: #eea236;
+ border-color: #ec971f;
+}
+
+.bootstrap_scope .btn-warning.disabled,
+.bootstrap_scope .btn-warning[disabled],
+fieldset[disabled] .bootstrap_scope .btn-warning,
+.bootstrap_scope .btn-warning.disabled:hover,
+.bootstrap_scope .btn-warning[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-warning:hover,
+.bootstrap_scope .btn-warning.disabled:focus,
+.bootstrap_scope .btn-warning[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-warning:focus,
+.bootstrap_scope .btn-warning.disabled:active,
+.bootstrap_scope .btn-warning[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-warning:active,
+.bootstrap_scope .btn-warning.disabled.active,
+.bootstrap_scope .btn-warning[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-warning.active {
+ background-color: #f0ad4e;
+ border-color: #f0ad4e;
+}
+
+.bootstrap_scope .btn-danger {
+ color: #ffffff;
+ background-color: #d9534f;
+ border-color: #d9534f;
+}
+
+.bootstrap_scope .btn-danger:hover,
+.bootstrap_scope .btn-danger:focus,
+.bootstrap_scope .btn-danger:active,
+.bootstrap_scope .btn-danger.active {
+ background-color: #d43f3a;
+ border-color: #c9302c;
+}
+
+.bootstrap_scope .btn-danger.disabled,
+.bootstrap_scope .btn-danger[disabled],
+fieldset[disabled] .bootstrap_scope .btn-danger,
+.bootstrap_scope .btn-danger.disabled:hover,
+.bootstrap_scope .btn-danger[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-danger:hover,
+.bootstrap_scope .btn-danger.disabled:focus,
+.bootstrap_scope .btn-danger[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-danger:focus,
+.bootstrap_scope .btn-danger.disabled:active,
+.bootstrap_scope .btn-danger[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-danger:active,
+.bootstrap_scope .btn-danger.disabled.active,
+.bootstrap_scope .btn-danger[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-danger.active {
+ background-color: #d9534f;
+ border-color: #d9534f;
+}
+
+.bootstrap_scope .btn-success {
+ color: #ffffff;
+ background-color: #5cb85c;
+ border-color: #5cb85c;
+}
+
+.bootstrap_scope .btn-success:hover,
+.bootstrap_scope .btn-success:focus,
+.bootstrap_scope .btn-success:active,
+.bootstrap_scope .btn-success.active {
+ background-color: #4cae4c;
+ border-color: #449d44;
+}
+
+.bootstrap_scope .btn-success.disabled,
+.bootstrap_scope .btn-success[disabled],
+fieldset[disabled] .bootstrap_scope .btn-success,
+.bootstrap_scope .btn-success.disabled:hover,
+.bootstrap_scope .btn-success[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-success:hover,
+.bootstrap_scope .btn-success.disabled:focus,
+.bootstrap_scope .btn-success[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-success:focus,
+.bootstrap_scope .btn-success.disabled:active,
+.bootstrap_scope .btn-success[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-success:active,
+.bootstrap_scope .btn-success.disabled.active,
+.bootstrap_scope .btn-success[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-success.active {
+ background-color: #5cb85c;
+ border-color: #5cb85c;
+}
+
+.bootstrap_scope .btn-info {
+ color: #ffffff;
+ background-color: #5bc0de;
+ border-color: #5bc0de;
+}
+
+.bootstrap_scope .btn-info:hover,
+.bootstrap_scope .btn-info:focus,
+.bootstrap_scope .btn-info:active,
+.bootstrap_scope .btn-info.active {
+ background-color: #46b8da;
+ border-color: #31b0d5;
+}
+
+.bootstrap_scope .btn-info.disabled,
+.bootstrap_scope .btn-info[disabled],
+fieldset[disabled] .bootstrap_scope .btn-info,
+.bootstrap_scope .btn-info.disabled:hover,
+.bootstrap_scope .btn-info[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-info:hover,
+.bootstrap_scope .btn-info.disabled:focus,
+.bootstrap_scope .btn-info[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-info:focus,
+.bootstrap_scope .btn-info.disabled:active,
+.bootstrap_scope .btn-info[disabled]:active,
+fieldset[disabled] .bootstrap_scope .btn-info:active,
+.bootstrap_scope .btn-info.disabled.active,
+.bootstrap_scope .btn-info[disabled].active,
+fieldset[disabled] .bootstrap_scope .btn-info.active {
+ background-color: #5bc0de;
+ border-color: #5bc0de;
+}
+
+.bootstrap_scope .btn-link {
+ font-weight: normal;
+ color: #428bca;
+ cursor: pointer;
+ border-radius: 0;
+}
+
+.bootstrap_scope .btn-link,
+.bootstrap_scope .btn-link:active,
+.bootstrap_scope .btn-link[disabled],
+fieldset[disabled] .bootstrap_scope .btn-link {
+ background-color: transparent;
+ -webkit-box-shadow: none;
+ box-shadow: none;
+}
+
+.bootstrap_scope .btn-link,
+.bootstrap_scope .btn-link:hover,
+.bootstrap_scope .btn-link:focus,
+.bootstrap_scope .btn-link:active {
+ border-color: transparent;
+}
+
+.bootstrap_scope .btn-link:hover,
+.bootstrap_scope .btn-link:focus {
+ color: #2a6496;
+ text-decoration: underline;
+ background-color: transparent;
+}
+
+.bootstrap_scope .btn-link[disabled]:hover,
+fieldset[disabled] .bootstrap_scope .btn-link:hover,
+.bootstrap_scope .btn-link[disabled]:focus,
+fieldset[disabled] .bootstrap_scope .btn-link:focus {
+ color: #333333;
+ text-decoration: none;
+}
+
+.bootstrap_scope .btn-large {
+ padding: 14px 16px;
+ font-size: 18px;
+ border-radius: 6px;
+}
+
+.bootstrap_scope .btn-small {
+ padding: 5px 10px;
+ font-size: 12px;
+ line-height: 1.5;
+ border-radius: 3px;
+}
+
+.bootstrap_scope .btn-block {
+ display: block;
+ width: 100%;
+ padding-right: 0;
+ padding-left: 0;
+}
+
+.bootstrap_scope .btn-block + .btn-block {
+ margin-top: 5px;
+}
+
+.bootstrap_scope input[type="submit"].btn-block,
+.bootstrap_scope input[type="reset"].btn-block,
+.bootstrap_scope input[type="button"].btn-block {
+ width: 100%;
+}
+
+.bootstrap_scope .fade {
+ opacity: 0;
+ -webkit-transition: opacity 0.15s linear;
+ transition: opacity 0.15s linear;
+}
+
+.bootstrap_scope .fade.in {
+ opacity: 1;
+}
+
+.bootstrap_scope .collapse {
+ display: none;
+}
+
+.bootstrap_scope .collapse.in {
+ display: block;
+}
+
+.bootstrap_scope .collapsing {
+ position: relative;
+ height: 0;
+ overflow: hidden;
+ -webkit-transition: height 0.35s ease;
+ transition: height 0.35s ease;
+}
+
+.bootstrap_scope .caret {
+ display: inline-block;
+ width: 0;
+ height: 0;
+ margin-left: 2px;
+ vertical-align: middle;
+ border-top: 4px solid #000000;
+ border-right: 4px solid transparent;
+ border-left: 4px solid transparent;
+ content: "";
+}
+
+.bootstrap_scope .dropdown-menu {
+ position: absolute;
+ top: 100%;
+ left: 0;
+ z-index: 1000;
+ display: none;
+ float: left;
+ min-width: 160px;
+ padding: 5px 0;
+ margin: 2px 0 0;
+ list-style: none;
+ background-color: #ffffff;
+ border: 1px solid #cccccc;
+ border: 1px solid rgba(0, 0, 0, 0.15);
+ border-radius: 4px;
+ -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
+ box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
+ background-clip: padding-box;
+}
+
+.bootstrap_scope .dropdown-menu.pull-right {
+ right: 0;
+ left: auto;
+}
+
+.bootstrap_scope .dropdown-menu .divider {
+ height: 1px;
+ margin: 9px 0;
+ overflow: hidden;
+ background-color: #e5e5e5;
+}
+
+.bootstrap_scope .dropdown-menu > li > a {
+ display: block;
+ padding: 3px 20px;
+ clear: both;
+ font-weight: normal;
+ line-height: 1.428571429;
+ color: #333333;
+ white-space: nowrap;
+}
+
+.bootstrap_scope .dropdown-menu > li > a:hover,
+.bootstrap_scope .dropdown-menu > li > a:focus {
+ color: #ffffff;
+ text-decoration: none;
+ background-color: #357ebd;
+ background-image: -webkit-gradient(linear, left 0%, left 100%, from(#428bca), to(#357ebd));
+ background-image: -webkit-linear-gradient(top, #428bca, 0%, #357ebd, 100%);
+ background-image: -moz-linear-gradient(top, #428bca 0%, #357ebd 100%);
+ background-image: linear-gradient(to bottom, #428bca 0%, #357ebd 100%);
+ background-repeat: repeat-x;
+ filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff357ebd', GradientType=0);
+}
+
+.bootstrap_scope .dropdown-menu > .active > a,
+.bootstrap_scope .dropdown-menu > .active > a:hover,
+.bootstrap_scope .dropdown-menu > .active > a:focus {
+ color: #ffffff;
+ text-decoration: none;
+ background-color: #357ebd;
+ background-image: -webkit-gradient(linear, left 0%, left 100%, from(#428bca), to(#357ebd));
+ background-image: -webkit-linear-gradient(top, #428bca, 0%, #357ebd, 100%);
+ background-image: -moz-linear-gradient(top, #428bca 0%, #357ebd 100%);
+ background-image: linear-gradient(to bottom, #428bca 0%, #357ebd 100%);
+ background-repeat: repeat-x;
+ outline: 0;
+ filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff357ebd', GradientType=0);
+}
+
+.bootstrap_scope .dropdown-menu > .disabled > a,
+.bootstrap_scope .dropdown-menu > .disabled > a:hover,
+.bootstrap_scope .dropdown-menu > .disabled > a:focus {
+ color: #999999;
+}
+
+.bootstrap_scope .dropdown-menu > .disabled > a:hover,
+.bootstrap_scope .dropdown-menu > .disabled > a:focus {
+ text-decoration: none;
+ cursor: not-allowed;
+ background-color: transparent;
+ background-image: none;
+ filter: progid:DXImageTransform.Microsoft.gradient(enabled=false);
+}
+
+.bootstrap_scope .open > .dropdown-menu {
+ display: block;
+}
+
+.bootstrap_scope .open > a {
+ outline: 0;
+}
+
+.bootstrap_scope .dropdown-header {
+ display: block;
+ padding: 3px 20px;
+ font-size: 12px;
+ line-height: 1.428571429;
+ color: #999999;
+}
+
+.bootstrap_scope .dropdown-backdrop {
+ position: fixed;
+ top: 0;
+ right: 0;
+ bottom: 0;
+ left: 0;
+ z-index: 990;
+}
+
+.bootstrap_scope .pull-right > .dropdown-menu {
+ right: 0;
+ left: auto;
+}
+
+.bootstrap_scope .dropup .caret,
+.bootstrap_scope .navbar-fixed-bottom .dropdown .caret {
+ border-top: 0;
+ border-bottom: 4px solid #000000;
+ content: "";
+}
+
+.bootstrap_scope .dropup .dropdown-menu,
+.bootstrap_scope .navbar-fixed-bottom .dropdown .dropdown-menu {
+ top: auto;
+ bottom: 100%;
+ margin-bottom: 1px;
+}
+
+.bootstrap_scope .list-group {
+ padding-left: 0;
+ margin-bottom: 20px;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .list-group-item {
+ position: relative;
+ display: block;
+ padding: 10px 30px 10px 15px;
+ margin-bottom: -1px;
+ border: 1px solid #dddddd;
+}
+
+.bootstrap_scope .list-group-item:first-child {
+ border-top-right-radius: 4px;
+ border-top-left-radius: 4px;
+}
+
+.bootstrap_scope .list-group-item:last-child {
+ margin-bottom: 0;
+ border-bottom-right-radius: 4px;
+ border-bottom-left-radius: 4px;
+}
+
+.bootstrap_scope .list-group-item > .badge {
+ float: right;
+ margin-right: -15px;
+}
+
+.bootstrap_scope .list-group-item-heading {
+ margin-top: 0;
+ margin-bottom: 5px;
+}
+
+.bootstrap_scope .list-group-item-text {
+ margin-bottom: 0;
+ line-height: 1.3;
+}
+
+.bootstrap_scope a.list-group-item .list-group-item-heading {
+ color: #333333;
+}
+
+.bootstrap_scope a.list-group-item .list-group-item-text {
+ color: #555555;
+}
+
+.bootstrap_scope a.list-group-item:hover,
+.bootstrap_scope a.list-group-item:focus {
+ text-decoration: none;
+ background-color: #f5f5f5;
+}
+
+.bootstrap_scope a.list-group-item.active {
+ z-index: 2;
+ color: #ffffff;
+ background-color: #428bca;
+ border-color: #428bca;
+}
+
+.bootstrap_scope a.list-group-item.active .list-group-item-heading {
+ color: inherit;
+}
+
+.bootstrap_scope a.list-group-item.active .list-group-item-text {
+ color: #e1edf7;
+}
+
+.bootstrap_scope .panel {
+ padding: 15px;
+ margin-bottom: 20px;
+ background-color: #ffffff;
+ border: 1px solid #dddddd;
+ border-radius: 4px;
+ -webkit-box-shadow: 0 1px 1px rgba(0, 0, 0, 0.05);
+ box-shadow: 0 1px 1px rgba(0, 0, 0, 0.05);
+}
+
+.bootstrap_scope .panel-heading {
+ padding: 10px 15px;
+ margin: -15px -15px 15px;
+ background-color: #f5f5f5;
+ border-bottom: 1px solid #dddddd;
+ border-top-right-radius: 3px;
+ border-top-left-radius: 3px;
+}
+
+.bootstrap_scope .panel-title {
+ margin-top: 0;
+ margin-bottom: 0;
+ font-size: 17.5px;
+ font-weight: 500;
+}
+
+.bootstrap_scope .panel-footer {
+ padding: 10px 15px;
+ margin: 15px -15px -15px;
+ background-color: #f5f5f5;
+ border-top: 1px solid #dddddd;
+ border-bottom-right-radius: 3px;
+ border-bottom-left-radius: 3px;
+}
+
+.bootstrap_scope .panel-primary {
+ border-color: #428bca;
+}
+
+.bootstrap_scope .panel-primary .panel-heading {
+ color: #ffffff;
+ background-color: #428bca;
+ border-color: #428bca;
+}
+
+.bootstrap_scope .panel-success {
+ border-color: #d6e9c6;
+}
+
+.bootstrap_scope .panel-success .panel-heading {
+ color: #468847;
+ background-color: #dff0d8;
+ border-color: #d6e9c6;
+}
+
+.bootstrap_scope .panel-warning {
+ border-color: #fbeed5;
+}
+
+.bootstrap_scope .panel-warning .panel-heading {
+ color: #c09853;
+ background-color: #fcf8e3;
+ border-color: #fbeed5;
+}
+
+.bootstrap_scope .panel-danger {
+ border-color: #eed3d7;
+}
+
+.bootstrap_scope .panel-danger .panel-heading {
+ color: #b94a48;
+ background-color: #f2dede;
+ border-color: #eed3d7;
+}
+
+.bootstrap_scope .panel-info {
+ border-color: #bce8f1;
+}
+
+.bootstrap_scope .panel-info .panel-heading {
+ color: #3a87ad;
+ background-color: #d9edf7;
+ border-color: #bce8f1;
+}
+
+.bootstrap_scope .list-group-flush {
+ margin: 15px -15px -15px;
+}
+
+.bootstrap_scope .list-group-flush .list-group-item {
+ border-width: 1px 0;
+}
+
+.bootstrap_scope .list-group-flush .list-group-item:first-child {
+ border-top-right-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .list-group-flush .list-group-item:last-child {
+ border-bottom: 0;
+}
+
+.bootstrap_scope .well {
+ min-height: 20px;
+ padding: 19px;
+ margin-bottom: 20px;
+ background-color: #f5f5f5;
+ border: 1px solid #e3e3e3;
+ border-radius: 4px;
+ -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+ box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+}
+
+.bootstrap_scope .well blockquote {
+ border-color: #ddd;
+ border-color: rgba(0, 0, 0, 0.15);
+}
+
+.bootstrap_scope .well-large {
+ padding: 24px;
+ border-radius: 6px;
+}
+
+.bootstrap_scope .well-small {
+ padding: 9px;
+ border-radius: 3px;
+}
+
+.bootstrap_scope .close {
+ float: right;
+ font-size: 21px;
+ font-weight: bold;
+ line-height: 1;
+ color: #000000;
+ text-shadow: 0 1px 0 #ffffff;
+ opacity: 0.2;
+ filter: alpha(opacity=20);
+}
+
+.bootstrap_scope .close:hover,
+.bootstrap_scope .close:focus {
+ color: #000000;
+ text-decoration: none;
+ cursor: pointer;
+ opacity: 0.5;
+ filter: alpha(opacity=50);
+}
+
+button.bootstrap_scope .close {
+ padding: 0;
+ cursor: pointer;
+ background: transparent;
+ border: 0;
+ -webkit-appearance: none;
+}
+
+.bootstrap_scope .nav {
+ padding-left: 0;
+ margin-bottom: 0;
+ list-style: none;
+}
+
+.bootstrap_scope .nav:before,
+.bootstrap_scope .nav:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .nav:after {
+ clear: both;
+}
+
+.bootstrap_scope .nav:before,
+.bootstrap_scope .nav:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .nav:after {
+ clear: both;
+}
+
+.bootstrap_scope .nav > li {
+ position: relative;
+ display: block;
+}
+
+.bootstrap_scope .nav > li > a {
+ position: relative;
+ display: block;
+ padding: 10px 15px;
+}
+
+.bootstrap_scope .nav > li > a:hover,
+.bootstrap_scope .nav > li > a:focus {
+ text-decoration: none;
+ background-color: #eeeeee;
+}
+
+.bootstrap_scope .nav > li.disabled > a {
+ color: #999999;
+}
+
+.bootstrap_scope .nav > li.disabled > a:hover,
+.bootstrap_scope .nav > li.disabled > a:focus {
+ color: #999999;
+ text-decoration: none;
+ cursor: not-allowed;
+ background-color: transparent;
+}
+
+.bootstrap_scope .nav > li + .nav-header {
+ margin-top: 9px;
+}
+
+.bootstrap_scope .nav.open > a,
+.bootstrap_scope .nav.open > a:hover,
+.bootstrap_scope .nav.open > a:focus {
+ color: #ffffff;
+ background-color: #428bca;
+ border-color: #428bca;
+}
+
+.bootstrap_scope .nav.open > a .caret,
+.bootstrap_scope .nav.open > a:hover .caret,
+.bootstrap_scope .nav.open > a:focus .caret {
+ border-top-color: #ffffff;
+ border-bottom-color: #ffffff;
+}
+
+.bootstrap_scope .nav > .pull-right {
+ float: right;
+}
+
+.bootstrap_scope .nav .nav-divider {
+ height: 1px;
+ margin: 9px 0;
+ overflow: hidden;
+ background-color: #e5e5e5;
+}
+
+.bootstrap_scope .nav-tabs {
+ border-bottom: 1px solid #dddddd;
+}
+
+.bootstrap_scope .nav-tabs > li {
+ float: left;
+ margin-bottom: -1px;
+}
+
+.bootstrap_scope .nav-tabs > li > a {
+ margin-right: 2px;
+ line-height: 1.428571429;
+ border: 1px solid transparent;
+ border-radius: 4px 4px 0 0;
+}
+
+.bootstrap_scope .nav-tabs > li > a:hover {
+ border-color: #eeeeee;
+}
+
+.bootstrap_scope .nav-tabs > li.active > a,
+.bootstrap_scope .nav-tabs > li.active > a:hover,
+.bootstrap_scope .nav-tabs > li.active > a:focus {
+ color: #555555;
+ cursor: default;
+ background-color: #ffffff;
+ border: 1px solid #dddddd;
+ border-bottom-color: transparent;
+}
+
+.bootstrap_scope .nav-tabs.nav-justified {
+ width: 100%;
+ border-bottom: 0;
+}
+
+.bootstrap_scope .nav-tabs.nav-justified > li {
+ display: table-cell;
+ float: none;
+ width: 1%;
+}
+
+.bootstrap_scope .nav-tabs.nav-justified > li > a {
+ text-align: center;
+}
+
+.bootstrap_scope .nav-tabs.nav-justified > li > a {
+ margin-right: 0;
+ border-bottom: 1px solid #dddddd;
+}
+
+.bootstrap_scope .nav-tabs.nav-justified > .active > a {
+ border-bottom-color: #ffffff;
+}
+
+.bootstrap_scope .nav-pills > li {
+ float: left;
+}
+
+.bootstrap_scope .nav-pills > li > a {
+ border-radius: 5px;
+}
+
+.bootstrap_scope .nav-pills > li + li {
+ margin-left: 2px;
+}
+
+.bootstrap_scope .nav-pills > li.active > a,
+.bootstrap_scope .nav-pills > li.active > a:hover,
+.bootstrap_scope .nav-pills > li.active > a:focus {
+ color: #ffffff;
+ background-color: #428bca;
+}
+
+.bootstrap_scope .nav-stacked > li {
+ float: none;
+}
+
+.bootstrap_scope .nav-stacked > li + li > a {
+ margin-top: 2px;
+ margin-left: 0;
+}
+
+.bootstrap_scope .nav-justified {
+ width: 100%;
+}
+
+.bootstrap_scope .nav-justified > li {
+ display: table-cell;
+ float: none;
+ width: 1%;
+}
+
+.bootstrap_scope .nav-justified > li > a {
+ text-align: center;
+}
+
+.bootstrap_scope .nav-tabs-justified {
+ border-bottom: 0;
+}
+
+.bootstrap_scope .nav-tabs-justified > li > a {
+ margin-right: 0;
+ border-bottom: 1px solid #dddddd;
+}
+
+.bootstrap_scope .nav-tabs-justified > .active > a {
+ border-bottom-color: #ffffff;
+}
+
+.bootstrap_scope .tabbable:before,
+.bootstrap_scope .tabbable:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .tabbable:after {
+ clear: both;
+}
+
+.bootstrap_scope .tabbable:before,
+.bootstrap_scope .tabbable:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .tabbable:after {
+ clear: both;
+}
+
+.bootstrap_scope .tab-content > .tab-pane,
+.bootstrap_scope .pill-content > .pill-pane {
+ display: none;
+}
+
+.bootstrap_scope .tab-content > .active,
+.bootstrap_scope .pill-content > .active {
+ display: block;
+}
+
+.bootstrap_scope .nav .caret {
+ border-top-color: #428bca;
+ border-bottom-color: #428bca;
+}
+
+.bootstrap_scope .nav a:hover .caret {
+ border-top-color: #2a6496;
+ border-bottom-color: #2a6496;
+}
+
+.bootstrap_scope .nav-tabs .dropdown-menu {
+ margin-top: -1px;
+ border-top-right-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .navbar {
+ position: relative;
+ min-height: 50px;
+ padding-right: 15px;
+ padding-left: 15px;
+ margin-bottom: 20px;
+ background-color: #eeeeee;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .navbar:before,
+.bootstrap_scope .navbar:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .navbar:after {
+ clear: both;
+}
+
+.bootstrap_scope .navbar:before,
+.bootstrap_scope .navbar:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .navbar:after {
+ clear: both;
+}
+
+.bootstrap_scope .navbar-nav {
+ margin-top: 10px;
+ margin-bottom: 15px;
+}
+
+.bootstrap_scope .navbar-nav > li > a {
+ padding-top: 15px;
+ padding-bottom: 15px;
+ line-height: 20px;
+ color: #777777;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .navbar-nav > li > a:hover,
+.bootstrap_scope .navbar-nav > li > a:focus {
+ color: #333333;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-nav > .active > a,
+.bootstrap_scope .navbar-nav > .active > a:hover,
+.bootstrap_scope .navbar-nav > .active > a:focus {
+ color: #555555;
+ background-color: #d5d5d5;
+}
+
+.bootstrap_scope .navbar-nav > .disabled > a,
+.bootstrap_scope .navbar-nav > .disabled > a:hover,
+.bootstrap_scope .navbar-nav > .disabled > a:focus {
+ color: #cccccc;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-nav.pull-right {
+ width: 100%;
+}
+
+.bootstrap_scope .navbar-static-top {
+ border-radius: 0;
+}
+
+.bootstrap_scope .navbar-fixed-top,
+.bootstrap_scope .navbar-fixed-bottom {
+ position: fixed;
+ right: 0;
+ left: 0;
+ z-index: 1030;
+ border-radius: 0;
+}
+
+.bootstrap_scope .navbar-fixed-top {
+ top: 0;
+}
+
+.bootstrap_scope .navbar-fixed-bottom {
+ bottom: 0;
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .navbar-brand {
+ display: block;
+ max-width: 200px;
+ padding: 15px 15px;
+ margin-right: auto;
+ margin-left: auto;
+ font-size: 18px;
+ font-weight: 500;
+ line-height: 20px;
+ color: #777777;
+ text-align: center;
+}
+
+.bootstrap_scope .navbar-brand:hover,
+.bootstrap_scope .navbar-brand:focus {
+ color: #5e5e5e;
+ text-decoration: none;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-toggle {
+ position: absolute;
+ top: 9px;
+ right: 10px;
+ width: 48px;
+ height: 32px;
+ padding: 8px 12px;
+ background-color: transparent;
+ border: 1px solid #dddddd;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .navbar-toggle:hover,
+.bootstrap_scope .navbar-toggle:focus {
+ background-color: #dddddd;
+}
+
+.bootstrap_scope .navbar-toggle .icon-bar {
+ display: block;
+ width: 22px;
+ height: 2px;
+ background-color: #cccccc;
+ border-radius: 1px;
+}
+
+.bootstrap_scope .navbar-toggle .icon-bar + .icon-bar {
+ margin-top: 4px;
+}
+
+.bootstrap_scope .navbar-form {
+ margin-top: 6px;
+ margin-bottom: 6px;
+}
+
+.bootstrap_scope .navbar-form .form-control,
+.bootstrap_scope .navbar-form .radio,
+.bootstrap_scope .navbar-form .checkbox {
+ display: inline-block;
+}
+
+.bootstrap_scope .navbar-form .radio,
+.bootstrap_scope .navbar-form .checkbox {
+ margin-top: 0;
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .navbar-nav > li > .dropdown-menu {
+ margin-top: 0;
+ border-top-right-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .navbar-fixed-bottom .navbar-nav > li > .dropdown-menu {
+ border-bottom-right-radius: 0;
+ border-bottom-left-radius: 0;
+}
+
+.bootstrap_scope .navbar-nav > .dropdown > a:hover .caret,
+.bootstrap_scope .navbar-nav > .dropdown > a:focus .caret {
+ border-top-color: #333333;
+ border-bottom-color: #333333;
+}
+
+.bootstrap_scope .navbar-nav > .open > a,
+.bootstrap_scope .navbar-nav > .open > a:hover,
+.bootstrap_scope .navbar-nav > .open > a:focus {
+ color: #555555;
+ background-color: #d5d5d5;
+}
+
+.bootstrap_scope .navbar-nav > .open > a .caret,
+.bootstrap_scope .navbar-nav > .open > a:hover .caret,
+.bootstrap_scope .navbar-nav > .open > a:focus .caret {
+ border-top-color: #555555;
+ border-bottom-color: #555555;
+}
+
+.bootstrap_scope .navbar-nav > .dropdown > a .caret {
+ border-top-color: #777777;
+ border-bottom-color: #777777;
+}
+
+.bootstrap_scope .navbar-nav.pull-right > li > .dropdown-menu,
+.bootstrap_scope .navbar-nav > li > .dropdown-menu.pull-right {
+ right: 0;
+ left: auto;
+}
+
+.bootstrap_scope .navbar-inverse {
+ background-color: #222222;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-brand {
+ color: #999999;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-brand:hover,
+.bootstrap_scope .navbar-inverse .navbar-brand:focus {
+ color: #ffffff;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-text {
+ color: #999999;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > li > a {
+ color: #999999;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > li > a:hover,
+.bootstrap_scope .navbar-inverse .navbar-nav > li > a:focus {
+ color: #ffffff;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .active > a,
+.bootstrap_scope .navbar-inverse .navbar-nav > .active > a:hover,
+.bootstrap_scope .navbar-inverse .navbar-nav > .active > a:focus {
+ color: #ffffff;
+ background-color: #080808;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .disabled > a,
+.bootstrap_scope .navbar-inverse .navbar-nav > .disabled > a:hover,
+.bootstrap_scope .navbar-inverse .navbar-nav > .disabled > a:focus {
+ color: #444444;
+ background-color: transparent;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-toggle {
+ border-color: #333333;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-toggle:hover,
+.bootstrap_scope .navbar-inverse .navbar-toggle:focus {
+ background-color: #333333;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-toggle .icon-bar {
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a,
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a:hover,
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a:focus {
+ color: #ffffff;
+ background-color: #080808;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .dropdown > a:hover .caret {
+ border-top-color: #ffffff;
+ border-bottom-color: #ffffff;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .dropdown > a .caret {
+ border-top-color: #999999;
+ border-bottom-color: #999999;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a .caret,
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a:hover .caret,
+.bootstrap_scope .navbar-inverse .navbar-nav > .open > a:focus .caret {
+ border-top-color: #ffffff;
+ border-bottom-color: #ffffff;
+}
+
+@media screen and (min-width: 768px) {
+ .bootstrap_scope .navbar-brand {
+ float: left;
+ margin-right: 5px;
+ margin-left: -15px;
+ }
+ .bootstrap_scope .navbar-nav {
+ float: left;
+ margin-top: 0;
+ margin-bottom: 0;
+ }
+ .bootstrap_scope .navbar-nav > li {
+ float: left;
+ }
+ .bootstrap_scope .navbar-nav > li > a {
+ border-radius: 0;
+ }
+ .bootstrap_scope .navbar-nav.pull-right {
+ float: right;
+ width: auto;
+ }
+ .bootstrap_scope .navbar-toggle {
+ position: relative;
+ top: auto;
+ left: auto;
+ display: none;
+ }
+ .bootstrap_scope .nav-collapse.collapse {
+ display: block !important;
+ height: auto !important;
+ overflow: visible !important;
+ }
+}
+
+.bootstrap_scope .navbar-btn {
+ margin-top: 6px;
+}
+
+.bootstrap_scope .navbar-text {
+ margin-top: 15px;
+ margin-bottom: 15px;
+}
+
+.bootstrap_scope .navbar-link {
+ color: #777777;
+}
+
+.bootstrap_scope .navbar-link:hover {
+ color: #333333;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-link {
+ color: #999999;
+}
+
+.bootstrap_scope .navbar-inverse .navbar-link:hover {
+ color: #ffffff;
+}
+
+.bootstrap_scope .btn .caret {
+ border-top-color: #ffffff;
+}
+
+.bootstrap_scope .dropup .btn .caret {
+ border-bottom-color: #ffffff;
+}
+
+.bootstrap_scope .btn-group,
+.bootstrap_scope .btn-group-vertical {
+ position: relative;
+ display: inline-block;
+ vertical-align: middle;
+}
+
+.bootstrap_scope .btn-group > .btn,
+.bootstrap_scope .btn-group-vertical > .btn {
+ position: relative;
+ float: left;
+}
+
+.bootstrap_scope .btn-group > .btn:hover,
+.bootstrap_scope .btn-group-vertical > .btn:hover,
+.bootstrap_scope .btn-group > .btn:active,
+.bootstrap_scope .btn-group-vertical > .btn:active {
+ z-index: 2;
+}
+
+.bootstrap_scope .btn-group .btn + .btn {
+ margin-left: -1px;
+}
+
+.bootstrap_scope .btn-toolbar:before,
+.bootstrap_scope .btn-toolbar:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .btn-toolbar:after {
+ clear: both;
+}
+
+.bootstrap_scope .btn-toolbar:before,
+.bootstrap_scope .btn-toolbar:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .btn-toolbar:after {
+ clear: both;
+}
+
+.bootstrap_scope .btn-toolbar .btn-group {
+ float: left;
+}
+
+.bootstrap_scope .btn-toolbar > .btn + .btn,
+.bootstrap_scope .btn-toolbar > .btn-group + .btn,
+.bootstrap_scope .btn-toolbar > .btn + .btn-group,
+.bootstrap_scope .btn-toolbar > .btn-group + .btn-group {
+ margin-left: 5px;
+}
+
+.bootstrap_scope .btn-group > .btn:not(:first-child):not(:last-child):not(.dropdown-toggle) {
+ border-radius: 0;
+}
+
+.bootstrap_scope .btn-group > .btn:first-child {
+ margin-left: 0;
+}
+
+.bootstrap_scope .btn-group > .btn:first-child:not(:last-child):not(.dropdown-toggle) {
+ border-top-right-radius: 0;
+ border-bottom-right-radius: 0;
+}
+
+.bootstrap_scope .btn-group > .btn:last-child:not(:first-child),
+.bootstrap_scope .btn-group > .dropdown-toggle:not(:first-child) {
+ border-bottom-left-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .btn-group > .btn-group {
+ float: left;
+}
+
+.bootstrap_scope .btn-group > .btn-group:not(:first-child):not(:last-child) > .btn {
+ border-radius: 0;
+}
+
+.bootstrap_scope .btn-group > .btn-group:first-child > .btn:last-child,
+.bootstrap_scope .btn-group > .btn-group:first-child > .dropdown-toggle {
+ border-top-right-radius: 0;
+ border-bottom-right-radius: 0;
+}
+
+.bootstrap_scope .btn-group > .btn-group:last-child > .btn:first-child {
+ border-bottom-left-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .btn-group .dropdown-toggle:active,
+.bootstrap_scope .btn-group.open .dropdown-toggle {
+ outline: 0;
+}
+
+.bootstrap_scope .btn-group > .btn + .dropdown-toggle {
+ padding-right: 8px;
+ padding-left: 8px;
+}
+
+.bootstrap_scope .btn-group > .btn-large + .dropdown-toggle {
+ padding-right: 12px;
+ padding-left: 12px;
+}
+
+.bootstrap_scope .btn-group.open .dropdown-toggle {
+ -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+ box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+}
+
+.bootstrap_scope .btn .caret {
+ margin-left: 0;
+}
+
+.bootstrap_scope .btn-large .caret {
+ border-width: 5px;
+}
+
+.bootstrap_scope .dropup .btn-large .caret {
+ border-bottom-width: 5px;
+}
+
+.bootstrap_scope .btn-group-vertical > .btn {
+ display: block;
+ float: none;
+ width: 100%;
+ max-width: 100%;
+}
+
+.bootstrap_scope .btn-group-vertical > .btn + .btn {
+ margin-top: -1px;
+}
+
+.bootstrap_scope .btn-group-vertical .btn:not(:first-child):not(:last-child) {
+ border-radius: 0;
+}
+
+.bootstrap_scope .btn-group-vertical .btn:first-child {
+ border-bottom-right-radius: 0;
+ border-bottom-left-radius: 0;
+}
+
+.bootstrap_scope .btn-group-vertical .btn:last-child {
+ border-top-right-radius: 0;
+ border-top-left-radius: 0;
+}
+
+.bootstrap_scope .btn-group-justified {
+ display: table;
+ width: 100%;
+}
+
+.bootstrap_scope .btn-group-justified .btn {
+ display: table-cell;
+ float: none;
+ width: 1%;
+}
+
+.bootstrap_scope .btn-group[data-toggle="buttons"] > .btn > input[type="radio"],
+.bootstrap_scope .btn-group[data-toggle="buttons"] > .btn > input[type="checkbox"] {
+ display: none;
+}
+
+.bootstrap_scope .breadcrumb {
+ padding: 8px 15px;
+ margin-bottom: 20px;
+ list-style: none;
+ background-color: #f5f5f5;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .breadcrumb > li {
+ display: inline-block;
+}
+
+.bootstrap_scope .breadcrumb > li + li:before {
+ padding: 0 5px;
+ color: #cccccc;
+ content: "/\00a0";
+}
+
+.bootstrap_scope .breadcrumb > .active {
+ color: #999999;
+}
+
+.bootstrap_scope .pagination {
+ display: inline-block;
+ padding-left: 0;
+ margin: 20px 0;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .pagination > li {
+ display: inline;
+}
+
+.bootstrap_scope .pagination > li > a,
+.bootstrap_scope .pagination > li > span {
+ float: left;
+ padding: 4px 12px;
+ line-height: 1.428571429;
+ text-decoration: none;
+ background-color: #ffffff;
+ border: 1px solid #dddddd;
+ border-left-width: 0;
+}
+
+.bootstrap_scope .pagination > li:first-child > a,
+.bootstrap_scope .pagination > li:first-child > span {
+ border-left-width: 1px;
+ border-bottom-left-radius: 4px;
+ border-top-left-radius: 4px;
+}
+
+.bootstrap_scope .pagination > li:last-child > a,
+.bootstrap_scope .pagination > li:last-child > span {
+ border-top-right-radius: 4px;
+ border-bottom-right-radius: 4px;
+}
+
+.bootstrap_scope .pagination > li > a:hover,
+.bootstrap_scope .pagination > li > a:focus,
+.bootstrap_scope .pagination > .active > a,
+.bootstrap_scope .pagination > .active > span {
+ background-color: #f5f5f5;
+}
+
+.bootstrap_scope .pagination > .active > a,
+.bootstrap_scope .pagination > .active > span {
+ color: #999999;
+ cursor: default;
+}
+
+.bootstrap_scope .pagination > .disabled > span,
+.bootstrap_scope .pagination > .disabled > a,
+.bootstrap_scope .pagination > .disabled > a:hover,
+.bootstrap_scope .pagination > .disabled > a:focus {
+ color: #999999;
+ cursor: not-allowed;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .pagination-large > li > a,
+.bootstrap_scope .pagination-large > li > span {
+ padding: 14px 16px;
+ font-size: 18px;
+}
+
+.bootstrap_scope .pagination-large > li:first-child > a,
+.bootstrap_scope .pagination-large > li:first-child > span {
+ border-bottom-left-radius: 6px;
+ border-top-left-radius: 6px;
+}
+
+.bootstrap_scope .pagination-large > li:last-child > a,
+.bootstrap_scope .pagination-large > li:last-child > span {
+ border-top-right-radius: 6px;
+ border-bottom-right-radius: 6px;
+}
+
+.bootstrap_scope .pagination-small > li > a,
+.bootstrap_scope .pagination-small > li > span {
+ padding: 5px 10px;
+ font-size: 12px;
+}
+
+.bootstrap_scope .pagination-small > li:first-child > a,
+.bootstrap_scope .pagination-small > li:first-child > span {
+ border-bottom-left-radius: 3px;
+ border-top-left-radius: 3px;
+}
+
+.bootstrap_scope .pagination-small > li:last-child > a,
+.bootstrap_scope .pagination-small > li:last-child > span {
+ border-top-right-radius: 3px;
+ border-bottom-right-radius: 3px;
+}
+
+.bootstrap_scope .pager {
+ padding-left: 0;
+ margin: 20px 0;
+ text-align: center;
+ list-style: none;
+}
+
+.bootstrap_scope .pager:before,
+.bootstrap_scope .pager:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .pager:after {
+ clear: both;
+}
+
+.bootstrap_scope .pager:before,
+.bootstrap_scope .pager:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .pager:after {
+ clear: both;
+}
+
+.bootstrap_scope .pager li {
+ display: inline;
+}
+
+.bootstrap_scope .pager li > a,
+.bootstrap_scope .pager li > span {
+ display: inline-block;
+ padding: 5px 14px;
+ background-color: #ffffff;
+ border: 1px solid #dddddd;
+ border-radius: 15px;
+}
+
+.bootstrap_scope .pager li > a:hover,
+.bootstrap_scope .pager li > a:focus {
+ text-decoration: none;
+ background-color: #f5f5f5;
+}
+
+.bootstrap_scope .pager .next > a,
+.bootstrap_scope .pager .next > span {
+ float: right;
+}
+
+.bootstrap_scope .pager .previous > a,
+.bootstrap_scope .pager .previous > span {
+ float: left;
+}
+
+.bootstrap_scope .pager .disabled > a,
+.bootstrap_scope .pager .disabled > a:hover,
+.bootstrap_scope .pager .disabled > a:focus,
+.bootstrap_scope .pager .disabled > span {
+ color: #999999;
+ cursor: not-allowed;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .modal-open {
+ overflow: hidden;
+}
+
+.bootstrap_scope .modal {
+ position: fixed;
+ top: 0;
+ right: 0;
+ bottom: 0;
+ left: 0;
+ z-index: 1040;
+ display: none;
+ overflow: auto;
+ overflow-y: scroll;
+}
+
+.bootstrap_scope .modal.fade .modal-dialog {
+ -webkit-transform: translate(0, -25%);
+ -ms-transform: translate(0, -25%);
+ transform: translate(0, -25%);
+ -webkit-transition: -webkit-transform 0.3s ease-out;
+ -moz-transition: -moz-transform 0.3s ease-out;
+ -o-transition: -o-transform 0.3s ease-out;
+ transition: transform 0.3s ease-out;
+}
+
+.bootstrap_scope .modal.fade.in .modal-dialog {
+ -webkit-transform: translate(0, 0);
+ -ms-transform: translate(0, 0);
+ transform: translate(0, 0);
+}
+
+.bootstrap_scope .modal-dialog {
+ position: relative;
+ top: 0;
+ right: 0;
+ left: 0;
+ z-index: 1050;
+ width: auto;
+ padding: 10px;
+}
+
+.bootstrap_scope .modal-content {
+ position: relative;
+ background-color: #ffffff;
+ border: 1px solid #999999;
+ border: 1px solid rgba(0, 0, 0, 0.2);
+ border-radius: 6px;
+ outline: none;
+ -webkit-box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);
+ box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);
+ background-clip: padding-box;
+}
+
+.bootstrap_scope .modal-backdrop {
+ position: fixed;
+ top: 0;
+ right: 0;
+ bottom: 0;
+ left: 0;
+ z-index: 1030;
+ background-color: #000000;
+}
+
+.bootstrap_scope .modal-backdrop.fade {
+ opacity: 0;
+ filter: alpha(opacity=0);
+}
+
+.bootstrap_scope .modal-backdrop.fade.in {
+ opacity: 0.5;
+ filter: alpha(opacity=50);
+}
+
+.bootstrap_scope .modal-header {
+ min-height: 16.428571429px;
+ padding: 15px;
+ border-bottom: 1px solid #e5e5e5;
+}
+
+.bootstrap_scope .modal-header .close {
+ margin-top: -2px;
+}
+
+.bootstrap_scope .modal-title {
+ margin: 0;
+ line-height: 1.428571429;
+}
+
+.bootstrap_scope .modal-body {
+ position: relative;
+ padding: 20px;
+}
+
+.bootstrap_scope .modal-footer {
+ padding: 19px 20px 20px;
+ margin-top: 15px;
+ text-align: right;
+ border-top: 1px solid #e5e5e5;
+}
+
+.bootstrap_scope .modal-footer:before,
+.bootstrap_scope .modal-footer:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .modal-footer:after {
+ clear: both;
+}
+
+.bootstrap_scope .modal-footer:before,
+.bootstrap_scope .modal-footer:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .modal-footer:after {
+ clear: both;
+}
+
+.bootstrap_scope .modal-footer .btn + .btn {
+ margin-bottom: 0;
+ margin-left: 5px;
+}
+
+.bootstrap_scope .modal-footer .btn-group .btn + .btn {
+ margin-left: -1px;
+}
+
+.bootstrap_scope .modal-footer .btn-block + .btn-block {
+ margin-left: 0;
+}
+
+@media screen and (min-width: 768px) {
+ .bootstrap_scope .modal-dialog {
+ right: auto;
+ left: 50%;
+ width: 560px;
+ padding-top: 30px;
+ padding-bottom: 30px;
+ margin-left: -280px;
+ }
+ .bootstrap_scope .modal-content {
+ -webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);
+ box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);
+ }
+}
+
+.bootstrap_scope .tooltip {
+ position: absolute;
+ z-index: 1030;
+ display: block;
+ font-size: 12px;
+ line-height: 1.4;
+ opacity: 0;
+ filter: alpha(opacity=0);
+ visibility: visible;
+}
+
+.bootstrap_scope .tooltip.in {
+ opacity: 1;
+ filter: alpha(opacity=100);
+}
+
+.bootstrap_scope .tooltip.top {
+ padding: 5px 0;
+ margin-top: -3px;
+}
+
+.bootstrap_scope .tooltip.right {
+ padding: 0 5px;
+ margin-left: 3px;
+}
+
+.bootstrap_scope .tooltip.bottom {
+ padding: 5px 0;
+ margin-top: 3px;
+}
+
+.bootstrap_scope .tooltip.left {
+ padding: 0 5px;
+ margin-left: -3px;
+}
+
+.bootstrap_scope .tooltip-inner {
+ max-width: 200px;
+ padding: 3px 8px;
+ color: #ffffff;
+ text-align: center;
+ text-decoration: none;
+ background-color: rgba(0, 0, 0, 0.9);
+ border-radius: 4px;
+}
+
+.bootstrap_scope .tooltip-arrow {
+ position: absolute;
+ width: 0;
+ height: 0;
+ border-color: transparent;
+ border-style: solid;
+}
+
+.bootstrap_scope .tooltip.top .tooltip-arrow {
+ bottom: 0;
+ left: 50%;
+ margin-left: -5px;
+ border-top-color: rgba(0, 0, 0, 0.9);
+ border-width: 5px 5px 0;
+}
+
+.bootstrap_scope .tooltip.top-left .tooltip-arrow {
+ bottom: 0;
+ left: 5px;
+ border-top-color: rgba(0, 0, 0, 0.9);
+ border-width: 5px 5px 0;
+}
+
+.bootstrap_scope .tooltip.top-right .tooltip-arrow {
+ right: 5px;
+ bottom: 0;
+ border-top-color: rgba(0, 0, 0, 0.9);
+ border-width: 5px 5px 0;
+}
+
+.bootstrap_scope .tooltip.right .tooltip-arrow {
+ top: 50%;
+ left: 0;
+ margin-top: -5px;
+ border-right-color: rgba(0, 0, 0, 0.9);
+ border-width: 5px 5px 5px 0;
+}
+
+.bootstrap_scope .tooltip.left .tooltip-arrow {
+ top: 50%;
+ right: 0;
+ margin-top: -5px;
+ border-left-color: rgba(0, 0, 0, 0.9);
+ border-width: 5px 0 5px 5px;
+}
+
+.bootstrap_scope .tooltip.bottom .tooltip-arrow {
+ top: 0;
+ left: 50%;
+ margin-left: -5px;
+ border-bottom-color: rgba(0, 0, 0, 0.9);
+ border-width: 0 5px 5px;
+}
+
+.bootstrap_scope .tooltip.bottom-left .tooltip-arrow {
+ top: 0;
+ left: 5px;
+ border-bottom-color: rgba(0, 0, 0, 0.9);
+ border-width: 0 5px 5px;
+}
+
+.bootstrap_scope .tooltip.bottom-right .tooltip-arrow {
+ top: 0;
+ right: 5px;
+ border-bottom-color: rgba(0, 0, 0, 0.9);
+ border-width: 0 5px 5px;
+}
+
+.bootstrap_scope .popover {
+ position: absolute;
+ top: 0;
+ left: 0;
+ z-index: 1010;
+ display: none;
+ max-width: 276px;
+ padding: 1px;
+ text-align: left;
+ white-space: normal;
+ background-color: #ffffff;
+ border: 1px solid #cccccc;
+ border: 1px solid rgba(0, 0, 0, 0.2);
+ border-radius: 6px;
+ -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+ box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+ background-clip: padding-box;
+ -webkit-bg-clip: padding-box;
+ -moz-bg-clip: padding;
+}
+
+.bootstrap_scope .popover.top {
+ margin-top: -10px;
+}
+
+.bootstrap_scope .popover.right {
+ margin-left: 10px;
+}
+
+.bootstrap_scope .popover.bottom {
+ margin-top: 10px;
+}
+
+.bootstrap_scope .popover.left {
+ margin-left: -10px;
+}
+
+.bootstrap_scope .popover-title {
+ padding: 8px 14px;
+ margin: 0;
+ font-size: 14px;
+ font-weight: normal;
+ line-height: 18px;
+ background-color: #f7f7f7;
+ border-bottom: 1px solid #ebebeb;
+ border-radius: 5px 5px 0 0;
+}
+
+.bootstrap_scope .popover-content {
+ padding: 9px 14px;
+}
+
+.bootstrap_scope .popover .arrow,
+.bootstrap_scope .popover .arrow:after {
+ position: absolute;
+ display: block;
+ width: 0;
+ height: 0;
+ border-color: transparent;
+ border-style: solid;
+}
+
+.bootstrap_scope .popover .arrow {
+ border-width: 11px;
+}
+
+.bootstrap_scope .popover .arrow:after {
+ border-width: 10px;
+ content: "";
+}
+
+.bootstrap_scope .popover.top .arrow {
+ bottom: -11px;
+ left: 50%;
+ margin-left: -11px;
+ border-top-color: #999999;
+ border-top-color: rgba(0, 0, 0, 0.25);
+ border-bottom-width: 0;
+}
+
+.bootstrap_scope .popover.top .arrow:after {
+ bottom: 1px;
+ margin-left: -10px;
+ border-top-color: #ffffff;
+ border-bottom-width: 0;
+ content: " ";
+}
+
+.bootstrap_scope .popover.right .arrow {
+ top: 50%;
+ left: -11px;
+ margin-top: -11px;
+ border-right-color: #999999;
+ border-right-color: rgba(0, 0, 0, 0.25);
+ border-left-width: 0;
+}
+
+.bootstrap_scope .popover.right .arrow:after {
+ bottom: -10px;
+ left: 1px;
+ border-right-color: #ffffff;
+ border-left-width: 0;
+ content: " ";
+}
+
+.bootstrap_scope .popover.bottom .arrow {
+ top: -11px;
+ left: 50%;
+ margin-left: -11px;
+ border-bottom-color: #999999;
+ border-bottom-color: rgba(0, 0, 0, 0.25);
+ border-top-width: 0;
+}
+
+.bootstrap_scope .popover.bottom .arrow:after {
+ top: 1px;
+ margin-left: -10px;
+ border-bottom-color: #ffffff;
+ border-top-width: 0;
+ content: " ";
+}
+
+.bootstrap_scope .popover.left .arrow {
+ top: 50%;
+ right: -11px;
+ margin-top: -11px;
+ border-left-color: #999999;
+ border-left-color: rgba(0, 0, 0, 0.25);
+ border-right-width: 0;
+}
+
+.bootstrap_scope .popover.left .arrow:after {
+ right: 1px;
+ bottom: -10px;
+ border-left-color: #ffffff;
+ border-right-width: 0;
+ content: " ";
+}
+
+.bootstrap_scope .alert {
+ padding: 10px 35px 10px 15px;
+ margin-bottom: 20px;
+ color: #c09853;
+ background-color: #fcf8e3;
+ border: 1px solid #fbeed5;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .alert h4 {
+ margin-top: 0;
+ color: inherit;
+}
+
+.bootstrap_scope .alert hr {
+ border-top-color: #f8e5be;
+}
+
+.bootstrap_scope .alert .alert-link {
+ font-weight: 500;
+ color: #a47e3c;
+}
+
+.bootstrap_scope .alert .close {
+ position: relative;
+ top: -2px;
+ right: -21px;
+ color: inherit;
+}
+
+.bootstrap_scope .alert-success {
+ color: #468847;
+ background-color: #dff0d8;
+ border-color: #d6e9c6;
+}
+
+.bootstrap_scope .alert-success hr {
+ border-top-color: #c9e2b3;
+}
+
+.bootstrap_scope .alert-success .alert-link {
+ color: #356635;
+}
+
+.bootstrap_scope .alert-danger {
+ color: #b94a48;
+ background-color: #f2dede;
+ border-color: #eed3d7;
+}
+
+.bootstrap_scope .alert-danger hr {
+ border-top-color: #e6c1c7;
+}
+
+.bootstrap_scope .alert-danger .alert-link {
+ color: #953b39;
+}
+
+.bootstrap_scope .alert-info {
+ color: #3a87ad;
+ background-color: #d9edf7;
+ border-color: #bce8f1;
+}
+
+.bootstrap_scope .alert-info hr {
+ border-top-color: #a6e1ec;
+}
+
+.bootstrap_scope .alert-info .alert-link {
+ color: #2d6987;
+}
+
+.bootstrap_scope .alert-block {
+ padding-top: 15px;
+ padding-bottom: 15px;
+}
+
+.bootstrap_scope .alert-block > p,
+.bootstrap_scope .alert-block > ul {
+ margin-bottom: 0;
+}
+
+.bootstrap_scope .alert-block p + p {
+ margin-top: 5px;
+}
+
+.bootstrap_scope .thumbnail,
+.bootstrap_scope .img-thumbnail {
+ padding: 4px;
+ line-height: 1.428571429;
+ background-color: #ffffff;
+ border: 1px solid #dddddd;
+ border-radius: 4px;
+ -webkit-transition: all 0.2s ease-in-out;
+ transition: all 0.2s ease-in-out;
+}
+
+.bootstrap_scope .thumbnail {
+ display: block;
+}
+
+.bootstrap_scope .thumbnail > img,
+.bootstrap_scope .img-thumbnail {
+ display: inline-block;
+ height: auto;
+ max-width: 100%;
+}
+
+.bootstrap_scope a.thumbnail:hover,
+.bootstrap_scope a.thumbnail:focus {
+ border-color: #428bca;
+}
+
+.bootstrap_scope .thumbnail > img {
+ margin-right: auto;
+ margin-left: auto;
+}
+
+.bootstrap_scope .thumbnail .caption {
+ padding: 9px;
+ color: #333333;
+}
+
+.bootstrap_scope .media,
+.bootstrap_scope .media-body {
+ overflow: hidden;
+ zoom: 1;
+}
+
+.bootstrap_scope .media,
+.bootstrap_scope .media .media {
+ margin-top: 15px;
+}
+
+.bootstrap_scope .media:first-child {
+ margin-top: 0;
+}
+
+.bootstrap_scope .media-object {
+ display: block;
+}
+
+.bootstrap_scope .media-heading {
+ margin: 0 0 5px;
+}
+
+.bootstrap_scope .media > .pull-left {
+ margin-right: 10px;
+}
+
+.bootstrap_scope .media > .pull-right {
+ margin-left: 10px;
+}
+
+.bootstrap_scope .media-list {
+ padding-left: 0;
+ list-style: none;
+}
+
+.bootstrap_scope .label {
+ display: inline;
+ padding: .25em .6em;
+ font-size: 75%;
+ font-weight: 500;
+ line-height: 1;
+ color: #ffffff;
+ text-align: center;
+ white-space: nowrap;
+ vertical-align: middle;
+ background-color: #999999;
+ border-radius: .25em;
+}
+
+.bootstrap_scope .label[href]:hover,
+.bootstrap_scope .label[href]:focus {
+ color: #ffffff;
+ text-decoration: none;
+ cursor: pointer;
+ background-color: #808080;
+}
+
+.bootstrap_scope .label-danger {
+ background-color: #d9534f;
+}
+
+.bootstrap_scope .label-danger[href]:hover,
+.bootstrap_scope .label-danger[href]:focus {
+ background-color: #c9302c;
+}
+
+.bootstrap_scope .label-success {
+ background-color: #5cb85c;
+}
+
+.bootstrap_scope .label-success[href]:hover,
+.bootstrap_scope .label-success[href]:focus {
+ background-color: #449d44;
+}
+
+.bootstrap_scope .label-warning {
+ background-color: #f0ad4e;
+}
+
+.bootstrap_scope .label-warning[href]:hover,
+.bootstrap_scope .label-warning[href]:focus {
+ background-color: #ec971f;
+}
+
+.bootstrap_scope .label-info {
+ background-color: #5bc0de;
+}
+
+.bootstrap_scope .label-info[href]:hover,
+.bootstrap_scope .label-info[href]:focus {
+ background-color: #31b0d5;
+}
+
+.bootstrap_scope .badge {
+ display: inline-block;
+ min-width: 10px;
+ padding: 3px 7px;
+ font-size: 12px;
+ font-weight: bold;
+ line-height: 1;
+ color: #ffffff;
+ text-align: center;
+ white-space: nowrap;
+ vertical-align: middle;
+ background-color: #999999;
+ border-radius: 10px;
+}
+
+.bootstrap_scope .badge:empty {
+ display: none;
+}
+
+.bootstrap_scope a.badge:hover,
+.bootstrap_scope a.badge:focus {
+ color: #ffffff;
+ text-decoration: none;
+ cursor: pointer;
+}
+
+.bootstrap_scope .btn .badge {
+ position: relative;
+ top: -1px;
+}
+
+.bootstrap_scope a.list-group-item.active > .badge,
+.bootstrap_scope .nav-pills > .active > a > .badge {
+ color: #428bca;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .nav-pills > li > a > .badge {
+ margin-left: 3px;
+}
+
+@-webkit-keyframes progress-bar-stripes {
+ from {
+ background-position: 40px 0;
+ }
+ to {
+ background-position: 0 0;
+ }
+}
+
+@-moz-keyframes progress-bar-stripes {
+ from {
+ background-position: 40px 0;
+ }
+ to {
+ background-position: 0 0;
+ }
+}
+
+@-ms-keyframes progress-bar-stripes {
+ from {
+ background-position: 40px 0;
+ }
+ to {
+ background-position: 0 0;
+ }
+}
+
+@-o-keyframes progress-bar-stripes {
+ from {
+ background-position: 0 0;
+ }
+ to {
+ background-position: 40px 0;
+ }
+}
+
+@keyframes progress-bar-stripes {
+ from {
+ background-position: 40px 0;
+ }
+ to {
+ background-position: 0 0;
+ }
+}
+
+.bootstrap_scope .progress {
+ height: 20px;
+ margin-bottom: 20px;
+ overflow: hidden;
+ background-color: #f5f5f5;
+ border-radius: 4px;
+ -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+ box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+.bootstrap_scope .progress-bar {
+ float: left;
+ width: 0;
+ height: 100%;
+ font-size: 12px;
+ color: #ffffff;
+ text-align: center;
+ background-color: #428bca;
+ -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+ box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+ -webkit-transition: width 0.6s ease;
+ transition: width 0.6s ease;
+}
+
+.bootstrap_scope .progress-striped .progress-bar {
+ background-color: #428bca;
+ background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+ background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-size: 40px 40px;
+}
+
+.bootstrap_scope .progress.active .progress-bar {
+ -webkit-animation: progress-bar-stripes 2s linear infinite;
+ -moz-animation: progress-bar-stripes 2s linear infinite;
+ -ms-animation: progress-bar-stripes 2s linear infinite;
+ -o-animation: progress-bar-stripes 2s linear infinite;
+ animation: progress-bar-stripes 2s linear infinite;
+}
+
+.bootstrap_scope .progress-bar-danger {
+ background-color: #d9534f;
+}
+
+.progress-striped .bootstrap_scope .progress-bar-danger {
+ background-color: #d9534f;
+ background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+ background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.bootstrap_scope .progress-bar-success {
+ background-color: #5cb85c;
+}
+
+.progress-striped .bootstrap_scope .progress-bar-success {
+ background-color: #5cb85c;
+ background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+ background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.bootstrap_scope .progress-bar-warning {
+ background-color: #f0ad4e;
+}
+
+.progress-striped .bootstrap_scope .progress-bar-warning {
+ background-color: #f0ad4e;
+ background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+ background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.bootstrap_scope .progress-bar-info {
+ background-color: #5bc0de;
+}
+
+.progress-striped .bootstrap_scope .progress-bar-info {
+ background-color: #5bc0de;
+ background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+ background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.bootstrap_scope .accordion {
+ margin-bottom: 20px;
+}
+
+.bootstrap_scope .accordion-group {
+ margin-bottom: 2px;
+ border: 1px solid #e5e5e5;
+ border-radius: 4px;
+}
+
+.bootstrap_scope .accordion-heading {
+ border-bottom: 0;
+}
+
+.bootstrap_scope .accordion-heading .accordion-toggle {
+ display: block;
+ padding: 8px 15px;
+ cursor: pointer;
+}
+
+.bootstrap_scope .accordion-inner {
+ padding: 9px 15px;
+ border-top: 1px solid #e5e5e5;
+}
+
+.bootstrap_scope .carousel {
+ position: relative;
+}
+
+.bootstrap_scope .carousel-inner {
+ position: relative;
+ width: 100%;
+ overflow: hidden;
+}
+
+.bootstrap_scope .carousel-inner > .item {
+ position: relative;
+ display: none;
+ -webkit-transition: 0.6s ease-in-out left;
+ transition: 0.6s ease-in-out left;
+}
+
+.bootstrap_scope .carousel-inner > .item > img,
+.bootstrap_scope .carousel-inner > .item > a > img {
+ display: inline-block;
+ height: auto;
+ max-width: 100%;
+ line-height: 1;
+}
+
+.bootstrap_scope .carousel-inner > .active,
+.bootstrap_scope .carousel-inner > .next,
+.bootstrap_scope .carousel-inner > .prev {
+ display: block;
+}
+
+.bootstrap_scope .carousel-inner > .active {
+ left: 0;
+}
+
+.bootstrap_scope .carousel-inner > .next,
+.bootstrap_scope .carousel-inner > .prev {
+ position: absolute;
+ top: 0;
+ width: 100%;
+}
+
+.bootstrap_scope .carousel-inner > .next {
+ left: 100%;
+}
+
+.bootstrap_scope .carousel-inner > .prev {
+ left: -100%;
+}
+
+.bootstrap_scope .carousel-inner > .next.left,
+.bootstrap_scope .carousel-inner > .prev.right {
+ left: 0;
+}
+
+.bootstrap_scope .carousel-inner > .active.left {
+ left: -100%;
+}
+
+.bootstrap_scope .carousel-inner > .active.right {
+ left: 100%;
+}
+
+.bootstrap_scope .carousel-control {
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ width: 15%;
+ font-size: 20px;
+ color: #ffffff;
+ text-align: center;
+ text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6);
+ opacity: 0.5;
+ filter: alpha(opacity=50);
+}
+
+.bootstrap_scope .carousel-control.left {
+ background-color: rgba(0, 0, 0, 0.0001);
+ background-color: transparent;
+ background-image: -webkit-gradient(linear, 0 top, 100% top, from(rgba(0, 0, 0, 0.5)), to(rgba(0, 0, 0, 0.0001)));
+ background-image: -webkit-linear-gradient(left, color-stop(rgba(0, 0, 0, 0.5) 0), color-stop(rgba(0, 0, 0, 0.0001) 100%));
+ background-image: -moz-linear-gradient(left, rgba(0, 0, 0, 0.5) 0, rgba(0, 0, 0, 0.0001) 100%);
+ background-image: linear-gradient(to right, rgba(0, 0, 0, 0.5) 0, rgba(0, 0, 0, 0.0001) 100%);
+ background-repeat: repeat-x;
+ filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1);
+}
+
+.bootstrap_scope .carousel-control.right {
+ right: 0;
+ left: auto;
+ background-color: rgba(0, 0, 0, 0.5);
+ background-color: transparent;
+ background-image: -webkit-gradient(linear, 0 top, 100% top, from(rgba(0, 0, 0, 0.0001)), to(rgba(0, 0, 0, 0.5)));
+ background-image: -webkit-linear-gradient(left, color-stop(rgba(0, 0, 0, 0.0001) 0), color-stop(rgba(0, 0, 0, 0.5) 100%));
+ background-image: -moz-linear-gradient(left, rgba(0, 0, 0, 0.0001) 0, rgba(0, 0, 0, 0.5) 100%);
+ background-image: linear-gradient(to right, rgba(0, 0, 0, 0.0001) 0, rgba(0, 0, 0, 0.5) 100%);
+ background-repeat: repeat-x;
+ filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1);
+}
+
+.bootstrap_scope .carousel-control:hover,
+.bootstrap_scope .carousel-control:focus {
+ color: #ffffff;
+ text-decoration: none;
+ opacity: 0.9;
+ filter: alpha(opacity=90);
+}
+
+.bootstrap_scope .carousel-control .glyphicon,
+.bootstrap_scope .carousel-control .icon-prev,
+.bootstrap_scope .carousel-control .icon-next {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ z-index: 5;
+ display: inline-block;
+ width: 20px;
+ height: 20px;
+ margin-top: -10px;
+ margin-left: -10px;
+ font-family: serif;
+}
+
+.bootstrap_scope .carousel-control .icon-prev:before {
+ content: '\2039';
+}
+
+.bootstrap_scope .carousel-control .icon-next:before {
+ content: '\203a';
+}
+
+.bootstrap_scope .carousel-indicators {
+ position: absolute;
+ bottom: 10px;
+ left: 50%;
+ z-index: 15;
+ width: 120px;
+ padding-left: 0;
+ margin-left: -60px;
+ text-align: center;
+ list-style: none;
+}
+
+.bootstrap_scope .carousel-indicators li {
+ display: inline-block;
+ width: 10px;
+ height: 10px;
+ margin: 1px;
+ text-indent: -999px;
+ cursor: pointer;
+ border: 1px solid #ffffff;
+ border-radius: 10px;
+}
+
+.bootstrap_scope .carousel-indicators .active {
+ width: 12px;
+ height: 12px;
+ margin: 0;
+ background-color: #ffffff;
+}
+
+.bootstrap_scope .carousel-caption {
+ position: absolute;
+ right: 15%;
+ bottom: 20px;
+ left: 15%;
+ z-index: 10;
+ padding-top: 20px;
+ padding-bottom: 20px;
+ color: #ffffff;
+ text-align: center;
+ text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6);
+}
+
+.bootstrap_scope .carousel-caption .btn {
+ text-shadow: none;
+}
+
+@media screen and (min-width: 768px) {
+ .bootstrap_scope .carousel-control .glyphicon,
+ .bootstrap_scope .carousel-control .icon-prev,
+ .bootstrap_scope .carousel-control .icon-next {
+ width: 30px;
+ height: 30px;
+ margin-top: -15px;
+ margin-left: -15px;
+ font-size: 30px;
+ }
+ .bootstrap_scope .carousel-caption {
+ right: 20%;
+ left: 20%;
+ padding-bottom: 30px;
+ }
+ .bootstrap_scope .carousel-indicators {
+ bottom: 20px;
+ }
+}
+
+.bootstrap_scope .jumbotron {
+ padding: 30px;
+ margin-bottom: 30px;
+ font-size: 21px;
+ font-weight: 200;
+ line-height: 2.1428571435;
+ color: inherit;
+ background-color: #eeeeee;
+}
+
+.bootstrap_scope .jumbotron h1 {
+ line-height: 1;
+ color: inherit;
+}
+
+.bootstrap_scope .jumbotron p {
+ line-height: 1.4;
+}
+
+@media screen and (min-width: 768px) {
+ .bootstrap_scope .jumbotron {
+ padding: 50px 60px;
+ border-radius: 6px;
+ }
+ .bootstrap_scope .jumbotron h1 {
+ font-size: 63px;
+ }
+}
+
+.bootstrap_scope .clearfix:before,
+.bootstrap_scope .clearfix:after {
+ display: table;
+ content: " ";
+}
+
+.bootstrap_scope .clearfix:after {
+ clear: both;
+}
+
+.bootstrap_scope .pull-right {
+ float: right;
+}
+
+.bootstrap_scope .pull-left {
+ float: left;
+}
+
+.bootstrap_scope .hide {
+ display: none !important;
+}
+
+.bootstrap_scope .show {
+ display: block !important;
+}
+
+.bootstrap_scope .invisible {
+ visibility: hidden;
+}
+
+.bootstrap_scope .text-hide {
+ font: 0/0 a;
+ color: transparent;
+ text-shadow: none;
+ background-color: transparent;
+ border: 0;
+}
+
+.bootstrap_scope .affix {
+ position: fixed;
+}
+
+@-ms-viewport {
+ width: device-width;
+}
+
+@media screen and (max-width: 400px) {
+ @-ms-viewport {
+ width: 320px;
+ }
+}
+
+.bootstrap_scope .hidden {
+ display: none !important;
+ visibility: hidden !important;
+}
+
+.bootstrap_scope .visible-sm {
+ display: block !important;
+}
+
+tr.bootstrap_scope .visible-sm {
+ display: table-row !important;
+}
+
+th.bootstrap_scope .visible-sm,
+td.bootstrap_scope .visible-sm {
+ display: table-cell !important;
+}
+
+.bootstrap_scope .visible-md {
+ display: none !important;
+}
+
+tr.bootstrap_scope .visible-md {
+ display: none !important;
+}
+
+th.bootstrap_scope .visible-md,
+td.bootstrap_scope .visible-md {
+ display: none !important;
+}
+
+.bootstrap_scope .visible-lg {
+ display: none !important;
+}
+
+tr.bootstrap_scope .visible-lg {
+ display: none !important;
+}
+
+th.bootstrap_scope .visible-lg,
+td.bootstrap_scope .visible-lg {
+ display: none !important;
+}
+
+.bootstrap_scope .hidden-sm {
+ display: none !important;
+}
+
+tr.bootstrap_scope .hidden-sm {
+ display: none !important;
+}
+
+th.bootstrap_scope .hidden-sm,
+td.bootstrap_scope .hidden-sm {
+ display: none !important;
+}
+
+.bootstrap_scope .hidden-md {
+ display: block !important;
+}
+
+tr.bootstrap_scope .hidden-md {
+ display: table-row !important;
+}
+
+th.bootstrap_scope .hidden-md,
+td.bootstrap_scope .hidden-md {
+ display: table-cell !important;
+}
+
+.bootstrap_scope .hidden-lg {
+ display: block !important;
+}
+
+tr.bootstrap_scope .hidden-lg {
+ display: table-row !important;
+}
+
+th.bootstrap_scope .hidden-lg,
+td.bootstrap_scope .hidden-lg {
+ display: table-cell !important;
+}
+
+@media (min-width: 768px) and (max-width: 991px) {
+ .bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ tr.bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ th.bootstrap_scope .visible-sm,
+ td.bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ .bootstrap_scope .visible-md {
+ display: block !important;
+ }
+ tr.bootstrap_scope .visible-md {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .visible-md,
+ td.bootstrap_scope .visible-md {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .visible-lg {
+ display: none !important;
+ }
+ tr.bootstrap_scope .visible-lg {
+ display: none !important;
+ }
+ th.bootstrap_scope .visible-lg,
+ td.bootstrap_scope .visible-lg {
+ display: none !important;
+ }
+ .bootstrap_scope .hidden-sm {
+ display: block !important;
+ }
+ tr.bootstrap_scope .hidden-sm {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .hidden-sm,
+ td.bootstrap_scope .hidden-sm {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .hidden-md {
+ display: none !important;
+ }
+ tr.bootstrap_scope .hidden-md {
+ display: none !important;
+ }
+ th.bootstrap_scope .hidden-md,
+ td.bootstrap_scope .hidden-md {
+ display: none !important;
+ }
+ .bootstrap_scope .hidden-lg {
+ display: block !important;
+ }
+ tr.bootstrap_scope .hidden-lg {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .hidden-lg,
+ td.bootstrap_scope .hidden-lg {
+ display: table-cell !important;
+ }
+}
+
+@media (min-width: 992px) {
+ .bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ tr.bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ th.bootstrap_scope .visible-sm,
+ td.bootstrap_scope .visible-sm {
+ display: none !important;
+ }
+ .bootstrap_scope .visible-md {
+ display: none !important;
+ }
+ tr.bootstrap_scope .visible-md {
+ display: none !important;
+ }
+ th.bootstrap_scope .visible-md,
+ td.bootstrap_scope .visible-md {
+ display: none !important;
+ }
+ .bootstrap_scope .visible-lg {
+ display: block !important;
+ }
+ tr.bootstrap_scope .visible-lg {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .visible-lg,
+ td.bootstrap_scope .visible-lg {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .hidden-sm {
+ display: block !important;
+ }
+ tr.bootstrap_scope .hidden-sm {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .hidden-sm,
+ td.bootstrap_scope .hidden-sm {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .hidden-md {
+ display: block !important;
+ }
+ tr.bootstrap_scope .hidden-md {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .hidden-md,
+ td.bootstrap_scope .hidden-md {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .hidden-lg {
+ display: none !important;
+ }
+ tr.bootstrap_scope .hidden-lg {
+ display: none !important;
+ }
+ th.bootstrap_scope .hidden-lg,
+ td.bootstrap_scope .hidden-lg {
+ display: none !important;
+ }
+}
+
+.bootstrap_scope .visible-print {
+ display: none !important;
+}
+
+tr.bootstrap_scope .visible-print {
+ display: none !important;
+}
+
+th.bootstrap_scope .visible-print,
+td.bootstrap_scope .visible-print {
+ display: none !important;
+}
+
+@media print {
+ .bootstrap_scope .visible-print {
+ display: block !important;
+ }
+ tr.bootstrap_scope .visible-print {
+ display: table-row !important;
+ }
+ th.bootstrap_scope .visible-print,
+ td.bootstrap_scope .visible-print {
+ display: table-cell !important;
+ }
+ .bootstrap_scope .hidden-print {
+ display: none !important;
+ }
+ tr.bootstrap_scope .hidden-print {
+ display: none !important;
+ }
+ th.bootstrap_scope .hidden-print,
+ td.bootstrap_scope .hidden-print {
+ display: none !important;
+ }
+}
=== added file 'web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap.js'
--- web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap.js 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/static/lib/bootstrap-scoped/bootstrap.js 2013-11-10 13:14:55 +0000
@@ -0,0 +1,2001 @@
+/*!
+ * Bootstrap v3.0.0 by @fat and @mdo
+ * Copyright 2013 Twitter, Inc.
+ * Licensed under http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world by @mdo and @fat.
+ */
+if (typeof jQuery === "undefined") { throw new Error("Bootstrap requires jQuery") }
+
+/* ========================================================================
+ * Bootstrap: transition.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#transitions
+ * ========================================================================
+ * Copyright 2013 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
+ // ============================================================
+
+ function transitionEnd() {
+ var el = document.createElement('bootstrap')
+
+ var transEndEventNames = {
+ 'WebkitTransition' : 'webkitTransitionEnd'
+ , 'MozTransition' : 'transitionend'
+ , 'OTransition' : 'oTransitionEnd otransitionend'
+ , 'transition' : 'transitionend'
+ }
+
+ for (var name in transEndEventNames) {
+ if (el.style[name] !== undefined) {
+ return { end: transEndEventNames[name] }
+ }
+ }
+ }
+
+ // http://blog.alexmaccaw.com/css-transitions
+ $.fn.emulateTransitionEnd = function (duration) {
+ var called = false, $el = this
+ $(this).one($.support.transition.end, function () { called = true })
+ var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
+ setTimeout(callback, duration)
+ return this
+ }
+
+ $(function () {
+ $.support.transition = transitionEnd()
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: alert.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#alerts
+ * ========================================================================
+ * Copyright 2013 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // ALERT CLASS DEFINITION
+ // ======================
+
+ var dismiss = '[data-dismiss="alert"]'
+ var Alert = function (el) {
+ $(el).on('click', dismiss, this.close)
+ }
+
+ Alert.prototype.close = function (e) {
+ var $this = $(this)
+ var selector = $this.attr('data-target')
+
+ if (!selector) {
+ selector = $this.attr('href')
+ selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
+ }
+
+ var $parent = $(selector)
+
+ if (e) e.preventDefault()
+
+ if (!$parent.length) {
+ $parent = $this.hasClass('alert') ? $this : $this.parent()
+ }
+
+ $parent.trigger(e = $.Event('close.bs.alert'))
+
+ if (e.isDefaultPrevented()) return
+
+ $parent.removeClass('in')
+
+ function removeElement() {
+ $parent.trigger('closed.bs.alert').remove()
+ }
+
+ $.support.transition && $parent.hasClass('fade') ?
+ $parent
+ .one($.support.transition.end, removeElement)
+ .emulateTransitionEnd(150) :
+ removeElement()
+ }
+
+
+ // ALERT PLUGIN DEFINITION
+ // =======================
+
+ var old = $.fn.alert
+
+ $.fn.alert = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.alert')
+
+ if (!data) $this.data('bs.alert', (data = new Alert(this)))
+ if (typeof option == 'string') data[option].call($this)
+ })
+ }
+
+ $.fn.alert.Constructor = Alert
+
+
+ // ALERT NO CONFLICT
+ // =================
+
+ $.fn.alert.noConflict = function () {
+ $.fn.alert = old
+ return this
+ }
+
+
+ // ALERT DATA-API
+ // ==============
+
+ $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: button.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#buttons
+ * ========================================================================
+ * Copyright 2013 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // BUTTON PUBLIC CLASS DEFINITION
+ // ==============================
+
+ var Button = function (element, options) {
+ this.$element = $(element)
+ this.options = $.extend({}, Button.DEFAULTS, options)
+ }
+
+ Button.DEFAULTS = {
+ loadingText: 'loading...'
+ }
+
+ Button.prototype.setState = function (state) {
+ var d = 'disabled'
+ var $el = this.$element
+ var val = $el.is('input') ? 'val' : 'html'
+ var data = $el.data()
+
+ state = state + 'Text'
+
+ if (!data.resetText) $el.data('resetText', $el[val]())
+
+ $el[val](data[state] || this.options[state])
+
+ // push to event loop to allow forms to submit
+ setTimeout(function () {
+ state == 'loadingText' ?
+ $el.addClass(d).attr(d, d) :
+ $el.removeClass(d).removeAttr(d);
+ }, 0)
+ }
+
+ Button.prototype.toggle = function () {
+ var $parent = this.$element.closest('[data-toggle="buttons"]')
+
+ if ($parent.length) {
+ var $input = this.$element.find('input')
+ .prop('checked', !this.$element.hasClass('active'))
+ .trigger('change')
+ if ($input.prop('type') === 'radio') $parent.find('.active').removeClass('active')
+ }
+
+ this.$element.toggleClass('active')
+ }
+
+
+ // BUTTON PLUGIN DEFINITION
+ // ========================
+
+ var old = $.fn.button
+
+ $.fn.button = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.button')
+ var options = typeof option == 'object' && option
+
+ if (!data) $this.data('bs.button', (data = new Button(this, options)))
+
+ if (option == 'toggle') data.toggle()
+ else if (option) data.setState(option)
+ })
+ }
+
+ $.fn.button.Constructor = Button
+
+
+ // BUTTON NO CONFLICT
+ // ==================
+
+ $.fn.button.noConflict = function () {
+ $.fn.button = old
+ return this
+ }
+
+
+ // BUTTON DATA-API
+ // ===============
+
+ $(document).on('click.bs.button.data-api', '[data-toggle^=button]', function (e) {
+ var $btn = $(e.target)
+ if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
+ $btn.button('toggle')
+ e.preventDefault()
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: carousel.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#carousel
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // CAROUSEL CLASS DEFINITION
+ // =========================
+
+ var Carousel = function (element, options) {
+ this.$element = $(element)
+ this.$indicators = this.$element.find('.carousel-indicators')
+ this.options = options
+ this.paused =
+ this.sliding =
+ this.interval =
+ this.$active =
+ this.$items = null
+
+ this.options.pause == 'hover' && this.$element
+ .on('mouseenter', $.proxy(this.pause, this))
+ .on('mouseleave', $.proxy(this.cycle, this))
+ }
+
+ Carousel.DEFAULTS = {
+ interval: 5000
+ , pause: 'hover'
+ , wrap: true
+ }
+
+ Carousel.prototype.cycle = function (e) {
+ e || (this.paused = false)
+
+ this.interval && clearInterval(this.interval)
+
+ this.options.interval
+ && !this.paused
+ && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
+
+ return this
+ }
+
+ Carousel.prototype.getActiveIndex = function () {
+ this.$active = this.$element.find('.item.active')
+ this.$items = this.$active.parent().children()
+
+ return this.$items.index(this.$active)
+ }
+
+ Carousel.prototype.to = function (pos) {
+ var that = this
+ var activeIndex = this.getActiveIndex()
+
+ if (pos > (this.$items.length - 1) || pos < 0) return
+
+ if (this.sliding) return this.$element.one('slid', function () { that.to(pos) })
+ if (activeIndex == pos) return this.pause().cycle()
+
+ return this.slide(pos > activeIndex ? 'next' : 'prev', $(this.$items[pos]))
+ }
+
+ Carousel.prototype.pause = function (e) {
+ e || (this.paused = true)
+
+ if (this.$element.find('.next, .prev').length && $.support.transition.end) {
+ this.$element.trigger($.support.transition.end)
+ this.cycle(true)
+ }
+
+ this.interval = clearInterval(this.interval)
+
+ return this
+ }
+
+ Carousel.prototype.next = function () {
+ if (this.sliding) return
+ return this.slide('next')
+ }
+
+ Carousel.prototype.prev = function () {
+ if (this.sliding) return
+ return this.slide('prev')
+ }
+
+ Carousel.prototype.slide = function (type, next) {
+ var $active = this.$element.find('.item.active')
+ var $next = next || $active[type]()
+ var isCycling = this.interval
+ var direction = type == 'next' ? 'left' : 'right'
+ var fallback = type == 'next' ? 'first' : 'last'
+ var that = this
+
+ if (!$next.length) {
+ if (!this.options.wrap) return
+ $next = this.$element.find('.item')[fallback]()
+ }
+
+ this.sliding = true
+
+ isCycling && this.pause()
+
+ var e = $.Event('slide.bs.carousel', { relatedTarget: $next[0], direction: direction })
+
+ if ($next.hasClass('active')) return
+
+ if (this.$indicators.length) {
+ this.$indicators.find('.active').removeClass('active')
+ this.$element.one('slid', function () {
+ var $nextIndicator = $(that.$indicators.children()[that.getActiveIndex()])
+ $nextIndicator && $nextIndicator.addClass('active')
+ })
+ }
+
+ if ($.support.transition && this.$element.hasClass('slide')) {
+ this.$element.trigger(e)
+ if (e.isDefaultPrevented()) return
+ $next.addClass(type)
+ $next[0].offsetWidth // force reflow
+ $active.addClass(direction)
+ $next.addClass(direction)
+ $active
+ .one($.support.transition.end, function () {
+ $next.removeClass([type, direction].join(' ')).addClass('active')
+ $active.removeClass(['active', direction].join(' '))
+ that.sliding = false
+ setTimeout(function () { that.$element.trigger('slid') }, 0)
+ })
+ .emulateTransitionEnd(600)
+ } else {
+ this.$element.trigger(e)
+ if (e.isDefaultPrevented()) return
+ $active.removeClass('active')
+ $next.addClass('active')
+ this.sliding = false
+ this.$element.trigger('slid')
+ }
+
+ isCycling && this.cycle()
+
+ return this
+ }
+
+
+ // CAROUSEL PLUGIN DEFINITION
+ // ==========================
+
+ var old = $.fn.carousel
+
+ $.fn.carousel = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.carousel')
+ var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
+ var action = typeof option == 'string' ? option : options.slide
+
+ if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))
+ if (typeof option == 'number') data.to(option)
+ else if (action) data[action]()
+ else if (options.interval) data.pause().cycle()
+ })
+ }
+
+ $.fn.carousel.Constructor = Carousel
+
+
+ // CAROUSEL NO CONFLICT
+ // ====================
+
+ $.fn.carousel.noConflict = function () {
+ $.fn.carousel = old
+ return this
+ }
+
+
+ // CAROUSEL DATA-API
+ // =================
+
+ $(document).on('click.bs.carousel.data-api', '[data-slide], [data-slide-to]', function (e) {
+ var $this = $(this), href
+ var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+ var options = $.extend({}, $target.data(), $this.data())
+ var slideIndex = $this.attr('data-slide-to')
+ if (slideIndex) options.interval = false
+
+ $target.carousel(options)
+
+ if (slideIndex = $this.attr('data-slide-to')) {
+ $target.data('bs.carousel').to(slideIndex)
+ }
+
+ e.preventDefault()
+ })
+
+ $(window).on('load', function () {
+ $('[data-ride="carousel"]').each(function () {
+ var $carousel = $(this)
+ $carousel.carousel($carousel.data())
+ })
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: collapse.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#collapse
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // COLLAPSE PUBLIC CLASS DEFINITION
+ // ================================
+
+ var Collapse = function (element, options) {
+ this.$element = $(element)
+ this.options = $.extend({}, Collapse.DEFAULTS, options)
+ this.transitioning = null
+
+ if (this.options.parent) this.$parent = $(this.options.parent)
+ if (this.options.toggle) this.toggle()
+ }
+
+ Collapse.DEFAULTS = {
+ toggle: true
+ }
+
+ Collapse.prototype.dimension = function () {
+ var hasWidth = this.$element.hasClass('width')
+ return hasWidth ? 'width' : 'height'
+ }
+
+ Collapse.prototype.show = function () {
+ if (this.transitioning || this.$element.hasClass('in')) return
+
+ var startEvent = $.Event('show.bs.collapse')
+ this.$element.trigger(startEvent)
+ if (startEvent.isDefaultPrevented()) return
+
+ var actives = this.$parent && this.$parent.find('> .panel > .in')
+
+ if (actives && actives.length) {
+ var hasData = actives.data('bs.collapse')
+ if (hasData && hasData.transitioning) return
+ actives.collapse('hide')
+ hasData || actives.data('bs.collapse', null)
+ }
+
+ var dimension = this.dimension()
+
+ this.$element
+ .removeClass('collapse')
+ .addClass('collapsing')
+ [dimension](0)
+
+ this.transitioning = 1
+
+ var complete = function () {
+ this.$element
+ .removeClass('collapsing')
+ .addClass('in')
+ [dimension]('auto')
+ this.transitioning = 0
+ this.$element.trigger('shown.bs.collapse')
+ }
+
+ if (!$.support.transition) return complete.call(this)
+
+ var scrollSize = $.camelCase(['scroll', dimension].join('-'))
+
+ this.$element
+ .one($.support.transition.end, $.proxy(complete, this))
+ .emulateTransitionEnd(350)
+ [dimension](this.$element[0][scrollSize])
+ }
+
+ Collapse.prototype.hide = function () {
+ if (this.transitioning || !this.$element.hasClass('in')) return
+
+ var startEvent = $.Event('hide.bs.collapse')
+ this.$element.trigger(startEvent)
+ if (startEvent.isDefaultPrevented()) return
+
+ var dimension = this.dimension()
+
+ this.$element
+ [dimension](this.$element[dimension]())
+ [0].offsetHeight
+
+ this.$element
+ .addClass('collapsing')
+ .removeClass('collapse')
+ .removeClass('in')
+
+ this.transitioning = 1
+
+ var complete = function () {
+ this.transitioning = 0
+ this.$element
+ .trigger('hidden.bs.collapse')
+ .removeClass('collapsing')
+ .addClass('collapse')
+ }
+
+ if (!$.support.transition) return complete.call(this)
+
+ this.$element
+ [dimension](0)
+ .one($.support.transition.end, $.proxy(complete, this))
+ .emulateTransitionEnd(350)
+ }
+
+ Collapse.prototype.toggle = function () {
+ this[this.$element.hasClass('in') ? 'hide' : 'show']()
+ }
+
+
+ // COLLAPSE PLUGIN DEFINITION
+ // ==========================
+
+ var old = $.fn.collapse
+
+ $.fn.collapse = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.collapse')
+ var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
+
+ if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.collapse.Constructor = Collapse
+
+
+ // COLLAPSE NO CONFLICT
+ // ====================
+
+ $.fn.collapse.noConflict = function () {
+ $.fn.collapse = old
+ return this
+ }
+
+
+ // COLLAPSE DATA-API
+ // =================
+
+ $(document).on('click.bs.collapse.data-api', '[data-toggle=collapse]', function (e) {
+ var $this = $(this), href
+ var target = $this.attr('data-target')
+ || e.preventDefault()
+ || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') //strip for ie7
+ var $target = $(target)
+ var data = $target.data('bs.collapse')
+ var option = data ? 'toggle' : $this.data()
+ var parent = $this.attr('data-parent')
+ var $parent = parent && $(parent)
+
+ if (!data || !data.transitioning) {
+ if ($parent) $parent.find('[data-toggle=collapse][data-parent="' + parent + '"]').not($this).addClass('collapsed')
+ $this[$target.hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
+ }
+
+ $target.collapse(option)
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: dropdown.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#dropdowns
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // DROPDOWN CLASS DEFINITION
+ // =========================
+
+ var backdrop = '.dropdown-backdrop'
+ var toggle = '[data-toggle=dropdown]'
+ var Dropdown = function (element) {
+ var $el = $(element).on('click.bs.dropdown', this.toggle)
+ }
+
+ Dropdown.prototype.toggle = function (e) {
+ var $this = $(this)
+
+ if ($this.is('.disabled, :disabled')) return
+
+ var $parent = getParent($this)
+ var isActive = $parent.hasClass('open')
+
+ clearMenus()
+
+ if (!isActive) {
+ if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
+ // if mobile we we use a backdrop because click events don't delegate
+ $('<div class="dropdown-backdrop"/>').insertAfter($(this)).on('click', clearMenus)
+ }
+
+ $parent.trigger(e = $.Event('show.bs.dropdown'))
+
+ if (e.isDefaultPrevented()) return
+
+ $parent
+ .toggleClass('open')
+ .trigger('shown.bs.dropdown')
+
+ $this.focus()
+ }
+
+ return false
+ }
+
+ Dropdown.prototype.keydown = function (e) {
+ if (!/(38|40|27)/.test(e.keyCode)) return
+
+ var $this = $(this)
+
+ e.preventDefault()
+ e.stopPropagation()
+
+ if ($this.is('.disabled, :disabled')) return
+
+ var $parent = getParent($this)
+ var isActive = $parent.hasClass('open')
+
+ if (!isActive || (isActive && e.keyCode == 27)) {
+ if (e.which == 27) $parent.find(toggle).focus()
+ return $this.click()
+ }
+
+ var $items = $('[role=menu] li:not(.divider):visible a', $parent)
+
+ if (!$items.length) return
+
+ var index = $items.index($items.filter(':focus'))
+
+ if (e.keyCode == 38 && index > 0) index-- // up
+ if (e.keyCode == 40 && index < $items.length - 1) index++ // down
+ if (!~index) index=0
+
+ $items.eq(index).focus()
+ }
+
+ function clearMenus() {
+ $(backdrop).remove()
+ $(toggle).each(function (e) {
+ var $parent = getParent($(this))
+ if (!$parent.hasClass('open')) return
+ $parent.trigger(e = $.Event('hide.bs.dropdown'))
+ if (e.isDefaultPrevented()) return
+ $parent.removeClass('open').trigger('hidden.bs.dropdown')
+ })
+ }
+
+ function getParent($this) {
+ var selector = $this.attr('data-target')
+
+ if (!selector) {
+ selector = $this.attr('href')
+ selector = selector && /#/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+ }
+
+ var $parent = selector && $(selector)
+
+ return $parent && $parent.length ? $parent : $this.parent()
+ }
+
+
+ // DROPDOWN PLUGIN DEFINITION
+ // ==========================
+
+ var old = $.fn.dropdown
+
+ $.fn.dropdown = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('dropdown')
+
+ if (!data) $this.data('dropdown', (data = new Dropdown(this)))
+ if (typeof option == 'string') data[option].call($this)
+ })
+ }
+
+ $.fn.dropdown.Constructor = Dropdown
+
+
+ // DROPDOWN NO CONFLICT
+ // ====================
+
+ $.fn.dropdown.noConflict = function () {
+ $.fn.dropdown = old
+ return this
+ }
+
+
+ // APPLY TO STANDARD DROPDOWN ELEMENTS
+ // ===================================
+
+ $(document)
+ .on('click.bs.dropdown.data-api', clearMenus)
+ .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
+ .on('click.bs.dropdown.data-api' , toggle, Dropdown.prototype.toggle)
+ .on('keydown.bs.dropdown.data-api', toggle + ', [role=menu]' , Dropdown.prototype.keydown)
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: modal.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#modals
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // MODAL CLASS DEFINITION
+ // ======================
+
+ var Modal = function (element, options) {
+ this.options = options
+ this.$element = $(element)
+ this.$backdrop =
+ this.isShown = null
+
+ if (this.options.remote) this.$element.load(this.options.remote)
+ }
+
+ Modal.DEFAULTS = {
+ backdrop: true
+ , keyboard: true
+ , show: true
+ }
+
+ Modal.prototype.toggle = function (_relatedTarget) {
+ return this[!this.isShown ? 'show' : 'hide'](_relatedTarget)
+ }
+
+ Modal.prototype.show = function (_relatedTarget) {
+ var that = this
+ var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
+
+ this.$element.trigger(e)
+
+ if (this.isShown || e.isDefaultPrevented()) return
+
+ this.isShown = true
+
+ this.escape()
+
+ this.$element.on('click.dismiss.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
+
+ this.backdrop(function () {
+ var transition = $.support.transition && that.$element.hasClass('fade')
+
+ if (!that.$element.parent().length) {
+ that.$element.appendTo(document.body) // don't move modals dom position
+ }
+
+ that.$element.show()
+
+ if (transition) {
+ that.$element[0].offsetWidth // force reflow
+ }
+
+ that.$element
+ .addClass('in')
+ .attr('aria-hidden', false)
+
+ that.enforceFocus()
+
+ var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
+
+ transition ?
+ that.$element.find('.modal-dialog') // wait for modal to slide in
+ .one($.support.transition.end, function () {
+ that.$element.focus().trigger(e)
+ })
+ .emulateTransitionEnd(300) :
+ that.$element.focus().trigger(e)
+ })
+ }
+
+ Modal.prototype.hide = function (e) {
+ if (e) e.preventDefault()
+
+ e = $.Event('hide.bs.modal')
+
+ this.$element.trigger(e)
+
+ if (!this.isShown || e.isDefaultPrevented()) return
+
+ this.isShown = false
+
+ this.escape()
+
+ $(document).off('focusin.bs.modal')
+
+ this.$element
+ .removeClass('in')
+ .attr('aria-hidden', true)
+ .off('click.dismiss.modal')
+
+ $.support.transition && this.$element.hasClass('fade') ?
+ this.$element
+ .one($.support.transition.end, $.proxy(this.hideModal, this))
+ .emulateTransitionEnd(300) :
+ this.hideModal()
+ }
+
+ Modal.prototype.enforceFocus = function () {
+ $(document)
+ .off('focusin.bs.modal') // guard against infinite focus loop
+ .on('focusin.bs.modal', $.proxy(function (e) {
+ if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {
+ this.$element.focus()
+ }
+ }, this))
+ }
+
+ Modal.prototype.escape = function () {
+ if (this.isShown && this.options.keyboard) {
+ this.$element.on('keyup.dismiss.bs.modal', $.proxy(function (e) {
+ e.which == 27 && this.hide()
+ }, this))
+ } else if (!this.isShown) {
+ this.$element.off('keyup.dismiss.bs.modal')
+ }
+ }
+
+ Modal.prototype.hideModal = function () {
+ var that = this
+ this.$element.hide()
+ this.backdrop(function () {
+ that.removeBackdrop()
+ that.$element.trigger('hidden.bs.modal')
+ })
+ }
+
+ Modal.prototype.removeBackdrop = function () {
+ this.$backdrop && this.$backdrop.remove()
+ this.$backdrop = null
+ }
+
+ Modal.prototype.backdrop = function (callback) {
+ var that = this
+ var animate = this.$element.hasClass('fade') ? 'fade' : ''
+
+ if (this.isShown && this.options.backdrop) {
+ var doAnimate = $.support.transition && animate
+
+ this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
+ .appendTo(document.body)
+
+ this.$element.on('click.dismiss.modal', $.proxy(function (e) {
+ if (e.target !== e.currentTarget) return
+ this.options.backdrop == 'static'
+ ? this.$element[0].focus.call(this.$element[0])
+ : this.hide.call(this)
+ }, this))
+
+ if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
+
+ this.$backdrop.addClass('in')
+
+ if (!callback) return
+
+ doAnimate ?
+ this.$backdrop
+ .one($.support.transition.end, callback)
+ .emulateTransitionEnd(150) :
+ callback()
+
+ } else if (!this.isShown && this.$backdrop) {
+ this.$backdrop.removeClass('in')
+
+ $.support.transition && this.$element.hasClass('fade')?
+ this.$backdrop
+ .one($.support.transition.end, callback)
+ .emulateTransitionEnd(150) :
+ callback()
+
+ } else if (callback) {
+ callback()
+ }
+ }
+
+
+ // MODAL PLUGIN DEFINITION
+ // =======================
+
+ var old = $.fn.modal
+
+ $.fn.modal = function (option, _relatedTarget) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.modal')
+ var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
+
+ if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
+ if (typeof option == 'string') data[option](_relatedTarget)
+ else if (options.show) data.show(_relatedTarget)
+ })
+ }
+
+ $.fn.modal.Constructor = Modal
+
+
+ // MODAL NO CONFLICT
+ // =================
+
+ $.fn.modal.noConflict = function () {
+ $.fn.modal = old
+ return this
+ }
+
+
+ // MODAL DATA-API
+ // ==============
+
+ $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
+ var $this = $(this)
+ var href = $this.attr('href')
+ var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) //strip for ie7
+ var option = $target.data('modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
+
+ e.preventDefault()
+
+ $target
+ .modal(option, this)
+ .one('hide', function () {
+ $this.is(':visible') && $this.focus()
+ })
+ })
+
+ $(document)
+ .on('show.bs.modal', '.modal', function () { $(document.body).addClass('modal-open') })
+ .on('hidden.bs.modal', '.modal', function () { $(document.body).removeClass('modal-open') })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: tooltip.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#tooltip
+ * Inspired by the original jQuery.tipsy by Jason Frame
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // TOOLTIP PUBLIC CLASS DEFINITION
+ // ===============================
+
+ var Tooltip = function (element, options) {
+ this.type =
+ this.options =
+ this.enabled =
+ this.timeout =
+ this.hoverState =
+ this.$element = null
+
+ this.init('tooltip', element, options)
+ }
+
+ Tooltip.DEFAULTS = {
+ animation: true
+ , placement: 'top'
+ , selector: false
+ , template: '<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>'
+ , trigger: 'hover focus'
+ , title: ''
+ , delay: 0
+ , html: false
+ , container: false
+ }
+
+ Tooltip.prototype.init = function (type, element, options) {
+ this.enabled = true
+ this.type = type
+ this.$element = $(element)
+ this.options = this.getOptions(options)
+
+ var triggers = this.options.trigger.split(' ')
+
+ for (var i = triggers.length; i--;) {
+ var trigger = triggers[i]
+
+ if (trigger == 'click') {
+ this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
+ } else if (trigger != 'manual') {
+ var eventIn = trigger == 'hover' ? 'mouseenter' : 'focus'
+ var eventOut = trigger == 'hover' ? 'mouseleave' : 'blur'
+
+ this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
+ this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
+ }
+ }
+
+ this.options.selector ?
+ (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
+ this.fixTitle()
+ }
+
+ Tooltip.prototype.getDefaults = function () {
+ return Tooltip.DEFAULTS
+ }
+
+ Tooltip.prototype.getOptions = function (options) {
+ options = $.extend({}, this.getDefaults(), this.$element.data(), options)
+
+ if (options.delay && typeof options.delay == 'number') {
+ options.delay = {
+ show: options.delay
+ , hide: options.delay
+ }
+ }
+
+ return options
+ }
+
+ Tooltip.prototype.getDelegateOptions = function () {
+ var options = {}
+ var defaults = this.getDefaults()
+
+ this._options && $.each(this._options, function (key, value) {
+ if (defaults[key] != value) options[key] = value
+ })
+
+ return options
+ }
+
+ Tooltip.prototype.enter = function (obj) {
+ var self = obj instanceof this.constructor ?
+ obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type)
+
+ clearTimeout(self.timeout)
+
+ self.hoverState = 'in'
+
+ if (!self.options.delay || !self.options.delay.show) return self.show()
+
+ self.timeout = setTimeout(function () {
+ if (self.hoverState == 'in') self.show()
+ }, self.options.delay.show)
+ }
+
+ Tooltip.prototype.leave = function (obj) {
+ var self = obj instanceof this.constructor ?
+ obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type)
+
+ clearTimeout(self.timeout)
+
+ self.hoverState = 'out'
+
+ if (!self.options.delay || !self.options.delay.hide) return self.hide()
+
+ self.timeout = setTimeout(function () {
+ if (self.hoverState == 'out') self.hide()
+ }, self.options.delay.hide)
+ }
+
+ Tooltip.prototype.show = function () {
+ var e = $.Event('show.bs.'+ this.type)
+
+ if (this.hasContent() && this.enabled) {
+ this.$element.trigger(e)
+
+ if (e.isDefaultPrevented()) return
+
+ var $tip = this.tip()
+
+ this.setContent()
+
+ if (this.options.animation) $tip.addClass('fade')
+
+ var placement = typeof this.options.placement == 'function' ?
+ this.options.placement.call(this, $tip[0], this.$element[0]) :
+ this.options.placement
+
+ var autoToken = /\s?auto?\s?/i
+ var autoPlace = autoToken.test(placement)
+ if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
+
+ $tip
+ .detach()
+ .css({ top: 0, left: 0, display: 'block' })
+ .addClass(placement)
+
+ this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
+
+ var pos = this.getPosition()
+ var actualWidth = $tip[0].offsetWidth
+ var actualHeight = $tip[0].offsetHeight
+
+ if (autoPlace) {
+ var $parent = this.$element.parent()
+
+ var orgPlacement = placement
+ var docScroll = document.documentElement.scrollTop || document.body.scrollTop
+ var parentWidth = this.options.container == 'body' ? window.innerWidth : $parent.outerWidth()
+ var parentHeight = this.options.container == 'body' ? window.innerHeight : $parent.outerHeight()
+ var parentLeft = this.options.container == 'body' ? 0 : $parent.offset().left
+
+ placement = placement == 'bottom' && pos.top + pos.height + actualHeight - docScroll > parentHeight ? 'top' :
+ placement == 'top' && pos.top - docScroll - actualHeight < 0 ? 'bottom' :
+ placement == 'right' && pos.right + actualWidth > parentWidth ? 'left' :
+ placement == 'left' && pos.left - actualWidth < parentLeft ? 'right' :
+ placement
+
+ $tip
+ .removeClass(orgPlacement)
+ .addClass(placement)
+ }
+
+ var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
+
+ this.applyPlacement(calculatedOffset, placement)
+ this.$element.trigger('shown.bs.' + this.type)
+ }
+ }
+
+ Tooltip.prototype.applyPlacement = function(offset, placement) {
+ var replace
+ var $tip = this.tip()
+ var width = $tip[0].offsetWidth
+ var height = $tip[0].offsetHeight
+
+ // manually read margins because getBoundingClientRect includes difference
+ var marginTop = parseInt($tip.css('margin-top'), 10)
+ var marginLeft = parseInt($tip.css('margin-left'), 10)
+
+ // we must check for NaN for ie 8/9
+ if (isNaN(marginTop)) marginTop = 0
+ if (isNaN(marginLeft)) marginLeft = 0
+
+ offset.top = offset.top + marginTop
+ offset.left = offset.left + marginLeft
+
+ $tip
+ .offset(offset)
+ .addClass('in')
+
+ // check to see if placing tip in new offset caused the tip to resize itself
+ var actualWidth = $tip[0].offsetWidth
+ var actualHeight = $tip[0].offsetHeight
+
+ if (placement == 'top' && actualHeight != height) {
+ replace = true
+ offset.top = offset.top + height - actualHeight
+ }
+
+ if (/bottom|top/.test(placement)) {
+ var delta = 0
+
+ if (offset.left < 0) {
+ delta = offset.left * -2
+ offset.left = 0
+
+ $tip.offset(offset)
+
+ actualWidth = $tip[0].offsetWidth
+ actualHeight = $tip[0].offsetHeight
+ }
+
+ this.replaceArrow(delta - width + actualWidth, actualWidth, 'left')
+ } else {
+ this.replaceArrow(actualHeight - height, actualHeight, 'top')
+ }
+
+ if (replace) $tip.offset(offset)
+ }
+
+ Tooltip.prototype.replaceArrow = function(delta, dimension, position) {
+ this.arrow().css(position, delta ? (50 * (1 - delta / dimension) + "%") : '')
+ }
+
+ Tooltip.prototype.setContent = function () {
+ var $tip = this.tip()
+ var title = this.getTitle()
+
+ $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
+ $tip.removeClass('fade in top bottom left right')
+ }
+
+ Tooltip.prototype.hide = function () {
+ var that = this
+ var $tip = this.tip()
+ var e = $.Event('hide.bs.' + this.type)
+
+ function complete() {
+ if (that.hoverState != 'in') $tip.detach()
+ }
+
+ this.$element.trigger(e)
+
+ if (e.isDefaultPrevented()) return
+
+ $tip.removeClass('in')
+
+ $.support.transition && this.$tip.hasClass('fade') ?
+ $tip
+ .one($.support.transition.end, complete)
+ .emulateTransitionEnd(150) :
+ complete()
+
+ this.$element.trigger('hidden.bs.' + this.type)
+
+ return this
+ }
+
+ Tooltip.prototype.fixTitle = function () {
+ var $e = this.$element
+ if ($e.attr('title') || typeof($e.attr('data-original-title')) != 'string') {
+ $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
+ }
+ }
+
+ Tooltip.prototype.hasContent = function () {
+ return this.getTitle()
+ }
+
+ Tooltip.prototype.getPosition = function () {
+ var el = this.$element[0]
+ return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : {
+ width: el.offsetWidth
+ , height: el.offsetHeight
+ }, this.$element.offset())
+ }
+
+ Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
+ return placement == 'bottom' ? { top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2 } :
+ placement == 'top' ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
+ placement == 'left' ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
+ /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
+ }
+
+ Tooltip.prototype.getTitle = function () {
+ var title
+ var $e = this.$element
+ var o = this.options
+
+ title = $e.attr('data-original-title')
+ || (typeof o.title == 'function' ? o.title.call($e[0]) : o.title)
+
+ return title
+ }
+
+ Tooltip.prototype.tip = function () {
+ return this.$tip = this.$tip || $(this.options.template)
+ }
+
+ Tooltip.prototype.arrow = function () {
+ return this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow')
+ }
+
+ Tooltip.prototype.validate = function () {
+ if (!this.$element[0].parentNode) {
+ this.hide()
+ this.$element = null
+ this.options = null
+ }
+ }
+
+ Tooltip.prototype.enable = function () {
+ this.enabled = true
+ }
+
+ Tooltip.prototype.disable = function () {
+ this.enabled = false
+ }
+
+ Tooltip.prototype.toggleEnabled = function () {
+ this.enabled = !this.enabled
+ }
+
+ Tooltip.prototype.toggle = function (e) {
+ var self = e ? $(e.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type) : this
+ self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
+ }
+
+ Tooltip.prototype.destroy = function () {
+ this.hide().$element.off('.' + this.type).removeData('bs.' + this.type)
+ }
+
+
+ // TOOLTIP PLUGIN DEFINITION
+ // =========================
+
+ var old = $.fn.tooltip
+
+ $.fn.tooltip = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.tooltip')
+ var options = typeof option == 'object' && option
+
+ if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.tooltip.Constructor = Tooltip
+
+
+ // TOOLTIP NO CONFLICT
+ // ===================
+
+ $.fn.tooltip.noConflict = function () {
+ $.fn.tooltip = old
+ return this
+ }
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: popover.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#popovers
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // POPOVER PUBLIC CLASS DEFINITION
+ // ===============================
+
+ var Popover = function (element, options) {
+ this.init('popover', element, options)
+ }
+
+ if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
+
+ Popover.DEFAULTS = $.extend({} , $.fn.tooltip.Constructor.DEFAULTS, {
+ placement: 'right'
+ , trigger: 'click'
+ , content: ''
+ , template: '<div class="popover"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
+ })
+
+
+ // NOTE: POPOVER EXTENDS tooltip.js
+ // ================================
+
+ Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
+
+ Popover.prototype.constructor = Popover
+
+ Popover.prototype.getDefaults = function () {
+ return Popover.DEFAULTS
+ }
+
+ Popover.prototype.setContent = function () {
+ var $tip = this.tip()
+ var title = this.getTitle()
+ var content = this.getContent()
+
+ $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
+ $tip.find('.popover-content')[this.options.html ? 'html' : 'text'](content)
+
+ $tip.removeClass('fade top bottom left right in')
+
+ // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
+ // this manually by checking the contents.
+ if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
+ }
+
+ Popover.prototype.hasContent = function () {
+ return this.getTitle() || this.getContent()
+ }
+
+ Popover.prototype.getContent = function () {
+ var $e = this.$element
+ var o = this.options
+
+ return $e.attr('data-content')
+ || (typeof o.content == 'function' ?
+ o.content.call($e[0]) :
+ o.content)
+ }
+
+ Popover.prototype.arrow = function () {
+ return this.$arrow = this.$arrow || this.tip().find('.arrow')
+ }
+
+ Popover.prototype.tip = function () {
+ if (!this.$tip) this.$tip = $(this.options.template)
+ return this.$tip
+ }
+
+
+ // POPOVER PLUGIN DEFINITION
+ // =========================
+
+ var old = $.fn.popover
+
+ $.fn.popover = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.popover')
+ var options = typeof option == 'object' && option
+
+ if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.popover.Constructor = Popover
+
+
+ // POPOVER NO CONFLICT
+ // ===================
+
+ $.fn.popover.noConflict = function () {
+ $.fn.popover = old
+ return this
+ }
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: scrollspy.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#scrollspy
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // SCROLLSPY CLASS DEFINITION
+ // ==========================
+
+ function ScrollSpy(element, options) {
+ var href
+ var process = $.proxy(this.process, this)
+
+ this.$element = $(element).is('body') ? $(window) : $(element)
+ this.$body = $('body')
+ this.$scrollElement = this.$element.on('scroll.bs.scroll-spy.data-api', process)
+ this.options = $.extend({}, ScrollSpy.DEFAULTS, options)
+ this.selector = (this.options.target
+ || ((href = $(element).attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+ || '') + ' .nav li > a'
+ this.offsets = $([])
+ this.targets = $([])
+ this.activeTarget = null
+
+ this.refresh()
+ this.process()
+ }
+
+ ScrollSpy.DEFAULTS = {
+ offset: 10
+ }
+
+ ScrollSpy.prototype.refresh = function () {
+ var offsetMethod = this.$element[0] == window ? 'offset' : 'position'
+
+ this.offsets = $([])
+ this.targets = $([])
+
+ var self = this
+ var $targets = this.$body
+ .find(this.selector)
+ .map(function () {
+ var $el = $(this)
+ var href = $el.data('target') || $el.attr('href')
+ var $href = /^#\w/.test(href) && $(href)
+
+ return ($href
+ && $href.length
+ && [[ $href[offsetMethod]().top + (!$.isWindow(self.$scrollElement.get(0)) && self.$scrollElement.scrollTop()), href ]]) || null
+ })
+ .sort(function (a, b) { return a[0] - b[0] })
+ .each(function () {
+ self.offsets.push(this[0])
+ self.targets.push(this[1])
+ })
+ }
+
+ ScrollSpy.prototype.process = function () {
+ var scrollTop = this.$scrollElement.scrollTop() + this.options.offset
+ var scrollHeight = this.$scrollElement[0].scrollHeight || this.$body[0].scrollHeight
+ var maxScroll = scrollHeight - this.$scrollElement.height()
+ var offsets = this.offsets
+ var targets = this.targets
+ var activeTarget = this.activeTarget
+ var i
+
+ if (scrollTop >= maxScroll) {
+ return activeTarget != (i = targets.last()[0]) && this.activate(i)
+ }
+
+ for (i = offsets.length; i--;) {
+ activeTarget != targets[i]
+ && scrollTop >= offsets[i]
+ && (!offsets[i + 1] || scrollTop <= offsets[i + 1])
+ && this.activate( targets[i] )
+ }
+ }
+
+ ScrollSpy.prototype.activate = function (target) {
+ this.activeTarget = target
+
+ $(this.selector)
+ .parents('.active')
+ .removeClass('active')
+
+ var selector = this.selector
+ + '[data-target="' + target + '"],'
+ + this.selector + '[href="' + target + '"]'
+
+ var active = $(selector)
+ .parents('li')
+ .addClass('active')
+
+ if (active.parent('.dropdown-menu').length) {
+ active = active
+ .closest('li.dropdown')
+ .addClass('active')
+ }
+
+ active.trigger('activate')
+ }
+
+
+ // SCROLLSPY PLUGIN DEFINITION
+ // ===========================
+
+ var old = $.fn.scrollspy
+
+ $.fn.scrollspy = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.scrollspy')
+ var options = typeof option == 'object' && option
+
+ if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.scrollspy.Constructor = ScrollSpy
+
+
+ // SCROLLSPY NO CONFLICT
+ // =====================
+
+ $.fn.scrollspy.noConflict = function () {
+ $.fn.scrollspy = old
+ return this
+ }
+
+
+ // SCROLLSPY DATA-API
+ // ==================
+
+ $(window).on('load', function () {
+ $('[data-spy="scroll"]').each(function () {
+ var $spy = $(this)
+ $spy.scrollspy($spy.data())
+ })
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: tab.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#tabs
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // TAB CLASS DEFINITION
+ // ====================
+
+ var Tab = function (element) {
+ this.element = $(element)
+ }
+
+ Tab.prototype.show = function () {
+ var $this = this.element
+ var $ul = $this.closest('ul:not(.dropdown-menu)')
+ var selector = $this.data('target')
+
+ if (!selector) {
+ selector = $this.attr('href')
+ selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+ }
+
+ if ($this.parent('li').hasClass('active')) return
+
+ var previous = $ul.find('.active:last a')[0]
+ var e = $.Event('show.bs.tab', {
+ relatedTarget: previous
+ })
+
+ $this.trigger(e)
+
+ if (e.isDefaultPrevented()) return
+
+ var $target = $(selector)
+
+ this.activate($this.parent('li'), $ul)
+ this.activate($target, $target.parent(), function () {
+ $this.trigger({
+ type: 'shown.bs.tab'
+ , relatedTarget: previous
+ })
+ })
+ }
+
+ Tab.prototype.activate = function (element, container, callback) {
+ var $active = container.find('> .active')
+ var transition = callback
+ && $.support.transition
+ && $active.hasClass('fade')
+
+ function next() {
+ $active
+ .removeClass('active')
+ .find('> .dropdown-menu > .active')
+ .removeClass('active')
+
+ element.addClass('active')
+
+ if (transition) {
+ element[0].offsetWidth // reflow for transition
+ element.addClass('in')
+ } else {
+ element.removeClass('fade')
+ }
+
+ if (element.parent('.dropdown-menu')) {
+ element.closest('li.dropdown').addClass('active')
+ }
+
+ callback && callback()
+ }
+
+ transition ?
+ $active
+ .one($.support.transition.end, next)
+ .emulateTransitionEnd(150) :
+ next()
+
+ $active.removeClass('in')
+ }
+
+
+ // TAB PLUGIN DEFINITION
+ // =====================
+
+ var old = $.fn.tab
+
+ $.fn.tab = function ( option ) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.tab')
+
+ if (!data) $this.data('bs.tab', (data = new Tab(this)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.tab.Constructor = Tab
+
+
+ // TAB NO CONFLICT
+ // ===============
+
+ $.fn.tab.noConflict = function () {
+ $.fn.tab = old
+ return this
+ }
+
+
+ // TAB DATA-API
+ // ============
+
+ $(document).on('click.bs.tab.data-api', '[data-toggle="tab"], [data-toggle="pill"]', function (e) {
+ e.preventDefault()
+ $(this).tab('show')
+ })
+
+}(window.jQuery);
+
+/* ========================================================================
+ * Bootstrap: affix.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#affix
+ * ========================================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+ // AFFIX CLASS DEFINITION
+ // ======================
+
+ var Affix = function (element, options) {
+ this.options = $.extend({}, Affix.DEFAULTS, options)
+ this.$window = $(window)
+ .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
+ .on('click.bs.affix.data-api', $.proxy(this.checkPositionWithEventLoop, this))
+
+ this.$element = $(element)
+ this.affixed =
+ this.unpin = null
+
+ this.checkPosition()
+ }
+
+ Affix.RESET = 'affix affix-top affix-bottom'
+
+ Affix.DEFAULTS = {
+ offset: 0
+ }
+
+ Affix.prototype.checkPositionWithEventLoop = function () {
+ setTimeout($.proxy(this.checkPosition, this), 1)
+ }
+
+ Affix.prototype.checkPosition = function () {
+ if (!this.$element.is(':visible')) return
+
+ var scrollHeight = $(document).height()
+ var scrollTop = this.$window.scrollTop()
+ var position = this.$element.offset()
+ var offset = this.options.offset
+ var offsetTop = offset.top
+ var offsetBottom = offset.bottom
+
+ if (typeof offset != 'object') offsetBottom = offsetTop = offset
+ if (typeof offsetTop == 'function') offsetTop = offset.top()
+ if (typeof offsetBottom == 'function') offsetBottom = offset.bottom()
+
+ var affix = this.unpin != null && (scrollTop + this.unpin <= position.top) ? false :
+ offsetBottom != null && (position.top + this.$element.height() >= scrollHeight - offsetBottom) ? 'bottom' :
+ offsetTop != null && (scrollTop <= offsetTop) ? 'top' : false
+
+ if (this.affixed === affix) return
+ if (this.unpin) this.$element.css('top', '')
+
+ this.affixed = affix
+ this.unpin = affix == 'bottom' ? position.top - scrollTop : null
+
+ this.$element.removeClass(Affix.RESET).addClass('affix' + (affix ? '-' + affix : ''))
+
+ if (affix == 'bottom') {
+ this.$element.offset({ top: document.body.offsetHeight - offsetBottom - this.$element.height() })
+ }
+ }
+
+
+ // AFFIX PLUGIN DEFINITION
+ // =======================
+
+ var old = $.fn.affix
+
+ $.fn.affix = function (option) {
+ return this.each(function () {
+ var $this = $(this)
+ var data = $this.data('bs.affix')
+ var options = typeof option == 'object' && option
+
+ if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
+ if (typeof option == 'string') data[option]()
+ })
+ }
+
+ $.fn.affix.Constructor = Affix
+
+
+ // AFFIX NO CONFLICT
+ // =================
+
+ $.fn.affix.noConflict = function () {
+ $.fn.affix = old
+ return this
+ }
+
+
+ // AFFIX DATA-API
+ // ==============
+
+ $(window).on('load', function () {
+ $('[data-spy="affix"]').each(function () {
+ var $spy = $(this)
+ var data = $spy.data()
+
+ data.offset = data.offset || {}
+
+ if (data.offsetBottom) data.offset.bottom = data.offsetBottom
+ if (data.offsetTop) data.offset.top = data.offsetTop
+
+ $spy.affix(data)
+ })
+ })
+
+}(window.jQuery);
\ No newline at end of file
=== added directory 'web_unleashed_extra/static/lib/font-awesome'
=== added directory 'web_unleashed_extra/static/lib/font-awesome/css'
=== added file 'web_unleashed_extra/static/lib/font-awesome/css/font-awesome-ie7.css'
--- web_unleashed_extra/static/lib/font-awesome/css/font-awesome-ie7.css 1970-01-01 00:00:00 +0000
+++ web_unleashed_extra/static/lib/font-awesome/css/font-awesome-ie7.css 2013-11-10 13:14:55 +0000
@@ -0,0 +1,1203 @@
+/*!
+ * Font Awesome 3.2.1
+ * the iconic font designed for Bootstrap
+ * ------------------------------------------------------------------------------
+ * The full suite of pictographic icons, examples, and documentation can be
+ * found at http://fontawesome.io. Stay up to date on Twitter at
+ * http://twitter.com/fontawesome.
+ *
+ * License
+ * ------------------------------------------------------------------------------
+ * - The Font Awesome font is licensed under SIL OFL 1.1 -
+ * http://scripts.sil.org/OFL
+ * - Font Awesome CSS, LESS, and SASS files are licensed under MIT License -
+ * http://opensource.org/licenses/mit-license.html
+ * - Font Awesome documentation licensed under CC BY 3.0 -
+ * http://creativecommons.org/licenses/by/3.0/
+ * - Attribution is no longer required in Font Awesome 3.0, but much appreciated:
+ * "Font Awesome by Dave Gandy - http://fontawesome.io";
+ *
+ * Author - Dave Gandy
+ * ------------------------------------------------------------------------------
+ * Email: dave@xxxxxxxxxxxxxx
+ * Twitter: http://twitter.com/davegandy
+ * Work: Lead Product Designer @ Kyruus - http://kyruus.com
+ */
+.icon-large {
+ font-size: 1.3333333333333333em;
+ margin-top: -4px;
+ padding-top: 3px;
+ margin-bottom: -4px;
+ padding-bottom: 3px;
+ vertical-align: middle;
+}
+.nav [class^="icon-"],
+.nav [class*=" icon-"] {
+ vertical-align: inherit;
+ margin-top: -4px;
+ padding-top: 3px;
+ margin-bottom: -4px;
+ padding-bottom: 3px;
+}
+.nav [class^="icon-"].icon-large,
+.nav [class*=" icon-"].icon-large {
+ vertical-align: -25%;
+}
+.nav-pills [class^="icon-"].icon-large,
+.nav-tabs [class^="icon-"].icon-large,
+.nav-pills [class*=" icon-"].icon-large,
+.nav-tabs [class*=" icon-"].icon-large {
+ line-height: .75em;
+ margin-top: -7px;
+ padding-top: 5px;
+ margin-bottom: -5px;
+ padding-bottom: 4px;
+}
+.btn [class^="icon-"].pull-left,
+.btn [class*=" icon-"].pull-left,
+.btn [class^="icon-"].pull-right,
+.btn [class*=" icon-"].pull-right {
+ vertical-align: inherit;
+}
+.btn [class^="icon-"].icon-large,
+.btn [class*=" icon-"].icon-large {
+ margin-top: -0.5em;
+}
+a [class^="icon-"],
+a [class*=" icon-"] {
+ cursor: pointer;
+}
+.icon-glass {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-music {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-search {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-envelope-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-heart {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-star {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-star-empty {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-user {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-film {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-th-large {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-th {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-th-list {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-ok {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-remove {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-zoom-in {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-zoom-out {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-off {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-power-off {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-signal {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cog {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-gear {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-trash {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-home {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-file-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-time {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-road {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-download-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-download {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-upload {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-inbox {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-play-circle {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-repeat {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-rotate-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-refresh {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-list-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-lock {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-flag {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-headphones {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-volume-off {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-volume-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-volume-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-qrcode {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-barcode {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-tag {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-tags {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-book {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bookmark {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-print {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-camera {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-font {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bold {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-italic {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-text-height {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-text-width {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-align-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-align-center {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-align-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-align-justify {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-list {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-indent-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-indent-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-facetime-video {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-picture {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-pencil {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-map-marker {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-adjust {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-tint {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-edit {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-share {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-check {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-move {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-step-backward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-fast-backward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-backward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-play {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-pause {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-stop {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-forward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-fast-forward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-step-forward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-eject {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-chevron-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-chevron-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-plus-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-minus-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-remove-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-ok-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-question-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-info-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-screenshot {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-remove-circle {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-ok-circle {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-ban-circle {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-arrow-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-arrow-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-arrow-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-arrow-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-share-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-mail-forward {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-resize-full {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-resize-small {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-plus {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-minus {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-asterisk {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-exclamation-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-gift {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-leaf {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-fire {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-eye-open {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-eye-close {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-warning-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-plane {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-calendar {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-random {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-comment {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-magnet {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-chevron-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-chevron-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-retweet {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-shopping-cart {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-folder-close {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-folder-open {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-resize-vertical {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-resize-horizontal {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bar-chart {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-twitter-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-facebook-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-camera-retro {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-key {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cogs {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-gears {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-comments {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-thumbs-up-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-thumbs-down-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-star-half {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-heart-empty {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-signout {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-linkedin-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-pushpin {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-external-link {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-signin {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-trophy {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-github-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-upload-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-lemon {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-phone {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-check-empty {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-unchecked {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bookmark-empty {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-phone-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-twitter {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-facebook {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-github {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-unlock {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-credit-card {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-rss {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hdd {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bullhorn {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bell {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-certificate {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hand-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hand-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hand-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hand-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle-arrow-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle-arrow-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle-arrow-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle-arrow-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-globe {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-wrench {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-tasks {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-filter {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-briefcase {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-fullscreen {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-group {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-link {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cloud {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-beaker {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cut {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-copy {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-paper-clip {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-paperclip {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-save {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-sign-blank {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-reorder {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-list-ul {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-list-ol {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-strikethrough {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-underline {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-table {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-magic {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-truck {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-pinterest {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-pinterest-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-google-plus-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-google-plus {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-money {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-caret-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-caret-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-caret-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-caret-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-columns {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-sort {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-sort-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-sort-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-envelope {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-linkedin {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-undo {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-rotate-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-legal {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-dashboard {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-comment-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-comments-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bolt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-sitemap {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-umbrella {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-paste {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-lightbulb {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-exchange {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cloud-download {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-cloud-upload {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-user-md {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-stethoscope {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-suitcase {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-bell-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-coffee {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-food {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-file-text-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-building {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-hospital {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-ambulance {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-medkit {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-fighter-jet {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-beer {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-h-sign {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-plus-sign-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-double-angle-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-double-angle-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-double-angle-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-double-angle-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-angle-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-angle-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-angle-up {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-angle-down {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-desktop {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-laptop {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-tablet {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-mobile-phone {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle-blank {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-quote-left {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-quote-right {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-spinner {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-circle {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-reply {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-mail-reply {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '');
+}
+.icon-github-alt {
+ *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&
