luca 0.6.6

data/vendor/assets/luca-ui/components/router.js

@@ -0,0 +1,36 @@
+(function() {
+
+  Luca.Router = Backbone.Router.extend({
+    routes: {
+      "": "default"
+    },
+    initialize: function(options) {
+      var _this = this;
+      this.options = options;
+      _.extend(this, this.options);
+      this.routeHandlers = _(this.routes).values();
+      return _(this.routeHandlers).each(function(route_id) {
+        return _this.bind("route:" + route_id, function() {
+          return _this.trigger.apply(_this, ["change:navigation", route_id].concat(_(arguments).flatten()));
+        });
+      });
+    },
+    navigate: function(route, triggerRoute) {
+      if (triggerRoute == null) triggerRoute = false;
+      Backbone.Router.prototype.navigate.apply(this, arguments);
+      return this.buildPathFrom(Backbone.history.getFragment());
+    },
+    buildPathFrom: function(matchedRoute) {
+      var _this = this;
+      return _(this.routes).each(function(route_id, route) {
+        var args, regex;
+        regex = _this._routeToRegExp(route);
+        if (regex.test(matchedRoute)) {
+          args = _this._extractParameters(regex, matchedRoute);
+          return _this.trigger.apply(_this, ["change:navigation", route_id].concat(args));
+        }
+      });
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/components/template.js

@@ -0,0 +1,26 @@
+(function() {
+
+  Luca.components.Template = Luca.View.extend({
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.View.prototype.initialize.apply(this, arguments);
+      if (!(this.template || this.markup)) {
+        throw "Templates must specify which template / markup to use";
+      }
+      if (_.isString(this.templateContainer)) {
+        return this.templateContainer = eval("(window || global)." + this.templateContainer);
+      }
+    },
+    templateContainer: "Luca.templates",
+    beforeRender: function() {
+      if (_.isUndefined(this.templateContainer)) this.templateContainer = JST;
+      return this.$el.html(this.markup || this.templateContainer[this.template](this.options));
+    },
+    render: function() {
+      return $(this.container).append(this.$el);
+    }
+  });
+
+  Luca.register("template", "Luca.components.Template");
+
+}).call(this);

data/vendor/assets/luca-ui/components/toolbar.css

@@ -0,0 +1,11 @@
+.luca-ui-toolbar-wrapper {
+  clear: both;
+  display: block;
+  float: left;
+  width: 100%; }
+  .luca-ui-toolbar-wrapper .luca-ui-form-toolbar, .luca-ui-toolbar-wrapper .luca-ui-toolbar {
+    clear: both;
+    margin: 5px auto; }
+    .luca-ui-toolbar-wrapper .luca-ui-form-toolbar .luca-ui-field, .luca-ui-toolbar-wrapper .luca-ui-toolbar .luca-ui-field {
+      float: left;
+      margin: 5px; }

data/vendor/assets/luca-ui/containers/card_view.js

@@ -0,0 +1,98 @@
+(function() {
+
+  Luca.containers.CardView = Luca.core.Container.extend({
+    componentType: 'card_view',
+    className: 'luca-ui-card-view-wrapper',
+    activeCard: 0,
+    components: [],
+    hooks: ['before:card:switch', 'after:card:switch'],
+    initialize: function(options) {
+      this.options = options;
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      return this.setupHooks(this.hooks);
+    },
+    componentClass: 'luca-ui-card',
+    beforeLayout: function() {
+      var _this = this;
+      return this.cards = _(this.components).map(function(card, cardIndex) {
+        return {
+          classes: _this.componentClass,
+          style: "display:" + (cardIndex === _this.activeCard ? 'block' : 'none'),
+          id: "" + _this.cid + "-" + cardIndex
+        };
+      });
+    },
+    prepareLayout: function() {
+      var _this = this;
+      return this.card_containers = _(this.cards).map(function(card, index) {
+        _this.$el.append(Luca.templates["containers/basic"](card));
+        return $("#" + card.id);
+      });
+    },
+    prepareComponents: function() {
+      var _this = this;
+      return this.components = _(this.components).map(function(object, index) {
+        var card;
+        card = _this.cards[index];
+        object.container = "#" + card.id;
+        return object;
+      });
+    },
+    activeComponent: function() {
+      return this.getComponent(this.activeCard);
+    },
+    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;
+      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);
+      _(this.card_containers).each(function(container) {
+        var _ref;
+        if ((_ref = container.trigger) != null) {
+          _ref.apply(container, ["deactivation", this, previous, current]);
+        }
+        return container.hide();
+      });
+      if (!current.previously_activated) {
+        current.trigger("first:activation");
+        current.previously_activated = true;
+      }
+      $(current.container).show();
+      this.activeCard = index;
+      if (!silent) {
+        this.trigger("after:card:switch", previous, current);
+        if ((_ref = current.trigger) != null) {
+          _ref.apply(current, ["activation", this, previous, current]);
+        }
+      }
+      if (_.isFunction(callback)) {
+        return callback.apply(this, [this, previous, current]);
+      }
+    }
+  });
+
+  Luca.register('card_view', "Luca.containers.CardView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/column_view.js

@@ -0,0 +1,52 @@
+(function() {
+
+  Luca.containers.ColumnView = Luca.core.Container.extend({
+    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 + "%";
+      });
+    },
+    beforeComponents: function() {
+      this.debug("column_view before components");
+      return _(this.components).each(function(component) {
+        return component.ctype || (component.ctype = "panel_view");
+      });
+    },
+    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;
+    }
+  });
+
+  Luca.register('column_view', "Luca.containers.ColumnView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/container.css

@@ -0,0 +1,3 @@
+.luca-ui-card {
+  padding: 5px;
+  width: 100%; }

data/vendor/assets/luca-ui/containers/modal_view.js

@@ -0,0 +1,87 @@
+(function() {
+
+  Luca.containers.ModalView = Luca.core.Container.extend({
+    componentType: 'modal_view',
+    className: 'luca-ui-modal-view',
+    components: [],
+    renderOnInitialize: true,
+    showOnRender: false,
+    hooks: ['before:show', 'before:hide'],
+    defaultModalOptions: {
+      minWidth: 375,
+      maxWidth: 375,
+      minHeight: 550,
+      maxHeight: 550,
+      opacity: 80,
+      onOpen: function(modal) {
+        this.onOpen.apply(this);
+        return this.onModalOpen.apply(modal, [modal, this]);
+      },
+      onClose: function(modal) {
+        this.onClose.apply(this);
+        return this.onModalClose.apply(modal, [modal, this]);
+      }
+    },
+    modalOptions: {},
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      this.setupHooks(this.hooks);
+      _(this.defaultModalOptions).each(function(value, setting) {
+        var _base;
+        return (_base = _this.modalOptions)[setting] || (_base[setting] = value);
+      });
+      this.modalOptions.onOpen = _.bind(this.modalOptions.onOpen, this);
+      return this.modalOptions.onClose = _.bind(this.modalOptions.onClose, this);
+    },
+    onOpen: function() {
+      return true;
+    },
+    onClose: function() {
+      return true;
+    },
+    getModal: function() {
+      return this.modal;
+    },
+    onModalOpen: function(modal, view) {
+      view.modal = modal;
+      modal.overlay.show();
+      modal.container.show();
+      return modal.data.show();
+    },
+    onModalClose: function(modal, view) {
+      return $.modal.close();
+    },
+    prepareLayout: function() {
+      return $('body').append(this.$el);
+    },
+    prepareComponents: function() {
+      var _this = this;
+      return this.components = _(this.components).map(function(object, index) {
+        object.container = _this.el;
+        return object;
+      });
+    },
+    afterInitialize: function() {
+      this.$el.hide();
+      if (this.renderOnInitialize) return this.render();
+    },
+    afterRender: function() {
+      if (this.showOnRender) return this.show();
+    },
+    wrapper: function() {
+      return $(this.$el.parent());
+    },
+    show: function() {
+      this.trigger("before:show", this);
+      return this.$el.modal(this.modalOptions);
+    },
+    hide: function() {
+      return this.trigger("before:hide", this);
+    }
+  });
+
+  Luca.register("modal_view", "Luca.containers.ModalView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/panel_view.js

@@ -0,0 +1,34 @@
+(function() {
+
+  Luca.containers.PanelView = Luca.core.Container.extend({
+    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) {
+        console.log("Yes Yes Yall", this.css, this.$el);
+        return _(this.css).each(function(value, property) {
+          return _this.$el.css(property, value);
+        });
+      }
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/containers/split_view.js

@@ -0,0 +1,13 @@
+(function() {
+
+  Luca.containers.SplitView = Luca.core.Container.extend({
+    layout: '100',
+    componentType: 'split_view',
+    containerTemplate: 'containers/basic',
+    className: 'luca-ui-split-view',
+    componentClass: 'luca-ui-panel'
+  });
+
+  Luca.register('split_view', "Luca.containers.SplitView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/tab_view.css

@@ -0,0 +1,16 @@
+.luca-ui-tab-view .luca-ui-card .luca-ui-grid-view, .luca-ui-tab-view .luca-ui-card .luca-ui-form-view, .luca-ui-tab-view .luca-ui-card .luca-ui-card {
+  overflow: hidden; }
+
+.luca-ui-tab-view.tabs-below .tab-selector-container, .luca-ui-tab-view.tabs-right .tab-selector-container {
+  display: block;
+  clear: both; }
+
+.luca-ui-tab-view.tabs-left .tab-selector-container {
+  float: left; }
+.luca-ui-tab-view.tabs-left .tab-content {
+  float: left; }
+
+.luca-ui-tab-view.tabs-right .tab-selector-container {
+  float: right; }
+.luca-ui-tab-view.tabs-right .tab-content {
+  float: left; }

data/vendor/assets/luca-ui/containers/tab_view.js

@@ -0,0 +1,80 @@
+(function() {
+
+  Luca.containers.TabView = Luca.containers.CardView.extend({
+    events: {
+      "click ul.nav-tabs li": "select"
+    },
+    hooks: ["before:select", "after:select"],
+    componentType: 'tab_view',
+    className: 'luca-ui-tab-view tabbable',
+    tab_position: 'top',
+    tabVerticalOffset: '50px',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      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);
+    },
+    prepareLayout: function() {
+      var _this = this;
+      return this.card_containers = _(this.cards).map(function(card, index) {
+        _this.$('.tab-content').append(Luca.templates["containers/basic"](card));
+        return $("#" + card.id);
+      });
+    },
+    beforeLayout: function() {
+      this.$el.addClass("tabs-" + this.tab_position);
+      if (this.tab_position === "below") {
+        this.$el.append(Luca.templates["containers/tab_view"](this));
+        this.$el.append(Luca.templates["containers/tab_selector_container"](this));
+      } else {
+        this.$el.append(Luca.templates["containers/tab_selector_container"](this));
+        this.$el.append(Luca.templates["containers/tab_view"](this));
+      }
+      return Luca.containers.CardView.prototype.beforeLayout.apply(this, arguments);
+    },
+    beforeRender: function() {
+      var _ref;
+      if ((_ref = Luca.containers.CardView.prototype.beforeRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.activeTabSelector().addClass('active');
+      if (Luca.enableBootstrap && this.tab_position === "left" || this.tab_position === "right") {
+        this.$el.addClass('grid-12');
+        this.tabContainerWrapper().addClass('grid-3');
+        this.tabContentWrapper().addClass('grid-9');
+        if (this.tabVerticalOffset) {
+          return this.tabContainerWrapper().css('padding-top', this.tabVerticalOffset);
+        }
+      }
+    },
+    highlightSelectedTab: function() {
+      this.tabSelectors().removeClass('active');
+      return this.activeTabSelector().addClass('active');
+    },
+    select: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      this.trigger("before:select", this);
+      this.activate(my.data('target'));
+      return this.trigger("after:select", this);
+    },
+    tabContentWrapper: function() {
+      return $("#" + this.cid + "-tab-view-content");
+    },
+    tabContainerWrapper: function() {
+      return $("#" + this.cid + "-tabs-selector");
+    },
+    tabContainer: function() {
+      return $("ul#" + this.cid + "-tabs-nav");
+    },
+    tabSelectors: function() {
+      return $('li.tab-selector', this.tabContainer());
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/containers/viewport.js

@@ -0,0 +1,18 @@
+(function() {
+
+  Luca.containers.Viewport = Luca.containers.CardView.extend({
+    activeItem: 0,
+    className: 'luca-ui-viewport',
+    fullscreen: true,
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      if (this.fullscreen) return $('html,body').addClass('luca-ui-fullscreen');
+    },
+    render: function() {
+      console.log("Rendering Viewport");
+      return this.$el.addClass('luca-ui-viewport');
+    }
+  });
+
+}).call(this);