(function() {
var UnderscoreExtensions,
__slice = Array.prototype.slice;
(window || global).Luca = function() {
var args, definition, fallback, inheritsFrom, payload, result;
payload = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
if (_.isString(payload) && (result = Luca.cache(payload))) return result;
if (_.isString(payload) && (result = Luca.find(payload))) return result;
if (_.isObject(payload) && (payload.ctype != null)) {
return Luca.util.lazyComponent(payload);
}
if (_.isObject(payload) && payload.defines && payload["extends"]) {
definition = payload.defines;
inheritsFrom = payload["extends"];
}
if (_.isFunction(fallback = _(args).last())) return fallback();
};
_.extend(Luca, {
VERSION: "0.9.2",
core: {},
containers: {},
components: {},
modules: {},
util: {},
fields: {},
registry: {},
options: {}
});
_.extend(Luca, Backbone.Events);
Luca.autoRegister = true;
Luca.developmentMode = false;
Luca.enableGlobalObserver = false;
Luca.enableBootstrap = true;
Luca.keys = {
ENTER: 13,
ESCAPE: 27,
KEYLEFT: 37,
KEYUP: 38,
KEYRIGHT: 39,
KEYDOWN: 40,
SPACEBAR: 32,
FORWARDSLASH: 191
};
Luca.keyMap = _(Luca.keys).inject(function(memo, value, symbol) {
memo[value] = symbol.toLowerCase();
return memo;
}, {});
Luca.find = function() {
return;
};
Luca.supportsEvents = Luca.supportsBackboneEvents = function(obj) {
return Luca.isComponent(obj) || (_.isFunction(obj != null ? obj.trigger : void 0) || _.isFunction(obj != null ? obj.bind : void 0));
};
Luca.isComponent = function(obj) {
return Luca.isBackboneModel(obj) || Luca.isBackboneView(obj) || Luca.isBackboneCollection(obj);
};
Luca.isComponentPrototype = function(obj) {
return Luca.isViewPrototype(obj) || Luca.isModelPrototype(obj) || Luca.isCollectionPrototype(obj);
};
Luca.isBackboneModel = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return _.isFunction(obj != null ? obj.set : void 0) && _.isFunction(obj != null ? obj.get : void 0) && _.isObject(obj != null ? obj.attributes : void 0);
};
Luca.isBackboneView = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return _.isFunction(obj != null ? obj.render : void 0) && !_.isUndefined(obj != null ? obj.el : void 0);
};
Luca.isBackboneCollection = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return _.isFunction(obj != null ? obj.fetch : void 0) && _.isFunction(obj != null ? obj.reset : void 0);
};
Luca.isViewPrototype = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return (obj != null) && (obj.prototype != null) && (obj.prototype.make != null) && (obj.prototype.$ != null) && (obj.prototype.render != null);
};
Luca.isModelPrototype = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return (obj != null) && (typeof obj.prototype === "function" ? obj.prototype((obj.prototype.save != null) && (obj.prototype.changedAttributes != null)) : void 0);
};
Luca.isCollectionPrototype = function(obj) {
if (_.isString(obj)) obj = Luca.util.resolve(obj);
return (obj != null) && (obj.prototype != null) && !Luca.isModelPrototype(obj) && (obj.prototype.reset != null) && (obj.prototype.select != null) && (obj.prototype.reject != null);
};
Luca.inheritanceChain = function(obj) {
return _(Luca.parentClasses(obj)).map(function(className) {
return Luca.util.resolve(className);
});
};
Luca.parentClasses = function(obj) {
var classes, list, _ref;
list = [];
if (_.isString(obj)) obj = Luca.util.resolve(obj);
list.push(obj.displayName || ((_ref = obj.prototype) != null ? _ref.displayName : void 0) || Luca.parentClass(obj));
classes = (function() {
var _results;
_results = [];
while (!!(Luca.parentClass(obj) != null)) {
_results.push(obj = Luca.parentClass(obj));
}
return _results;
})();
list = list.concat(classes);
return _.uniq(list);
};
Luca.parentClass = function(obj) {
var list, _base, _ref;
list = [];
if (_.isString(obj)) obj = Luca.util.resolve(obj);
if (Luca.isComponent(obj)) {
return obj.displayName;
} else if (Luca.isComponentPrototype(obj)) {
return typeof (_base = obj.prototype)._superClass === "function" ? (_ref = _base._superClass()) != null ? _ref.displayName : void 0 : void 0;
}
};
Luca.template = function(template_name, variables) {
var jst, luca, needle, template, _ref;
window.JST || (window.JST = {});
if (_.isFunction(template_name)) return template_name(variables);
luca = (_ref = Luca.templates) != null ? _ref[template_name] : void 0;
jst = typeof JST !== "undefined" && JST !== null ? JST[template_name] : void 0;
if (!((luca != null) || (jst != null))) {
needle = new RegExp("" + template_name + "$");
luca = _(Luca.templates).detect(function(fn, template_id) {
return needle.exec(template_id);
});
jst = _(JST).detect(function(fn, template_id) {
return needle.exec(template_id);
});
}
if (!(luca || jst)) throw "Could not find template named " + template_name;
template = luca || jst;
if (variables != null) return template(variables);
return template;
};
Luca.available_templates = function(filter) {
var available;
if (filter == null) filter = "";
available = _(Luca.templates).keys();
if (filter.length > 0) {
return _(available).select(function(tmpl) {
return tmpl.match(filter);
});
} else {
return available;
}
};
UnderscoreExtensions = {
module: function(base, module) {
_.extend(base, module);
if (base.included && _(base.included).isFunction()) {
return base.included.apply(base);
}
},
"delete": function(object, key) {
var value;
value = object[key];
delete object[key];
return value;
},
idle: function(code, delay) {
var handle;
if (delay == null) delay = 1000;
if (window.DISABLE_IDLE) delay = 0;
handle = void 0;
return function() {
if (handle) window.clearTimeout(handle);
return handle = window.setTimeout(_.bind(code, this), delay);
};
},
idleShort: function(code, delay) {
var handle;
if (delay == null) delay = 100;
if (window.DISABLE_IDLE) delay = 0;
handle = void 0;
return function() {
if (handle) window.clearTimeout(handle);
return handle = window.setTimeout(_.bind(code, this), delay);
};
},
idleMedium: function(code, delay) {
var handle;
if (delay == null) delay = 2000;
if (window.DISABLE_IDLE) delay = 0;
handle = void 0;
return function() {
if (handle) window.clearTimeout(handle);
return handle = window.setTimeout(_.bind(code, this), delay);
};
},
idleLong: function(code, delay) {
var handle;
if (delay == null) delay = 5000;
if (window.DISABLE_IDLE) delay = 0;
handle = void 0;
return function() {
if (handle) window.clearTimeout(handle);
return handle = window.setTimeout(_.bind(code, this), delay);
};
}
};
_.mixin(UnderscoreExtensions);
}).call(this);
(function() {
var DeferredBindingProxy;
DeferredBindingProxy = (function() {
function DeferredBindingProxy(object, operation, wrapWithUnderscore) {
var fn,
_this = this;
this.object = object;
if (wrapWithUnderscore == null) wrapWithUnderscore = true;
if (_.isFunction(operation)) {
fn = operation;
} else if (_.isString(operation) && _.isFunction(this.object[operation])) {
fn = this.object[operation];
}
if (!_.isFunction(fn)) {
throw "Must pass a function or a string representing one";
}
if (wrapWithUnderscore === true) {
this.fn = function() {
return _.defer(fn);
};
} else {
this.fn = fn;
}
this;
}
DeferredBindingProxy.prototype.until = function(watch, trigger) {
if ((watch != null) && !(trigger != null)) {
trigger = watch;
watch = this.object;
}
watch.once(trigger, this.fn);
return this.object;
};
return DeferredBindingProxy;
})();
Luca.Events = {
defer: function(operation, wrapWithUnderscore) {
if (wrapWithUnderscore == null) wrapWithUnderscore = true;
return new DeferredBindingProxy(this, operation, wrapWithUnderscore);
},
once: function(trigger, callback, context) {
var onceFn;
context || (context = this);
onceFn = function() {
callback.apply(context, arguments);
return this.unbind(trigger, onceFn);
};
return this.bind(trigger, onceFn);
}
};
}).call(this);
(function() {
var currentNamespace;
Luca.util.resolve = function(accessor, source_object) {
source_object || (source_object = window || global);
return _(accessor.split(/\./)).inject(function(obj, key) {
return obj = obj != null ? obj[key] : void 0;
}, source_object);
};
Luca.util.nestedValue = Luca.util.resolve;
Luca.util.classify = function(string) {
if (string == null) string = "";
return _.string.camelize(_.string.capitalize(string));
};
Luca.util.hook = function(eventId) {
var fn, parts, prefix;
if (eventId == null) eventId = "";
parts = eventId.split(':');
prefix = parts.shift();
parts = _(parts).map(function(p) {
return _.string.capitalize(p);
});
return fn = prefix + parts.join('');
};
Luca.util.isIE = function() {
try {
Object.defineProperty({}, '', {});
return false;
} catch (e) {
return true;
}
};
currentNamespace = window || global;
Luca.util.namespace = function(namespace) {
if (namespace == null) return currentNamespace;
currentNamespace = _.isString(namespace) ? Luca.util.resolve(namespace, window || global) : namespace;
if (currentNamespace != null) return currentNamespace;
return currentNamespace = eval("(window||global)." + namespace + " = {}");
};
Luca.util.lazyComponent = function(config) {
var componentClass, constructor, ctype;
if (_.isObject(config)) ctype = config.ctype || config.type;
if (_.isString(config)) ctype = config;
componentClass = Luca.registry.lookup(ctype);
if (!componentClass) {
throw "Invalid Component Type: " + ctype + ". Did you forget to register it?";
}
constructor = eval(componentClass);
return new constructor(config);
};
Luca.util.selectProperties = function(iterator, object, context) {
var values;
values = _(object).values();
return _(values).select(iterator);
};
Luca.util.loadScript = function(url, callback) {
var script;
script = document.createElement("script");
script.type = "text/javascript";
if (script.readyState) {
script.onreadystatechange = function() {
if (script.readyState === "loaded" || script.readyState === "complete") {
script.onreadystatechange = null;
return callback();
} else {
return script.onload = function() {
return callback();
};
}
};
}
script.src = url;
return document.body.appendChild(script);
};
Luca.util.make = Backbone.View.prototype.make;
Luca.util.label = function(contents, type, baseClass) {
var cssClass;
if (contents == null) contents = "";
if (baseClass == null) baseClass = "label";
cssClass = baseClass;
if (type != null) cssClass += " " + baseClass + "-" + type;
return Luca.util.make("span", {
"class": cssClass
}, contents);
};
Luca.util.badge = function(contents, type, baseClass) {
var cssClass;
if (contents == null) contents = "";
if (baseClass == null) baseClass = "badge";
cssClass = baseClass;
if (type != null) cssClass += " " + baseClass + "-" + type;
return Luca.util.make("span", {
"class": cssClass
}, contents);
};
}).call(this);
(function() {
var DefineProxy;
Luca.define = function(componentName) {
return new DefineProxy(componentName);
};
Luca.component = Luca.define;
DefineProxy = (function() {
function DefineProxy(componentName) {
var parts;
this.namespace = Luca.util.namespace();
this.componentId = this.componentName = componentName;
if (componentName.match(/\./)) {
this.namespaced = true;
parts = componentName.split('.');
this.componentId = parts.pop();
this.namespace = parts.join('.');
Luca.registry.addNamespace(parts.join('.'));
}
}
DefineProxy.prototype["in"] = function(namespace) {
this.namespace = namespace;
return this;
};
DefineProxy.prototype.from = function(superClassName) {
this.superClassName = superClassName;
return this;
};
DefineProxy.prototype["extends"] = function(superClassName) {
this.superClassName = superClassName;
return this;
};
DefineProxy.prototype.extend = function(superClassName) {
this.superClassName = superClassName;
return this;
};
DefineProxy.prototype.enhance = function(properties) {
if (properties != null) return this["with"](properties);
return this;
};
DefineProxy.prototype["with"] = function(properties) {
var at, componentType, _base;
at = this.namespaced ? Luca.util.resolve(this.namespace, window || global) : window || global;
if (this.namespaced && !(at != null)) {
eval("(window||global)." + this.namespace + " = {}");
at = Luca.util.resolve(this.namespace, window || global);
}
at[this.componentId] = Luca.extend(this.superClassName, this.componentName, properties);
if (Luca.autoRegister === true) {
if (Luca.isViewPrototype(at[this.componentId])) componentType = "view";
if (Luca.isCollectionPrototype(at[this.componentId])) {
(_base = Luca.Collection).namespaces || (_base.namespaces = []);
Luca.Collection.namespaces.push(this.namespace);
componentType = "collection";
}
if (Luca.isModelPrototype(at[this.componentId])) componentType = "model";
Luca.register(_.string.underscored(this.componentId), this.componentName, componentType);
}
return at[this.componentId];
};
return DefineProxy;
})();
Luca.extend = function(superClassName, childName, properties) {
var superClass;
if (properties == null) properties = {};
superClass = Luca.util.resolve(superClassName, window || global);
if (!_.isFunction(superClass != null ? superClass.extend : void 0)) {
throw "" + superClassName + " is not a valid component to extend from";
}
properties.displayName = childName;
properties._superClass = function() {
superClass.displayName || (superClass.displayName = superClassName);
return superClass;
};
properties._super = function(method, context, args) {
var _ref;
return (_ref = this._superClass().prototype[method]) != null ? _ref.apply(context, args) : void 0;
};
return superClass.extend(properties);
};
_.mixin({
def: Luca.define
});
}).call(this);
(function() {
var component_cache, registry;
registry = {
classes: {},
model_classes: {},
collection_classes: {},
namespaces: ['Luca.containers', 'Luca.components']
};
component_cache = {
cid_index: {},
name_index: {}
};
Luca.defaultComponentType = 'view';
Luca.register = function(component, prototypeName, componentType) {
if (componentType == null) componentType = "view";
Luca.trigger("component:registered", component, prototypeName);
switch (componentType) {
case "model":
return registry.model_classes[component] = prototypeName;
case "collection":
return registry.model_classes[component] = prototypeName;
default:
return registry.classes[component] = prototypeName;
}
};
Luca.development_mode_register = function(component, prototypeName) {
var existing, liveInstances, prototypeDefinition;
existing = registry.classes[component];
if (Luca.enableDevelopmentTools === true && (existing != null)) {
prototypeDefinition = Luca.util.resolve(existing, window);
liveInstances = Luca.registry.findInstancesByClassName(prototypeName);
_(liveInstances).each(function(instance) {
var _ref;
return instance != null ? (_ref = instance.refreshCode) != null ? _ref.call(instance, prototypeDefinition) : void 0 : void 0;
});
}
return Luca.register(component, prototypeName);
};
Luca.registry.addNamespace = function(identifier) {
registry.namespaces.push(identifier);
return registry.namespaces = _(registry.namespaces).uniq();
};
Luca.registry.namespaces = function(resolve) {
if (resolve == null) resolve = true;
return _(registry.namespaces).map(function(namespace) {
if (resolve) {
return Luca.util.resolve(namespace);
} else {
return namespace;
}
});
};
Luca.registry.lookup = function(ctype) {
var c, className, fullPath, parents, _ref;
c = registry.classes[ctype];
if (c != null) return c;
className = Luca.util.classify(ctype);
parents = Luca.registry.namespaces();
return fullPath = (_ref = _(parents).chain().map(function(parent) {
return parent[className];
}).compact().value()) != null ? _ref[0] : void 0;
};
Luca.registry.findInstancesByClassName = function(className) {
var instances;
instances = _(component_cache.cid_index).values();
return _(instances).select(function(instance) {
var _ref;
return instance.displayName === className || (typeof instance._superClass === "function" ? (_ref = instance._superClass()) != null ? _ref.displayName : void 0 : void 0) === className;
});
};
Luca.registry.classes = function(toString) {
if (toString == null) toString = false;
return _(_.extend({}, registry.classes, registry.model_classes, registry.collection_classes)).map(function(className, ctype) {
if (toString) {
return className;
} else {
return {
className: className,
ctype: ctype
};
}
});
};
Luca.cache = function(needle, component) {
var lookup_id;
if (component != null) component_cache.cid_index[needle] = component;
component = component_cache.cid_index[needle];
if ((component != null ? component.component_name : void 0) != null) {
Luca.trigger("component:created:" + component.component_name, component);
component_cache.name_index[component.component_name] = component.cid;
} else if ((component != null ? component.name : void 0) != null) {
Luca.trigger("component:created:" + component.component_name, component);
component_cache.name_index[component.name] = component.cid;
}
if (component != null) return component;
lookup_id = component_cache.name_index[needle];
return component_cache.cid_index[lookup_id];
};
}).call(this);
(function() {
var customizeRender, originalExtend;
_.def("Luca.View")["extends"]("Backbone.View")["with"]({
include: ['Luca.Events'],
additionalClassNames: [],
hooks: ["after:initialize", "before:render", "after:render", "first:activation", "activation", "deactivation"],
debug: function() {
var message, _i, _len, _results;
if (!(this.debugMode || (window.LucaDebugMode != null))) return;
_results = [];
for (_i = 0, _len = arguments.length; _i < _len; _i++) {
message = arguments[_i];
_results.push(console.log([this.name || this.cid, message]));
}
return _results;
},
trigger: function() {
if (Luca.enableGlobalObserver) {
if (Luca.developmentMode === true || this.observeEvents === true) {
Luca.ViewObserver || (Luca.ViewObserver = new Luca.Observer({
type: "view"
}));
Luca.ViewObserver.relay(this, arguments);
}
}
return Backbone.View.prototype.trigger.apply(this, arguments);
},
initialize: function(options) {
var additional, template, unique, _i, _len, _ref;
this.options = options != null ? options : {};
_.extend(this, this.options);
if (this.name != null) this.cid = _.uniqueId(this.name);
if (template = this.bodyTemplate) {
this.$el.empty();
Luca.View.prototype.$html.call(this, Luca.template(template, this));
}
Luca.cache(this.cid, this);
unique = _(Luca.View.prototype.hooks.concat(this.hooks)).uniq();
this.setupHooks(unique);
if (this.autoBindEventHandlers === true) this.bindAllEventHandlers();
if (this.additionalClassNames) {
if (_.isString(this.additionalClassNames)) {
this.additionalClassNames = this.additionalClassNames.split(" ");
}
_ref = this.additionalClassNames;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
additional = _ref[_i];
this.$el.addClass(additional);
}
}
if (this.wrapperClass != null) this.$wrap(this.wrapperClass);
this.trigger("after:initialize", this);
this.registerCollectionEvents();
return this.delegateEvents();
},
$wrap: function(wrapper) {
if (_.isString(wrapper) && !wrapper.match(/[<>]/)) {
wrapper = this.make("div", {
"class": wrapper
});
}
return this.$el.wrap(wrapper);
},
$template: function(template, variables) {
if (variables == null) variables = {};
return this.$el.html(Luca.template(template, variables));
},
$html: function(content) {
return this.$el.html(content);
},
$append: function(content) {
return this.$el.append(content);
},
$attach: function() {
return this.$container().append(this.el);
},
$container: function() {
return $(this.container);
},
setupHooks: function(set) {
var _this = this;
set || (set = this.hooks);
return _(set).each(function(eventId) {
var callback, fn;
fn = Luca.util.hook(eventId);
callback = function() {
var _ref;
return (_ref = _this[fn]) != null ? _ref.apply(_this, arguments) : void 0;
};
if (eventId != null ? eventId.match(/once:/) : void 0) {
callback = _.once(callback);
}
return _this.bind(eventId, callback);
});
},
getCollectionManager: function() {
var _base;
return this.collectionManager || (typeof (_base = Luca.CollectionManager).get === "function" ? _base.get() : void 0);
},
registerCollectionEvents: function() {
var manager,
_this = this;
manager = this.getCollectionManager();
return _(this.collectionEvents).each(function(handler, signature) {
var collection, event, key, _ref;
_ref = signature.split(" "), key = _ref[0], event = _ref[1];
collection = _this["" + key + "Collection"] = manager.getOrCreate(key);
if (!collection) throw "Could not find collection specified by " + key;
if (_.isString(handler)) handler = _this[handler];
if (!_.isFunction(handler)) throw "invalid collectionEvents configuration";
try {
return collection.bind(event, handler);
} catch (e) {
console.log("Error Binding To Collection in registerCollectionEvents", _this);
throw e;
}
});
},
registerEvent: function(selector, handler) {
this.events || (this.events = {});
this.events[selector] = handler;
return this.delegateEvents();
},
bindAllEventHandlers: function() {
var _this = this;
return _(this.events).each(function(handler, event) {
if (_.isString(handler)) return _.bindAll(_this, handler);
});
},
definitionClass: function() {
var _ref;
return (_ref = Luca.util.resolve(this.displayName, window)) != null ? _ref.prototype : void 0;
},
refreshCode: function() {
var view;
view = this;
_(this.eventHandlerProperties()).each(function(prop) {
return view[prop] = view.definitionClass()[prop];
});
if (this.autoBindEventHandlers === true) this.bindAllEventHandlers();
return this.delegateEvents();
},
eventHandlerProperties: function() {
var handlerIds;
handlerIds = _(this.events).values();
return _(handlerIds).select(function(v) {
return _.isString(v);
});
},
eventHandlerFunctions: function() {
var handlerIds,
_this = this;
handlerIds = _(this.events).values();
return _(handlerIds).map(function(handlerId) {
if (_.isFunction(handlerId)) {
return handlerId;
} else {
return _this[handlerId];
}
});
},
collections: function() {
return Luca.util.selectProperties(Luca.isBackboneCollection, this);
},
models: function() {
return Luca.util.selectProperties(Luca.isBackboneModel, this);
},
views: function() {
return Luca.util.selectProperties(Luca.isBackboneView, this);
}
});
originalExtend = Backbone.View.extend;
customizeRender = function(definition) {
var _base;
_base = definition.render;
_base || (_base = Luca.View.prototype.$attach);
definition.render = function() {
var autoTrigger, deferred, fn, target, trigger, view,
_this = this;
view = this;
if (this.deferrable) {
target = this.deferrable_target;
if (!Luca.isBackboneCollection(this.deferrable)) {
this.deferrable = this.collection;
}
target || (target = this.deferrable);
trigger = this.deferrable_event ? this.deferrable_event : "reset";
deferred = function() {
_base.call(view);
return view.trigger("after:render", view);
};
view.defer(deferred).until(target, trigger);
view.trigger("before:render", this);
autoTrigger = this.deferrable_trigger || this.deferUntil;
if (!(autoTrigger != null)) {
target[this.deferrable_method || "fetch"].call(target);
} else {
fn = _.once(function() {
var _base2, _name;
return typeof (_base2 = _this.deferrable)[_name = _this.deferrable_method || "fetch"] === "function" ? _base2[_name]() : void 0;
});
(this.deferrable_target || this).bind(this.deferrable_trigger, fn);
}
return this;
} else {
this.trigger("before:render", this);
_base.apply(this, arguments);
this.trigger("after:render", this);
return this;
}
};
return definition;
};
Luca.View.extend = function(definition) {
definition = customizeRender(definition);
return originalExtend.call(this, definition);
};
}).call(this);
(function() {
var setupComputedProperties;
setupComputedProperties = function() {
var attr, dependencies, _ref, _results,
_this = this;
if (_.isUndefined(this.computed)) return;
this._computed = {};
_ref = this.computed;
_results = [];
for (attr in _ref) {
dependencies = _ref[attr];
this.on("change:" + attr, function() {
return _this._computed[attr] = _this[attr].call(_this);
});
_results.push(_(dependencies).each(function(dep) {
_this.on("change:" + dep, function() {
return _this.trigger("change:" + attr);
});
if (_this.has(dep)) return _this.trigger("change:" + attr);
}));
}
return _results;
};
_.def('Luca.Model')["extends"]('Backbone.Model')["with"]({
include: ['Luca.Events'],
initialize: function() {
Backbone.Model.prototype.initialize(this, arguments);
return setupComputedProperties.call(this);
},
get: function(attr) {
var _ref;
if ((_ref = this.computed) != null ? _ref.hasOwnProperty(attr) : void 0) {
return this._computed[attr];
} else {
return Backbone.Model.prototype.get.call(this, attr);
}
}
});
}).call(this);
(function() {
var source;
source = 'Backbone.Collection';
if (Backbone.QueryCollection != null) source = 'Backbone.QueryCollection';
_.def("Luca.Collection")["extends"](source)["with"]({
include: ['Luca.Events'],
cachedMethods: [],
remoteFilter: false,
initialize: function(models, options) {
var table,
_this = this;
if (models == null) models = [];
this.options = options;
_.extend(this, this.options);
this.setupMethodCaching();
this._reset();
if (this.cached) {
console.log('The @cached property of Luca.Collection is being deprecated. Please change to cache_key');
}
if (this.cache_key || (this.cache_key = this.cached)) {
this.bootstrap_cache_key = _.isFunction(this.cache_key) ? this.cache_key() : this.cache_key;
}
if (this.registerAs || this.registerWith) {
console.log("This configuration API is deprecated. use @name and @manager properties instead");
}
this.name || (this.name = this.registerAs);
this.manager || (this.manager = this.registerWith);
this.manager = _.isFunction(this.manager) ? this.manager() : this.manager;
if (this.name && !this.manager) this.manager = Luca.CollectionManager.get();
if (this.manager) {
this.name || (this.name = this.cache_key());
this.name = _.isFunction(this.name) ? this.name() : this.name;
if (!(this.private || this.anonymous)) {
this.bind("after:initialize", function() {
return _this.register(_this.manager, _this.name, _this);
});
}
}
if (this.useLocalStorage === true && (window.localStorage != null)) {
table = this.bootstrap_cache_key || this.name;
throw "Must specify either a cached or registerAs property to use localStorage";
this.localStorage = new Luca.LocalStore(table);
}
if (_.isArray(this.data) && this.data.length > 0) {
this.memoryCollection = true;
}
if (this.useNormalUrl !== true) this.__wrapUrl();
Backbone.Collection.prototype.initialize.apply(this, [models, this.options]);
if (models) {
this.reset(models, {
silent: true,
parse: options != null ? options.parse : void 0
});
}
return this.trigger("after:initialize");
},
__wrapUrl: function() {
var params, url,
_this = this;
if (_.isFunction(this.url)) {
return this.url = _.wrap(this.url, function(fn) {
var existing_params, new_val, parts, queryString, val;
val = fn.apply(_this);
parts = val.split('?');
if (parts.length > 1) existing_params = _.last(parts);
queryString = _this.queryString();
if (existing_params && val.match(existing_params)) {
queryString = queryString.replace(existing_params, '');
}
new_val = "" + val + "?" + queryString;
if (new_val.match(/\?$/)) new_val = new_val.replace(/\?$/, '');
return new_val;
});
} else {
url = this.url;
params = this.queryString();
return this.url = _([url, params]).compact().join("?");
}
},
queryString: function() {
var parts,
_this = this;
parts = _(this.base_params || (this.base_params = Luca.Collection.baseParams())).inject(function(memo, value, key) {
var str;
str = "" + key + "=" + value;
memo.push(str);
return memo;
}, []);
return _.uniq(parts).join("&");
},
resetFilter: function() {
this.base_params = _(Luca.Collection.baseParams()).clone();
return this;
},
applyFilter: function(filter, options) {
if (filter == null) filter = {};
if (options == null) options = {};
if ((options.remote != null) === true || this.remoteFilter === true) {
this.applyParams(filter);
return this.fetch(_.extend(options, {
refresh: true
}));
} else {
return this.reset(this.query(filter));
}
},
applyParams: function(params) {
this.base_params = _(Luca.Collection.baseParams()).clone();
_.extend(this.base_params, params);
return this;
},
register: function(collectionManager, key, collection) {
if (collectionManager == null) {
collectionManager = Luca.CollectionManager.get();
}
if (key == null) key = "";
if (!(key.length >= 1)) {
throw "Can not register with a collection manager without a key";
}
if (collectionManager == null) {
throw "Can not register with a collection manager without a valid collection manager";
}
if (_.isString(collectionManager)) {
collectionManager = Luca.util.nestedValue(collectionManager, window || global);
}
if (!collectionManager) throw "Could not register with collection manager";
if (_.isFunction(collectionManager.add)) {
return collectionManager.add(key, collection);
}
if (_.isObject(collectionManager)) {
return collectionManager[key] = collection;
}
},
loadFromBootstrap: function() {
if (!this.bootstrap_cache_key) return;
this.reset(this.cached_models());
return this.trigger("bootstrapped", this);
},
bootstrap: function() {
return this.loadFromBootstrap();
},
cached_models: function() {
return Luca.Collection.cache(this.bootstrap_cache_key);
},
fetch: function(options) {
var url;
if (options == null) options = {};
this.trigger("before:fetch", this);
if (this.memoryCollection === true) return this.reset(this.data);
if (this.cached_models().length && !options.refresh) return this.bootstrap();
url = _.isFunction(this.url) ? this.url() : this.url;
if (!((url && url.length > 1) || this.localStorage)) return true;
this.fetching = true;
try {
return Backbone.Collection.prototype.fetch.apply(this, arguments);
} catch (e) {
console.log("Error in Collection.fetch", e);
throw e;
}
},
onceLoaded: function(fn, options) {
var wrapped,
_this = this;
if (options == null) {
options = {
autoFetch: true
};
}
if (this.length > 0 && !this.fetching) {
fn.apply(this, [this]);
return;
}
wrapped = function() {
return fn.apply(_this, [_this]);
};
this.bind("reset", function() {
wrapped();
return this.unbind("reset", this);
});
if (!(this.fetching || !options.autoFetch)) return this.fetch();
},
ifLoaded: function(fn, options) {
var scope,
_this = this;
if (options == null) {
options = {
scope: this,
autoFetch: true
};
}
scope = options.scope || this;
if (this.length > 0 && !this.fetching) fn.apply(scope, [this]);
this.bind("reset", function(collection) {
return fn.call(scope, collection);
});
if (!(this.fetching === true || !options.autoFetch || this.length > 0)) {
return this.fetch();
}
},
parse: function(response) {
var models;
this.fetching = false;
this.trigger("after:response", response);
models = this.root != null ? response[this.root] : response;
if (this.bootstrap_cache_key) {
Luca.Collection.cache(this.bootstrap_cache_key, models);
}
return models;
},
restoreMethodCache: function() {
var config, name, _ref, _results;
_ref = this._methodCache;
_results = [];
for (name in _ref) {
config = _ref[name];
if (config.original != null) {
config.args = void 0;
_results.push(this[name] = config.original);
} else {
_results.push(void 0);
}
}
return _results;
},
clearMethodCache: function(method) {
return this._methodCache[method].value = void 0;
},
clearAllMethodsCache: function() {
var config, name, _ref, _results;
_ref = this._methodCache;
_results = [];
for (name in _ref) {
config = _ref[name];
_results.push(this.clearMethodCache(name));
}
return _results;
},
setupMethodCaching: function() {
var cache, collection, membershipEvents;
collection = this;
membershipEvents = ["reset", "add", "remove"];
cache = this._methodCache = {};
return _(this.cachedMethods).each(function(method) {
var dependencies, dependency, membershipEvent, _i, _j, _len, _len2, _ref, _results;
cache[method] = {
name: method,
original: collection[method],
value: void 0
};
collection[method] = function() {
var _base;
return (_base = cache[method]).value || (_base.value = cache[method].original.apply(collection, arguments));
};
for (_i = 0, _len = membershipEvents.length; _i < _len; _i++) {
membershipEvent = membershipEvents[_i];
collection.bind(membershipEvent, function() {
return collection.clearAllMethodsCache();
});
}
dependencies = method.split(':')[1];
if (dependencies) {
_ref = dependencies.split(",");
_results = [];
for (_j = 0, _len2 = _ref.length; _j < _len2; _j++) {
dependency = _ref[_j];
_results.push(collection.bind("change:" + dependency, function() {
return collection.clearMethodCache({
method: method
});
}));
}
return _results;
}
});
},
query: function(filter, options) {
if (filter == null) filter = {};
if (options == null) options = {};
if (Backbone.QueryCollection != null) {
return Backbone.QueryCollection.prototype.query.apply(this, arguments);
} else {
return this.models;
}
}
});
_.extend(Luca.Collection.prototype, {
trigger: function() {
if (Luca.enableGlobalObserver) {
Luca.CollectionObserver || (Luca.CollectionObserver = new Luca.Observer({
type: "collection"
}));
Luca.CollectionObserver.relay(this, arguments);
}
return Backbone.View.prototype.trigger.apply(this, arguments);
}
});
Luca.Collection.baseParams = function(obj) {
if (obj) return Luca.Collection._baseParams = obj;
if (_.isFunction(Luca.Collection._baseParams)) {
return Luca.Collection._baseParams();
}
if (_.isObject(Luca.Collection._baseParams)) {
return Luca.Collection._baseParams;
}
};
Luca.Collection._bootstrapped_models = {};
Luca.Collection.bootstrap = function(obj) {
return _.extend(Luca.Collection._bootstrapped_models, obj);
};
Luca.Collection.cache = function(key, models) {
if (models) return Luca.Collection._bootstrapped_models[key] = models;
return Luca.Collection._bootstrapped_models[key] || [];
};
}).call(this);
(function() {
var attachToolbar;
attachToolbar = function(config, targetEl) {
var action, container, hasBody, id, toolbar;
if (config == null) config = {};
config.orientation || (config.orientation = "top");
config.ctype || (config.ctype = this.toolbarType || "panel_toolbar");
id = "" + this.cid + "-tbc-" + config.orientation;
toolbar = Luca.util.lazyComponent(config);
container = this.make("div", {
"class": "toolbar-container " + config.orientation,
id: id
}, toolbar.render().el);
hasBody = this.bodyClassName || this.bodyTagName;
action = (function() {
switch (config.orientation) {
case "top":
case "left":
if (hasBody) {
return "before";
} else {
return "prepend";
}
break;
case "bottom":
case "right":
if (hasBody) {
return "after";
} else {
return "append";
}
}
})();
return (targetEl || this.$bodyEl())[action](container);
};
_.def("Luca.components.Panel")["extends"]("Luca.View")["with"]({
topToolbar: void 0,
bottomToolbar: void 0,
loadMask: false,
loadMaskTemplate: ["components/load_mask"],
loadMaskTimeout: 3000,
initialize: function(options) {
var _this = this;
this.options = options != null ? options : {};
Luca.View.prototype.initialize.apply(this, arguments);
_.bindAll(this, "applyLoadMask", "disableLoadMask");
if (this.loadMask === true) {
this.defer(function() {
_this.$el.addClass('with-mask');
if (_this.$('.load-mask').length === 0) {
_this.loadMaskTarget().prepend(Luca.template(_this.loadMaskTemplate, _this));
return _this.$('.load-mask').hide();
}
}).until("after:render");
this.on("enable:loadmask", this.applyLoadMask);
return this.on("disable:loadmask", this.applyLoadMask);
}
},
loadMaskTarget: function() {
if (this.loadMaskEl != null) {
return this.$(this.loadMaskEl);
} else {
return this.$bodyEl();
}
},
disableLoadMask: function() {
this.$('.load-mask .bar').css("width", "100%");
this.$('.load-mask').hide();
return clearInterval(this.loadMaskInterval);
},
enableLoadMask: function() {
var maxWidth,
_this = this;
this.$('.load-mask').show().find('.bar').css("width", "0%");
maxWidth = this.$('.load-mask .progress').width();
if (maxWidth < 20 && (maxWidth = this.$el.width()) < 20) {
maxWidth = this.$el.parent().width();
}
this.loadMaskInterval = setInterval(function() {
var currentWidth, newWidth;
currentWidth = _this.$('.load-mask .bar').width();
newWidth = currentWidth + 12;
return _this.$('.load-mask .bar').css('width', newWidth);
}, 200);
if (this.loadMaskTimeout == null) return;
return _.delay(function() {
return _this.disableLoadMask();
}, this.loadMaskTimeout);
},
applyLoadMask: function() {
if (this.$('.load-mask').is(":visible")) {
return this.disableLoadMask();
} else {
return this.enableLoadMask();
}
},
applyStyles: function(styles, body) {
var setting, target, value;
if (styles == null) styles = {};
if (body == null) body = false;
target = body ? this.$bodyEl() : this.$el;
for (setting in styles) {
value = styles[setting];
target.css(setting, value);
}
return this;
},
beforeRender: function() {
var _ref;
if ((_ref = Luca.View.prototype.beforeRender) != null) {
_ref.apply(this, arguments);
}
if (this.styles != null) this.applyStyles(this.styles);
if (this.bodyStyles != null) this.applyStyles(this.bodyStyles, true);
return typeof this.renderToolbars === "function" ? this.renderToolbars() : void 0;
},
$bodyEl: function() {
var bodyEl, className, element, newElement;
element = this.bodyTagName || "div";
className = this.bodyClassName || "view-body";
this.bodyEl || (this.bodyEl = "" + element + "." + className);
bodyEl = this.$(this.bodyEl);
if (bodyEl.length > 0) return bodyEl;
if (bodyEl.length === 0 && ((this.bodyClassName != null) || (this.bodyTagName != null))) {
newElement = this.make(element, {
"class": className,
"data-auto-appended": true
});
$(this.el).append(newElement);
return this.$(this.bodyEl);
}
return $(this.el);
},
$wrap: function(wrapper) {
if (_.isString(wrapper) && !wrapper.match(/[<>]/)) {
wrapper = this.make("div", {
"class": wrapper
});
}
return this.$el.wrap(wrapper);
},
$template: function(template, variables) {
if (variables == null) variables = {};
return this.$html(Luca.template(template, variables));
},
$html: function(content) {
return this.$bodyEl().html(content);
},
$append: function(content) {
return this.$bodyEl().append(content);
},
renderToolbars: function() {
var _this = this;
return _(["top", "left", "right", "bottom"]).each(function(orientation) {
var config;
if (config = _this["" + orientation + "Toolbar"]) {
return _this.renderToolbar(orientation, config);
}
});
},
renderToolbar: function(orientation, config) {
if (orientation == null) orientation = "top";
if (config == null) config = {};
config.parent = this;
config.orientation = orientation;
return attachToolbar.call(this, config, config.targetEl);
}
});
}).call(this);
(function() {
Luca.modules.Deferrable = {
configure_collection: function(setAsDeferrable) {
var collectionManager, _ref, _ref2;
if (setAsDeferrable == null) setAsDeferrable = true;
if (!this.collection) return;
if (_.isString(this.collection) && (collectionManager = (_ref = Luca.CollectionManager) != null ? _ref.get() : void 0)) {
this.collection = collectionManager.getOrCreate(this.collection);
}
if (!(this.collection && _.isFunction(this.collection.fetch) && _.isFunction(this.collection.reset))) {
this.collection = new Luca.Collection(this.collection.initial_set, this.collection);
}
if ((_ref2 = this.collection) != null ? _ref2.deferrable_trigger : void 0) {
this.deferrable_trigger = this.collection.deferrable_trigger;
}
if (setAsDeferrable) return this.deferrable = this.collection;
}
};
}).call(this);
(function() {
Luca.LocalStore = (function() {
function LocalStore(name) {
var store;
this.name = name;
store = localStorage.getItem(this.name);
this.data = (store && JSON.parse(store)) || {};
}
LocalStore.prototype.guid = function() {
var S4;
S4 = function() {
return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
};
return S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4();
};
LocalStore.prototype.save = function() {
return localStorage.setItem(this.name, JSON.stringify(this.data));
};
LocalStore.prototype.create = function(model) {
if (!model.id) model.id = model.attribtues.id = this.guid();
this.data[model.id] = model;
this.save();
return model;
};
LocalStore.prototype.update = function(model) {
this.data[model.id] = model;
this.save();
return model;
};
LocalStore.prototype.find = function(model) {
return this.data[model.id];
};
LocalStore.prototype.findAll = function() {
return _.values(this.data);
};
LocalStore.prototype.destroy = function(model) {
delete this.data[model.id];
this.save();
return model;
};
return LocalStore;
})();
Backbone.LocalSync = function(method, model, options) {
var resp, store;
store = model.localStorage || model.collection.localStorage;
resp = (function() {
switch (method) {
case "read":
if (model.id) {
return store.find(model);
} else {
return store.findAll();
}
case "create":
return store.create(model);
case "update":
return store.update(model);
case "delete":
return store.destroy(model);
}
})();
if (resp) {
return options.success(resp);
} else {
return options.error("Record not found");
}
};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["components/bootstrap_form_controls"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["components/collection_loader_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n
\n
\n Initializing...\n
\n
\n
\n '); for(var i = 0; i < components.length; i++ ) { __p.push('\n '); var component = components[i];__p.push('\n - \n \n ', component.title ,'\n \n
\n '); } __p.push('\n
\n
\n
\n
\n
\n ', helperText ,'\n
\n'); } __p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["fields/file_upload_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n\n'); if(helperText) { __p.push('\n\n ', helperText ,'\n
\n'); } __p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["fields/hidden_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["fields/select_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n\n'); if(helperText) { __p.push('\n\n ', helperText ,'\n
\n'); } __p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["fields/text_area_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('\n\n'); if(helperText) { __p.push('\n\n ', helperText ,'\n
\n'); } __p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["fields/text_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push(''); if(typeof(label)!=="undefined" && (typeof(hideLabel) !== "undefined" && !hideLabel) || (typeof(hideLabel)==="undefined")) {__p.push('\n\n'); } __p.push('\n'); if( typeof(addOn) !== "undefined" ) { __p.push('\n\n ', addOn ,'\n\n'); } __p.push('\n\n'); if(helperText) { __p.push('\n\n ', helperText ,'\n
\n'); } __p.push('\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["sample/contents"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('Sample Contents
\n');}return __p.join('');};
}).call(this);
(function() {
Luca.templates || (Luca.templates = {});
Luca.templates["sample/welcome"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('welcome.luca\n');}return __p.join('');};
}).call(this);
(function() {
var __slice = Array.prototype.slice;
Luca.Observer = (function() {
function Observer(options) {
var _this = this;
this.options = options != null ? options : {};
_.extend(this, Backbone.Events);
this.type = this.options.type;
if (this.options.debugAll) {
this.bind("all", function(trigger, one, two) {
return console.log("ALL", trigger, one, two);
});
}
}
Observer.prototype.relay = function() {
var args, triggerer;
triggerer = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
console.log("Relaying", trigger, args);
this.trigger("event", triggerer, args);
return this.trigger("event:" + args[0], triggerer, args.slice(1));
};
return Observer;
})();
Luca.Observer.enableObservers = function(options) {
if (options == null) options = {};
Luca.enableGlobalObserver = true;
Luca.ViewObserver = new Luca.Observer(_.extend(options, {
type: "view"
}));
return Luca.CollectionObserver = new Luca.Observer(_.extend(options, {
type: "collection"
}));
};
}).call(this);
(function() {
_.def('Luca.core.Field')["extends"]('Luca.View')["with"]({
className: 'luca-ui-text-field luca-ui-field',
isField: true,
template: 'fields/text_field',
labelAlign: 'top',
hooks: ["before:validation", "after:validation", "on:change"],
statuses: ["warning", "error", "success"],
initialize: function(options) {
var _ref;
this.options = options != null ? options : {};
_.extend(this, this.options);
this.input_id || (this.input_id = _.uniqueId('field'));
this.input_name || (this.input_name = this.name);
this.input_class || (this.input_class = "");
this.helperText || (this.helperText = "");
if (this.required && !((_ref = this.label) != null ? _ref.match(/^\*/) : void 0)) {
this.label || (this.label = "*" + this.label);
}
this.inputStyles || (this.inputStyles = "");
if (this.disabled) this.disable();
this.updateState(this.state);
this.placeHolder || (this.placeHolder = "");
return Luca.View.prototype.initialize.apply(this, arguments);
},
beforeRender: function() {
if (Luca.enableBootstrap) this.$el.addClass('control-group');
if (this.required) this.$el.addClass('required');
this.$el.html(Luca.templates[this.template](this));
return this.input = $('input', this.el);
},
change_handler: function(e) {
return this.trigger("on:change", this, e);
},
disable: function() {
return $("input", this.el).attr('disabled', true);
},
enable: function() {
return $("input", this.el).attr('disabled', false);
},
getValue: function() {
return this.input.attr('value');
},
render: function() {
return $(this.container).append(this.$el);
},
setValue: function(value) {
return this.input.attr('value', value);
},
updateState: function(state) {
var _this = this;
return _(this.statuses).each(function(cls) {
_this.$el.removeClass(cls);
return _this.$el.addClass(state);
});
}
});
}).call(this);
(function() {
var applyDOMConfig, doComponents, doLayout;
doLayout = function() {
this.trigger("before:layout", this);
this.prepareLayout();
return this.trigger("after:layout", this);
};
applyDOMConfig = function(panel, panelIndex) {
var config, style_declarations;
style_declarations = [];
if (panel.height != null) {
style_declarations.push("height: " + (_.isNumber(panel.height) ? panel.height + 'px' : panel.height));
}
if (panel.width != null) {
style_declarations.push("width: " + (_.isNumber(panel.width) ? panel.width + 'px' : panel.width));
}
if (panel.float) style_declarations.push("float: " + panel.float);
config = {
"class": (panel != null ? panel.classes : void 0) || this.componentClass,
id: "" + this.cid + "-" + panelIndex,
style: style_declarations.join(';'),
"data-luca-owner": this.name || this.cid
};
if (this.customizeContainerEl != null) {
config = this.customizeContainerEl(config, panel, panelIndex);
}
return config;
};
doComponents = function() {
this.trigger("before:components", this, this.components);
this.prepareComponents();
this.createComponents();
this.trigger("before:render:components", this, this.components);
this.renderComponents();
return this.trigger("after:components", this, this.components);
};
_.def('Luca.core.Container')["extends"]('Luca.components.Panel')["with"]({
className: 'luca-ui-container',
componentTag: 'div',
componentClass: 'luca-ui-panel',
isContainer: true,
hooks: ["before:components", "before:render:components", "before:layout", "after:components", "after:layout", "first:activation"],
rendered: false,
components: [],
initialize: function(options) {
this.options = options != null ? options : {};
_.extend(this, this.options);
this.setupHooks(["before:components", "before:render:components", "before:layout", "after:components", "after:layout", "first:activation"]);
return Luca.View.prototype.initialize.apply(this, arguments);
},
beforeRender: function() {
var _ref;
doLayout.call(this);
doComponents.call(this);
return (_ref = Luca.components.Panel.prototype.beforeRender) != null ? _ref.apply(this, arguments) : void 0;
},
customizeContainerEl: function(containerEl, panel, panelIndex) {
return containerEl;
},
prepareLayout: function() {
var container;
container = this;
return this.componentContainers = _(this.components).map(function(component, index) {
return applyDOMConfig.call(container, component, index);
});
},
prepareComponents: function() {
var component, _i, _len, _ref,
_this = this;
_ref = this.components;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
component = _ref[_i];
if (_.isString(component)) {
component = {
type: component
};
}
}
return _(this.components).each(function(component, index) {
var container, panel, _ref2;
container = (_ref2 = _this.componentContainers) != null ? _ref2[index] : void 0;
container["class"] = container["class"] || container.className || container.classes;
if (_this.appendContainers) {
panel = _this.make(_this.componentTag, container, '');
_this.$append(panel);
}
if (component.container == null) {
if (_this.appendContainers) component.container = "#" + container.id;
return component.container || (component.container = _this.$bodyEl());
}
});
},
createComponents: function() {
var map,
_this = this;
if (this.componentsCreated === true) return;
map = this.componentIndex = {
name_index: {},
cid_index: {}
};
this.components = _(this.components).map(function(object, index) {
var component;
component = Luca.isBackboneView(object) ? object : (object.type || (object.type = object.ctype), !(object.type != null) ? object.components != null ? object.type = object.ctype = 'container' : object.type = object.ctype = Luca.defaultComponentType : void 0, Luca.util.lazyComponent(object));
if (!component.container && component.options.container) {
component.container = component.options.container;
}
if (map && (component.cid != null)) map.cid_index[component.cid] = index;
if (map && (component.name != null)) {
map.name_index[component.name] = index;
}
return component;
});
this.componentsCreated = true;
if (!_.isEmpty(this.componentEvents)) this.registerComponentEvents();
return map;
},
renderComponents: function(debugMode) {
var _this = this;
this.debugMode = debugMode != null ? debugMode : "";
this.debug("container render components");
return _(this.components).each(function(component) {
component.getParent = function() {
return _this;
};
$(component.container).append($(component.el));
try {
return component.render();
} catch (e) {
console.log("Error Rendering Component " + (component.name || component.cid), component);
if (_.isObject(e)) {
console.log(e.message);
console.log(e.stack);
}
if ((Luca.silenceRenderErrors != null) !== true) throw e;
}
});
},
firstActivation: function() {
var activator;
activator = this;
return this.each(function(component, index) {
var _ref;
if ((component != null ? component.previously_activated : void 0) !== true) {
if (component != null) {
if ((_ref = component.trigger) != null) {
_ref.call(component, "first:activation", component, activator);
}
}
return component.previously_activated = true;
}
});
},
pluck: function(attribute) {
return _(this.components).pluck(attribute);
},
invoke: function(method) {
return _(this.components).invoke(method);
},
select: function(attribute, value, deep) {
var components;
if (deep == null) deep = false;
components = _(this.components).map(function(component) {
var matches, test;
matches = [];
test = component[attribute];
if (test === value) matches.push(component);
if (deep === true) {
matches.push(typeof component.select === "function" ? component.select(attribute, value, true) : void 0);
}
return _.compact(matches);
});
return _.flatten(components);
},
componentEvents: {},
registerComponentEvents: function() {
var component, componentName, handler, listener, trigger, _ref, _ref2, _results;
_ref = this.componentEvents;
_results = [];
for (listener in _ref) {
handler = _ref[listener];
_ref2 = listener.split(' '), componentName = _ref2[0], trigger = _ref2[1];
component = this.findComponentByName(componentName);
_results.push(component != null ? component.bind(trigger, this[handler]) : void 0);
}
return _results;
},
findComponentByName: function(name, deep) {
if (deep == null) deep = false;
return this.findComponent(name, "name_index", deep);
},
findComponentById: function(id, deep) {
if (deep == null) deep = false;
return this.findComponent(id, "cid_index", deep);
},
findComponent: function(needle, haystack, deep) {
var component, position, sub_container, _ref, _ref2;
if (haystack == null) haystack = "name";
if (deep == null) deep = false;
if (this.componentsCreated !== true) this.createComponents();
position = (_ref = this.componentIndex) != null ? _ref[haystack][needle] : void 0;
component = (_ref2 = this.components) != null ? _ref2[position] : void 0;
if (component) return component;
if (deep === true) {
sub_container = _(this.components).detect(function(component) {
return component != null ? typeof component.findComponent === "function" ? component.findComponent(needle, haystack, true) : void 0 : void 0;
});
return sub_container != null ? typeof sub_container.findComponent === "function" ? sub_container.findComponent(needle, haystack, true) : void 0 : void 0;
}
},
each: function(fn) {
return this.eachComponent(fn, false);
},
eachComponent: function(fn, deep) {
var _this = this;
if (deep == null) deep = true;
return _(this.components).each(function(component, index) {
var _ref;
fn.call(component, component, index);
if (deep) {
return component != null ? (_ref = component.eachComponent) != null ? _ref.apply(component, [fn, deep]) : void 0 : void 0;
}
});
},
indexOf: function(name) {
var names;
names = _(this.components).pluck('name');
return _(names).indexOf(name);
},
activeComponent: function() {
if (!this.activeItem) return this;
return this.components[this.activeItem];
},
componentElements: function() {
return $(">." + this.componentClass, this.el);
},
getComponent: function(needle) {
return this.components[needle];
},
rootComponent: function() {
return !(this.getParent != null);
},
getRootComponent: function() {
if (this.rootComponent()) {
return this;
} else {
return this.getParent().getRootComponent();
}
}
});
}).call(this);
(function() {
Luca.CollectionManager = (function() {
CollectionManager.prototype.name = "primary";
CollectionManager.prototype.__collections = {};
function CollectionManager(options) {
var existing, manager, _base, _base2;
this.options = options != null ? options : {};
_.extend(this, this.options);
manager = this;
if (existing = typeof (_base = Luca.CollectionManager).get === "function" ? _base.get(this.name) : void 0) {
throw 'Attempt to create a collection manager with a name which already exists';
}
(_base2 = Luca.CollectionManager).instances || (_base2.instances = {});
_.extend(this, Backbone.Events);
_.extend(this, Luca.Events);
Luca.CollectionManager.instances[this.name] = manager;
Luca.CollectionManager.get = function(name) {
if (name == null) return manager;
return Luca.CollectionManager.instances[name];
};
this.state = new Luca.Model();
if (this.initialCollections) {
this.state.set({
loaded_collections_count: 0,
collections_count: this.initialCollections.length
});
this.state.bind("change:loaded_collections_count", this.collectionCountDidChange);
if (this.useProgressLoader) {
this.loaderView || (this.loaderView = new Luca.components.CollectionLoaderView({
manager: this,
name: "collection_loader_view"
}));
}
this.loadInitialCollections();
}
this;
}
CollectionManager.prototype.add = function(key, collection) {
var _base;
return (_base = this.currentScope())[key] || (_base[key] = collection);
};
CollectionManager.prototype.allCollections = function() {
return _(this.currentScope()).values();
};
CollectionManager.prototype.create = function(key, collectionOptions, initialModels) {
var CollectionClass, collection;
if (collectionOptions == null) collectionOptions = {};
if (initialModels == null) initialModels = [];
CollectionClass = collectionOptions.base;
CollectionClass || (CollectionClass = this.guessCollectionClass(key));
if (collectionOptions.private) collectionOptions.name = "";
collection = new CollectionClass(initialModels, collectionOptions);
this.add(key, collection);
return collection;
};
CollectionManager.prototype.collectionNamespace = Luca.Collection.namespace;
CollectionManager.prototype.currentScope = function() {
var current_scope, _base;
if (current_scope = this.getScope()) {
return (_base = this.__collections)[current_scope] || (_base[current_scope] = {});
} else {
return this.__collections;
}
};
CollectionManager.prototype.each = function(fn) {
return _(this.all()).each(fn);
};
CollectionManager.prototype.get = function(key) {
return this.currentScope()[key];
};
CollectionManager.prototype.getScope = function() {
return;
};
CollectionManager.prototype.getOrCreate = function(key, collectionOptions, initialModels) {
if (collectionOptions == null) collectionOptions = {};
if (initialModels == null) initialModels = [];
return this.get(key) || this.create(key, collectionOptions, initialModels, false);
};
CollectionManager.prototype.guessCollectionClass = function(key) {
var classified, guess, guesses, _ref;
classified = Luca.util.classify(key);
guess = (this.collectionNamespace || (window || global))[classified];
guess || (guess = (this.collectionNamespace || (window || global))["" + classified + "Collection"]);
if (!(guess != null) && ((_ref = Luca.Collection.namespaces) != null ? _ref.length : void 0) > 0) {
guesses = _(Luca.Collection.namespaces.reverse()).map(function(namespace) {
return Luca.util.resolve("" + namespace + "." + classified) || Luca.util.resolve("" + namespace + "." + classified + "Collection");
});
guesses = _(guesses).compact();
if (guesses.length > 0) guess = guesses[0];
}
return guess;
};
CollectionManager.prototype.loadInitialCollections = function() {
var collectionDidLoad,
_this = this;
collectionDidLoad = function(collection) {
collection.unbind("reset");
return _this.trigger("collection_loaded", collection.name);
};
return _(this.initialCollections).each(function(name) {
var collection;
collection = _this.getOrCreate(name);
collection.bind("reset", function() {
return collectionDidLoad(collection);
});
return collection.fetch();
});
};
CollectionManager.prototype.collectionCountDidChange = function() {
if (this.totalCollectionsCount() === this.loadedCollectionsCount()) {
return this.trigger("all_collections_loaded");
}
};
CollectionManager.prototype.totalCollectionsCount = function() {
return this.state.get("collections_count");
};
CollectionManager.prototype.loadedCollectionsCount = function() {
return this.state.get("loaded_collections_count");
};
CollectionManager.prototype.private = function(key, collectionOptions, initialModels) {
if (collectionOptions == null) collectionOptions = {};
if (initialModels == null) initialModels = [];
return this.create(key, collectionOptions, initialModels, true);
};
return CollectionManager;
})();
Luca.CollectionManager.destroyAll = function() {
return Luca.CollectionManager.instances = {};
};
}).call(this);
(function() {
Luca.SocketManager = (function() {
function SocketManager(options) {
this.options = options != null ? options : {};
_.extend(Backbone.Events);
this.loadTransport();
}
SocketManager.prototype.connect = function() {
switch (this.options.provider) {
case "socket.io":
return this.socket = io.connect(this.options.socket_host);
case "faye.js":
return this.socket = new Faye.Client(this.options.socket_host);
}
};
SocketManager.prototype.transportLoaded = function() {
return this.connect();
};
SocketManager.prototype.transport_script = function() {
switch (this.options.provider) {
case "socket.io":
return "" + this.options.transport_host + "/socket.io/socket.io.js";
case "faye.js":
return "" + this.options.transport_host + "/faye.js";
}
};
SocketManager.prototype.loadTransport = function() {
var script,
_this = this;
script = document.createElement('script');
script.setAttribute("type", "text/javascript");
script.setAttribute("src", this.transport_script());
script.onload = this.transportLoaded;
if (Luca.util.isIE()) {
script.onreadystatechange = function() {
if (script.readyState === "loaded") return _this.transportLoaded();
};
}
return document.getElementsByTagName('head')[0].appendChild(script);
};
return SocketManager;
})();
}).call(this);
(function() {
_.def('Luca.containers.SplitView')["extends"]('Luca.core.Container')["with"]({
componentType: 'split_view',
containerTemplate: 'containers/basic',
className: 'luca-ui-split-view',
componentClass: 'luca-ui-panel'
});
}).call(this);
(function() {
_.def('Luca.containers.ColumnView')["extends"]('Luca.core.Container')["with"]({
componentType: 'column_view',
className: 'luca-ui-column-view',
components: [],
initialize: function(options) {
this.options = options != null ? options : {};
Luca.core.Container.prototype.initialize.apply(this, arguments);
return this.setColumnWidths();
},
componentClass: 'luca-ui-column',
containerTemplate: "containers/basic",
appendContainers: true,
autoColumnWidths: function() {
var widths,
_this = this;
widths = [];
_(this.components.length).times(function() {
return widths.push(parseInt(100 / _this.components.length));
});
return widths;
},
setColumnWidths: function() {
this.columnWidths = this.layout != null ? _(this.layout.split('/')).map(function(v) {
return parseInt(v);
}) : this.autoColumnWidths();
return this.columnWidths = _(this.columnWidths).map(function(val) {
return "" + val + "%";
});
},
beforeLayout: function() {
var _ref,
_this = this;
this.debug("column_view before layout");
_(this.columnWidths).each(function(width, index) {
_this.components[index].float = "left";
return _this.components[index].width = width;
});
return (_ref = Luca.core.Container.prototype.beforeLayout) != null ? _ref.apply(this, arguments) : void 0;
}
});
}).call(this);
(function() {
_.def("Luca.containers.CardView")["extends"]("Luca.core.Container")["with"]({
componentType: 'card_view',
className: 'luca-ui-card-view-wrapper',
activeCard: 0,
components: [],
hooks: ['before:card:switch', 'after:card:switch'],
componentClass: 'luca-ui-card',
appendContainers: true,
initialize: function(options) {
this.options = options;
Luca.core.Container.prototype.initialize.apply(this, arguments);
return this.setupHooks(this.hooks);
},
prepareComponents: function() {
var _ref,
_this = this;
if ((_ref = Luca.core.Container.prototype.prepareComponents) != null) {
_ref.apply(this, arguments);
}
return _(this.components).each(function(component, index) {
if (index === _this.activeCard) {
return $(component.container).show();
} else {
return $(component.container).hide();
}
});
},
activeComponentElement: function() {
return this.componentElements().eq(this.activeCard);
},
activeComponent: function() {
return this.getComponent(this.activeCard);
},
customizeContainerEl: function(containerEl, panel, panelIndex) {
containerEl.style += panelIndex === this.activeCard ? "display:block;" : "display:none;";
return containerEl;
},
cycle: function() {
var nextIndex;
nextIndex = this.activeCard < this.components.length - 1 ? this.activeCard + 1 : 0;
return this.activate(nextIndex);
},
find: function(name) {
return this.findComponentByName(name, true);
},
firstActivation: function() {
return this.activeComponent().trigger("first:activation", this, this.activeComponent());
},
activate: function(index, silent, callback) {
var current, previous, _ref, _ref2, _ref3, _ref4,
_this = this;
if (silent == null) silent = false;
if (_.isFunction(silent)) {
silent = false;
callback = silent;
}
if (index === this.activeCard) return;
previous = this.activeComponent();
current = this.getComponent(index);
if (!current) {
index = this.indexOf(index);
current = this.getComponent(index);
}
if (!current) return;
if (!silent) {
this.trigger("before:card:switch", previous, current);
if (previous != null) {
if ((_ref = previous.trigger) != null) {
_ref.apply(previous, ["before:deactivation", this, previous, current]);
}
}
if (current != null) {
if ((_ref2 = current.trigger) != null) {
_ref2.apply(previous, ["before:activation", this, previous, current]);
}
}
_.defer(function() {
return _this.$el.data(_this.activeAttribute || "active-card", current.name);
});
}
this.componentElements().hide();
if (!current.previously_activated) {
current.trigger("first:activation");
current.previously_activated = true;
}
this.activeCard = index;
this.activeComponentElement().show();
if (!silent) {
this.trigger("after:card:switch", previous, current);
if ((_ref3 = previous.trigger) != null) {
_ref3.apply(previous, ["deactivation", this, previous, current]);
}
if ((_ref4 = current.trigger) != null) {
_ref4.apply(current, ["activation", this, previous, current]);
}
}
if (_.isFunction(callback)) {
return callback.apply(this, [this, previous, current]);
}
}
});
}).call(this);
(function() {
_.def("Luca.ModalView")["extends"]("Luca.View")["with"]({
closeOnEscape: true,
showOnInitialize: false,
backdrop: false,
container: function() {
return $('body');
},
toggle: function() {
return this.$el.modal('toggle');
},
show: function() {
return this.$el.modal('show');
},
hide: function() {
return this.$el.modal('hide');
},
render: function() {
this.$el.addClass('modal');
if (this.fade === true) this.$el.addClass('fade');
$('body').append(this.$el);
return this.$el.modal({
backdrop: this.backdrop === true,
keyboard: this.closeOnEscape === true,
show: this.showOnInitialize === true
});
}
});
_.def("Luca.containers.ModalView")["extends"]("Luca.ModalView")["with"]();
}).call(this);
(function() {
var buildButton, make, prepareButtons;
make = Backbone.View.prototype.make;
buildButton = function(config, wrap) {
var autoWrapClass, buttonAttributes, buttonEl, buttons, dropdownEl, dropdownItems, label, object, white, wrapper,
_this = this;
if (wrap == null) wrap = true;
if (config.ctype != null) {
config.className || (config.className = "");
config.className += 'toolbar-component';
object = Luca(config).render();
if (Luca.isBackboneView(object)) {
console.log("Adding toolbar component", object);
return object.el;
}
}
if (config.spacer) {
return make("div", {
"class": "spacer " + config.spacer
});
}
if (config.text) {
return make("div", {
"class": "toolbar-text"
}, config.text);
}
wrapper = 'btn-group';
if (config.wrapper != null) wrapper += " " + config.wrapper;
if (config.align != null) wrapper += " align-" + config.align;
if ((config.group != null) && (config.buttons != null)) {
buttons = prepareButtons(config.buttons, false);
return make("div", {
"class": wrapper
}, buttons);
} else {
label = config.label || (config.label = "");
config.eventId || (config.eventId = _.string.dasherize(config.label.toLowerCase()));
if (config.icon) {
if (_.string.isBlank(label)) label = " ";
if (config.white) white = "icon-white";
label = " " + label;
}
buttonAttributes = {
"class": _.compact(["btn", config.classes, config.className]).join(" "),
"data-eventId": config.eventId,
title: config.title || config.description
};
if (config.color != null) {
buttonAttributes["class"] += " btn-" + config.color;
}
if (config.dropdown) {
label = "" + label + " ";
buttonAttributes["class"] += " dropdown-toggle";
buttonAttributes["data-toggle"] = "dropdown";
dropdownItems = _(config.dropdown).map(function(dropdownItem) {
var link;
link = make("a", {}, dropdownItem[1]);
return make("li", {
"data-eventId": dropdownItem[0]
}, link);
});
dropdownEl = make("ul", {
"class": "dropdown-menu"
}, dropdownItems);
}
buttonEl = make("a", buttonAttributes, label);
autoWrapClass = "btn-group";
if (config.align != null) autoWrapClass += " align-" + config.align;
if (wrap === true) {
return make("div", {
"class": autoWrapClass
}, [buttonEl, dropdownEl]);
} else {
return buttonEl;
}
}
};
prepareButtons = function(buttons, wrap) {
if (wrap == null) wrap = true;
return _(buttons).map(function(button) {
return buildButton(button, wrap);
});
};
_.def("Luca.containers.PanelToolbar")["extends"]("Luca.View")["with"]({
className: "luca-ui-toolbar btn-toolbar",
buttons: [],
well: true,
orientation: 'top',
autoBindEventHandlers: true,
events: {
"click a.btn, click .dropdown-menu li": "clickHandler"
},
clickHandler: function(e) {
var eventId, hook, me, my, source;
me = my = $(e.target);
if (me.is('i')) me = my = $(e.target).parent();
eventId = my.data('eventid');
if (eventId == null) return;
hook = Luca.util.hook(eventId);
source = this.parent || this;
if (_.isFunction(source[hook])) {
return source[hook].call(this, me, e);
} else {
return source.trigger(eventId, me, e);
}
},
beforeRender: function() {
this._super("beforeRender", this, arguments);
if (this.well === true) this.$el.addClass('well');
this.$el.addClass("toolbar-" + this.orientation);
if (this.styles != null) return this.applyStyles(this.styles);
},
render: function() {
var elements,
_this = this;
this.$el.empty();
elements = prepareButtons(this.buttons);
return _(elements).each(function(element) {
return _this.$el.append(element);
});
}
});
}).call(this);
(function() {
_.def('Luca.containers.PanelView')["extends"]('Luca.core.Container')["with"]({
className: 'luca-ui-panel',
initialize: function(options) {
this.options = options != null ? options : {};
return Luca.core.Container.prototype.initialize.apply(this, arguments);
},
afterLayout: function() {
var contents;
if (this.template) {
contents = (Luca.templates || JST)[this.template](this);
return this.$el.html(contents);
}
},
render: function() {
return $(this.container).append(this.$el);
},
afterRender: function() {
var _ref,
_this = this;
if ((_ref = Luca.core.Container.prototype.afterRender) != null) {
_ref.apply(this, arguments);
}
if (this.css) {
return _(this.css).each(function(value, property) {
return _this.$el.css(property, value);
});
}
}
});
}).call(this);
(function() {
_.def('Luca.containers.TabView')["extends"]('Luca.containers.CardView')["with"]({
hooks: ["before:select", "after:select"],
componentType: 'tab_view',
className: 'luca-ui-tab-view tabbable',
tab_position: 'top',
tabVerticalOffset: '50px',
navClass: "nav-tabs",
bodyTemplate: "containers/tab_view",
bodyEl: "div.tab-content",
initialize: function(options) {
this.options = options != null ? options : {};
if (this.navStyle === "list") this.navClass = "nav-list";
Luca.containers.CardView.prototype.initialize.apply(this, arguments);
_.bindAll(this, "select", "highlightSelectedTab");
this.setupHooks(this.hooks);
return this.bind("after:card:switch", this.highlightSelectedTab);
},
activeTabSelector: function() {
return this.tabSelectors().eq(this.activeCard || this.activeTab || this.activeItem);
},
beforeLayout: function() {
var _ref;
this.$el.addClass("tabs-" + this.tab_position);
this.activeTabSelector().addClass('active');
this.createTabSelectors();
return (_ref = Luca.containers.CardView.prototype.beforeLayout) != null ? _ref.apply(this, arguments) : void 0;
},
afterRender: function() {
var _ref;
if ((_ref = Luca.containers.CardView.prototype.afterRender) != null) {
_ref.apply(this, arguments);
}
this.registerEvent("click #" + this.cid + "-tabs-selector li a", "select");
if (Luca.enableBootstrap && (this.tab_position === "left" || this.tab_position === "right")) {
this.tabContainerWrapper().addClass("span2");
return this.tabContentWrapper().addClass("span9");
}
},
createTabSelectors: function() {
var tabView;
tabView = this;
return this.each(function(component, index) {
var icon, link, selector, _ref;
if (component.tabIcon) icon = "" + (icon || '') + " " + component.title + "";
selector = tabView.make("li", {
"class": "tab-selector",
"data-target": index
}, link);
tabView.tabContainer().append(selector);
if ((component.navHeading != null) && !((_ref = tabView.navHeadings) != null ? _ref[component.navHeading] : void 0)) {
$(selector).before(tabView.make('li', {
"class": "nav-header"
}, component.navHeading));
tabView.navHeadings || (tabView.navHeadings = {});
return tabView.navHeadings[component.navHeading] = true;
}
});
},
highlightSelectedTab: function() {
this.tabSelectors().removeClass('active');
return this.activeTabSelector().addClass('active');
},
select: function(e) {
var me, my;
e.preventDefault();
me = my = $(e.target);
this.trigger("before:select", this);
this.activate(my.parent().data('target'));
return this.trigger("after:select", this);
},
componentElements: function() {
return this.$(">.tab-content >." + this.componentClass);
},
tabContentWrapper: function() {
return $("#" + this.cid + "-tab-view-content");
},
tabContainerWrapper: function() {
return $("#" + this.cid + "-tabs-selector");
},
tabContainer: function() {
return this.$("ul." + this.navClass, this.tabContainerWrapper());
},
tabSelectors: function() {
return this.$('li.tab-selector', this.tabContainer());
}
});
}).call(this);
(function() {
_.def('Luca.containers.Viewport').extend('Luca.containers.CardView')["with"]({
activeItem: 0,
additionalClassNames: 'luca-ui-viewport',
fullscreen: true,
fluid: false,
wrapperClass: 'row',
initialize: function(options) {
this.options = options != null ? options : {};
_.extend(this, this.options);
if (Luca.enableBootstrap === true) {
if (this.fluid === true) {
this.wrapperClass = "row-fluid fluid-viewport-wrapper";
}
}
Luca.core.Container.prototype.initialize.apply(this, arguments);
if (this.fullscreen) return $('html,body').addClass('luca-ui-fullscreen');
},
beforeRender: function() {
var _ref;
if ((_ref = Luca.containers.CardView.prototype.beforeRender) != null) {
_ref.apply(this, arguments);
}
if (this.topNav != null) this.renderTopNavigation();
if (this.bottomNav != null) return this.renderBottomNavigation();
},
afterRender: function() {
var _ref;
if ((_ref = Luca.containers.CardView.prototype.after) != null) {
_ref.apply(this, arguments);
}
if (Luca.enableBootstrap === true && this.containerClassName) {
return this.$el.children().wrap('');
}
},
renderTopNavigation: function() {
var _base;
if (this.topNav == null) return;
if (_.isString(this.topNav)) {
this.topNav = Luca.util.lazyComponent(this.topNav);
}
if (_.isObject(this.topNav)) {
(_base = this.topNav).ctype || (_base.ctype = this.topNav.type || "nav_bar");
if (!Luca.isBackboneView(this.topNav)) {
this.topNav = Luca.util.lazyComponent(this.topNav);
}
}
this.topNav.app = this;
return $('body').prepend(this.topNav.render().el);
},
renderBottomNavigation: function() {}
});
}).call(this);
(function() {
}).call(this);
(function() {
}).call(this);