luca 0.6.6

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

@@ -0,0 +1,207 @@
+(function() {
+
+  Luca.components.FormView = Luca.core.Container.extend({
+    tagName: 'form',
+    className: 'luca-ui-form-view',
+    hooks: ["before:submit", "before:reset", "before:load", "before:load:new", "before:load:existing", "after:submit", "after:reset", "after:load", "after:load:new", "after:load:existing", "after:submit:success", "after:submit:fatal_error", "after:submit:error"],
+    events: {
+      "click .submit-button": "submitHandler",
+      "click .reset-button": "resetHandler"
+    },
+    toolbar: true,
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      _.bindAll(this, "submitHandler", "resetHandler", "renderToolbars");
+      this.state || (this.state = new Backbone.Model);
+      this.setupHooks(this.hooks);
+      this.legend || (this.legend = "");
+      this.configureToolbars();
+      return this.applyStyles();
+    },
+    addBootstrapFormControls: function() {
+      var _this = this;
+      return this.bind("after:render", function() {
+        var el;
+        el = _this.$('.toolbar-container.bottom');
+        el.addClass('form-controls');
+        return el.html(_this.formControlsTemplate || Luca.templates["components/bootstrap_form_controls"](_this));
+      });
+    },
+    applyStyles: function() {
+      if (Luca.enableBootstrap) this.applyBootstrapStyles();
+      if (this.labelAlign) this.$el.addClass("label-align-" + this.labelAlign);
+      if (this.fieldLayoutClass) return this.$el.addClass(this.fieldLayoutClass);
+    },
+    applyBootstrapStyles: function() {
+      if (this.labelAlign === "left") this.inlineForm = true;
+      if (this.well) this.$el.addClass('well');
+      if (this.searchForm) this.$el.addClass('form-search');
+      if (this.horizontalForm) this.$el.addClass('form-horizontal');
+      if (this.inlineForm) return this.$el.addClass('form-inline');
+    },
+    configureToolbars: function() {
+      if (Luca.enableBootstrap && this.toolbar === true) {
+        return this.addBootstrapFormControls();
+      }
+      if (this.toolbar === true) {
+        this.toolbars = [
+          {
+            ctype: 'form_button_toolbar',
+            includeReset: true,
+            position: 'bottom'
+          }
+        ];
+      }
+      if (this.toolbars && this.toolbars.length) {
+        return this.bind("after:render", _.once(this.renderToolbars));
+      }
+    },
+    resetHandler: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      this.trigger("before:reset", this);
+      this.reset();
+      return this.trigger("after:reset", this);
+    },
+    submitHandler: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      this.trigger("before:submit", this);
+      return this.submit();
+    },
+    beforeLayout: function() {
+      var _ref;
+      if ((_ref = Luca.core.Container.prototype.beforeLayout) != null) {
+        _ref.apply(this, arguments);
+      }
+      return this.$el.html(Luca.templates["components/form_view"](this));
+    },
+    prepareComponents: function() {
+      var container;
+      container = $('.form-view-body', this.el);
+      return _(this.components).each(function(component) {
+        return component.container = container;
+      });
+    },
+    render: function() {
+      return $(this.container).append(this.$el);
+    },
+    wrapper: function() {
+      return this.$el.parents('.luca-ui-form-view-wrapper');
+    },
+    toolbarContainers: function(position) {
+      if (position == null) position = "bottom";
+      return $(".toolbar-container." + position, this.wrapper()).first();
+    },
+    renderToolbars: function() {
+      var _this = this;
+      return _(this.toolbars).each(function(toolbar) {
+        toolbar.container = $("#" + _this.cid + "-" + toolbar.position + "-toolbar-container");
+        toolbar = Luca.util.lazyComponent(toolbar);
+        return toolbar.render();
+      });
+    },
+    getField: function(name) {
+      return _(this.getFields('name', name)).first();
+    },
+    getFields: function(attr, value) {
+      var fields;
+      fields = this.select("isField", true, true);
+      if (fields.length > 0 && attr && value) {
+        fields = _(fields).select(function(field) {
+          var property, propvalue;
+          property = field[attr];
+          if (property == null) return false;
+          propvalue = _.isFunction(property) ? property() : property;
+          return value === propvalue;
+        });
+      }
+      return fields;
+    },
+    loadModel: function(current_model) {
+      var event, fields, form,
+        _this = this;
+      this.current_model = current_model;
+      form = this;
+      fields = this.getFields();
+      this.trigger("before:load", this, this.current_model);
+      if (this.current_model) {
+        event = "before:load:" + (this.current_model.isNew() ? "new" : "existing");
+        this.trigger(event, this, this.current_model);
+      }
+      _(fields).each(function(field) {
+        var field_name, value;
+        field_name = field.input_name || field.name;
+        value = _.isFunction(_this.current_model[field_name]) ? _this.current_model[field_name].apply(_this, form) : _this.current_model.get(field_name);
+        if (field.readOnly !== true) {
+          return field != null ? field.setValue(value) : void 0;
+        }
+      });
+      this.trigger("after:load", this, this.current_model);
+      if (this.current_model) {
+        return this.trigger("after:load:" + (this.current_model.isNew() ? "new" : "existing"), this, this.current_model);
+      }
+    },
+    reset: function() {
+      return this.loadModel(this.current_model);
+    },
+    clear: function() {
+      var _this = this;
+      this.current_model = this.defaultModel != null ? this.defaultModel() : void 0;
+      return _(this.getFields()).each(function(field) {
+        try {
+          return field.setValue('');
+        } catch (e) {
+          return console.log("Error Clearing", _this, field);
+        }
+      });
+    },
+    getValues: function(reject_blank, skip_buttons) {
+      if (reject_blank == null) reject_blank = false;
+      if (skip_buttons == null) skip_buttons = true;
+      return _(this.getFields()).inject(function(memo, field) {
+        var skip, value;
+        value = field.getValue();
+        skip = false;
+        if (skip_buttons && field.ctype === "button_field") skip = true;
+        if (reject_blank && _.isBlank(value)) skip = true;
+        if (field.input_name === "id" && _.isBlank(value)) skip = true;
+        if (!skip) memo[field.input_name || name] = value;
+        return memo;
+      }, {});
+    },
+    submit_success_handler: function(model, response, xhr) {
+      this.trigger("after:submit", this, model, response);
+      if (response && response.success) {
+        return this.trigger("after:submit:success", this, model, response);
+      } else {
+        return this.trigger("after:submit:error", this, model, response);
+      }
+    },
+    submit_fatal_error_handler: function() {
+      this.trigger.apply(["after:submit", this].concat(arguments));
+      return this.trigger.apply(["after:submit:fatal_error", this].concat(arguments));
+    },
+    submit: function(save, saveOptions) {
+      if (save == null) save = true;
+      if (saveOptions == null) saveOptions = {};
+      _.bindAll(this, "submit_success_handler", "submit_fatal_error_handler");
+      saveOptions.success || (saveOptions.success = this.submit_success_handler);
+      saveOptions.error || (saveOptions.error = this.submit_fatal_error_handler);
+      this.current_model.set(this.getValues());
+      if (!save) return;
+      return this.current_model.save(this.current_model.toJSON(), saveOptions);
+    },
+    currentModel: function() {
+      return this.current_model;
+    },
+    setLegend: function(legend) {
+      this.legend = legend;
+      return $('fieldset legend', this.el).first().html(this.legend);
+    }
+  });
+
+  Luca.register('form_view', 'Luca.components.FormView');
+
+}).call(this);

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

@@ -0,0 +1,76 @@
+.scrollable-grid-view {
+  /* define height and width of scrollable area. Add 16px to width for scrollbar          */
+  /* Reset overflow value to hidden for all non-IE browsers. */
+  /* define width of table. IE browsers only                 */
+  /* define width of table. Add 16px to width for scrollbar.           */
+  /* All other non-IE browsers.                                        */
+  /* set table header to a fixed position. WinIE 6.x only                                       */
+  /* In WinIE 6.x, any element with a position property set to relative and is a child of       */
+  /* an element that has an overflow property set, the relative value translates into fixed.    */
+  /* Ex: parent element DIV with a class of tableContainer has an overflow property set to auto */
+  /* set THEAD element to have block level attributes. All other non-IE browsers            */
+  /* this enables overflow to work on TBODY element. All other non-IE, non-Mozilla browsers */
+  /* make the TH elements pretty */
+  /* make the A elements pretty. makes for nice clickable headers                */
+  /* make the A elements pretty. makes for nice clickable headers                */
+  /* WARNING: swapping the background on hover may cause problems in WinIE 6.x   */
+  /* define the table content to be scrollable                                              */
+  /* set TBODY element to have block level attributes. All other non-IE browsers            */
+  /* this enables overflow to work on TBODY element. All other non-IE, non-Mozilla browsers */
+  /* induced side effect is that child TDs no longer accept width: auto                     */
+  /* define width of TH elements: 1st, 2nd, and 3rd respectively.          */
+  /* Add 16px to last TH for scrollbar padding. All other non-IE browsers. */
+  /* http://www.w3.org/TR/REC-CSS2/selector.html#adjacent-selectors        */
+  /* define width of TD elements: 1st, 2nd, and 3rd respectively.          */
+  /* All other non-IE browsers.                                            */
+  /* http://www.w3.org/TR/REC-CSS2/selector.html#adjacent-selectors        */ }
+  .scrollable-grid-view .grid-view-body {
+    clear: both;
+    overflow: auto; }
+  .scrollable-grid-view .grid-view-body {
+    overflow: hidden; }
+  .scrollable-grid-view .grid-view-body .empty-text-wrapper {
+    display: block;
+    margin: 10px auto;
+    width: 30%;
+    padding: 50px;
+    text-align: center; }
+    .scrollable-grid-view .grid-view-body .empty-text-wrapper p {
+      color: #aaa; }
+  .scrollable-grid-view thead.fixed tr {
+    position: relative; }
+  .scrollable-grid-view thead.fixed tr {
+    display: block; }
+  .scrollable-grid-view thead.fixed th {
+    font-weight: bold;
+    text-align: left; }
+  .scrollable-grid-view thead.fixed a, .scrollable-grid-view thead.fixed a:link, .scrollable-grid-view thead.fixed a:visited {
+    color: #FFF;
+    display: block;
+    text-decoration: none;
+    width: 100%; }
+  .scrollable-grid-view thead.fixed a:hover {
+    color: #FFF;
+    display: block;
+    text-decoration: underline;
+    width: 100%; }
+  .scrollable-grid-view tbody.scrollable {
+    display: block;
+    overflow: auto;
+    width: 100%; }
+  .scrollable-grid-view thead.fixed th {
+    padding: 5px; }
+  .scrollable-grid-view tbody.scrollable td {
+    padding: 5px; }
+
+.grid-view-footer .toolbar-container {
+  float: left;
+  width: 100%;
+  clear: both;
+  display: block; }
+  .grid-view-footer .toolbar-container .luca-ui-toolbar {
+    display: block;
+    float: right;
+    clear: right; }
+    .grid-view-footer .toolbar-container .luca-ui-toolbar .luca-ui-field {
+      float: left; }

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

@@ -0,0 +1,202 @@
+(function() {
+
+  Luca.components.GridView = Luca.View.extend({
+    events: {
+      "dblclick .grid-view-row": "double_click_handler",
+      "click .grid-view-row": "click_handler"
+    },
+    className: 'luca-ui-grid-view',
+    scrollable: true,
+    emptyText: 'No Results To display',
+    tableStyle: 'striped',
+    hooks: ["before:grid:render", "before:render:header", "before:render:row", "after:grid:render", "row:double:click", "row:click", "after:collection:load"],
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.extend(this, Luca.modules.Deferrable);
+      Luca.View.prototype.initialize.apply(this, arguments);
+      _.bindAll(this, "double_click_handler", "click_handler");
+      this.configure_collection();
+      return this.collection.bind("reset", function(collection) {
+        _this.refresh();
+        return _this.trigger("after:collection:load", collection);
+      });
+    },
+    beforeRender: function() {
+      var _ref,
+        _this = this;
+      this.trigger("before:grid:render", this);
+      if (this.scrollable) this.$el.addClass('scrollable-grid-view');
+      this.$el.html(Luca.templates["components/grid_view"]());
+      this.table = $('table.luca-ui-grid-view', this.el);
+      this.header = $("thead", this.table);
+      this.body = $("tbody", this.table);
+      this.footer = $("tfoot", this.table);
+      if (Luca.enableBootstrap) this.table.addClass('table');
+      _((_ref = this.tableStyle) != null ? _ref.split(" ") : void 0).each(function(style) {
+        return _this.table.addClass("table-" + style);
+      });
+      if (this.scrollable) this.setDimensions();
+      this.renderHeader();
+      this.emptyMessage();
+      this.renderToolbars();
+      return $(this.container).append(this.$el);
+    },
+    toolbarContainers: function(position) {
+      if (position == null) position = "bottom";
+      return $(".toolbar-container." + position, this.el);
+    },
+    renderToolbars: function() {
+      var _this = this;
+      return _(this.toolbars).each(function(toolbar) {
+        toolbar = Luca.util.lazyComponent(toolbar);
+        toolbar.container = _this.toolbarContainers(toolbar.position);
+        return toolbar.render();
+      });
+    },
+    setDimensions: function(offset) {
+      var _this = this;
+      this.height || (this.height = 285);
+      $('.grid-view-body', this.el).height(this.height);
+      $('tbody.scrollable', this.el).height(this.height - 23);
+      this.container_width = (function() {
+        return $(_this.container).width();
+      })();
+      this.width = this.container_width > 0 ? this.container_width : 756;
+      $('.grid-view-body', this.el).width(this.width);
+      $('.grid-view-body table', this.el).width(this.width);
+      return this.setDefaultColumnWidths();
+    },
+    resize: function(newWidth) {
+      var difference, distribution,
+        _this = this;
+      difference = newWidth - this.width;
+      this.width = newWidth;
+      $('.grid-view-body', this.el).width(this.width);
+      $('.grid-view-body table', this.el).width(this.width);
+      if (this.columns.length > 0) {
+        distribution = difference / this.columns.length;
+        return _(this.columns).each(function(col, index) {
+          var column;
+          column = $(".column-" + index, _this.el);
+          return column.width(col.width = col.width + distribution);
+        });
+      }
+    },
+    padLastColumn: function() {
+      var configured_column_widths, unused_width;
+      configured_column_widths = _(this.columns).inject(function(sum, column) {
+        return sum = column.width + sum;
+      }, 0);
+      unused_width = this.width - configured_column_widths;
+      if (unused_width > 0) return this.lastColumn().width += unused_width;
+    },
+    setDefaultColumnWidths: function() {
+      var default_column_width;
+      default_column_width = this.columns.length > 0 ? this.width / this.columns.length : 200;
+      _(this.columns).each(function(column) {
+        return parseInt(column.width || (column.width = default_column_width));
+      });
+      return this.padLastColumn();
+    },
+    lastColumn: function() {
+      return this.columns[this.columns.length - 1];
+    },
+    afterRender: function() {
+      this.refresh();
+      return this.trigger("after:grid:render", this);
+    },
+    emptyMessage: function(text) {
+      if (text == null) text = "";
+      text || (text = this.emptyText);
+      this.body.html('');
+      return this.body.append(Luca.templates["components/grid_view_empty_text"]({
+        colspan: this.columns.length,
+        text: text
+      }));
+    },
+    refresh: function() {
+      var _this = this;
+      this.body.html('');
+      this.collection.each(function(model, index) {
+        return _this.render_row.apply(_this, [model, index]);
+      });
+      if (this.collection.models.length === 0) return this.emptyMessage();
+    },
+    ifLoaded: function(fn, scope) {
+      scope || (scope = this);
+      fn || (fn = function() {
+        return true;
+      });
+      return this.collection.ifLoaded(fn, scope);
+    },
+    applyFilter: function(values, options) {
+      if (options == null) {
+        options = {
+          auto: true,
+          refresh: true
+        };
+      }
+      return this.collection.applyFilter(values, options);
+    },
+    renderHeader: function() {
+      var headers,
+        _this = this;
+      this.trigger("before:render:header");
+      headers = _(this.columns).map(function(column, column_index) {
+        var style;
+        style = column.width ? "width:" + column.width + "px;" : "";
+        return "<th style='" + style + "' class='column-" + column_index + "'>" + column.header + "</th>";
+      });
+      return this.header.append("<tr>" + headers + "</tr>");
+    },
+    render_row: function(row, row_index) {
+      var alt_class, cells, model_id, _ref,
+        _this = this;
+      model_id = (row != null ? row.get : void 0) && (row != null ? row.attributes : void 0) ? row.get('id') : '';
+      this.trigger("before:render:row", row, row_index);
+      cells = _(this.columns).map(function(column, col_index) {
+        var display, style, value;
+        value = _this.cell_renderer(row, column, col_index);
+        style = column.width ? "width:" + column.width + "px;" : "";
+        display = _.isUndefined(value) ? "" : value;
+        return "<td style='" + style + "' class='column-" + col_index + "'>" + display + "</td>";
+      });
+      if (this.alternateRowClasses) {
+        alt_class = row_index % 2 === 0 ? "even" : "odd";
+      }
+      return (_ref = this.body) != null ? _ref.append("<tr data-record-id='" + model_id + "' data-row-index='" + row_index + "' class='grid-view-row " + alt_class + "' id='row-" + row_index + "'>" + cells + "</tr>") : void 0;
+    },
+    cell_renderer: function(row, column, columnIndex) {
+      var source;
+      if (_.isFunction(column.renderer)) {
+        return column.renderer.apply(this, [row, column, columnIndex]);
+      } else if (column.data.match(/\w+\.\w+/)) {
+        source = row.attributes || row;
+        return Luca.util.nestedValue(column.data, source);
+      } else {
+        return (typeof row.get === "function" ? row.get(column.data) : void 0) || row[column.data];
+      }
+    },
+    double_click_handler: function(e) {
+      var me, my, record, rowIndex;
+      me = my = $(e.currentTarget);
+      rowIndex = my.data('row-index');
+      record = this.collection.at(rowIndex);
+      return this.trigger("row:double:click", this, record, rowIndex);
+    },
+    click_handler: function(e) {
+      var me, my, record, rowIndex;
+      me = my = $(e.currentTarget);
+      rowIndex = my.data('row-index');
+      record = this.collection.at(rowIndex);
+      this.trigger("row:click", this, record, rowIndex);
+      $('.grid-view-row', this.body).removeClass('selected-row');
+      return me.addClass('selected-row');
+    }
+  });
+
+  Luca.register("grid_view", "Luca.components.GridView");
+
+}).call(this);

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

@@ -0,0 +1,207 @@
+(function() {
+
+  Luca.components.RecordManager = Luca.containers.CardView.extend({
+    events: {
+      "click .record-manager-grid .edit-link": "edit_handler",
+      "click .record-manager-filter .filter-button": "filter_handler",
+      "click .record-manager-filter .reset-button": "reset_filter_handler",
+      "click .add-button": "add_handler",
+      "click .refresh-button": "filter_handler",
+      "click .back-to-search-button": "back_to_search_handler"
+    },
+    record_manager: true,
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      Luca.containers.CardView.prototype.initialize.apply(this, arguments);
+      if (!this.name) throw "Record Managers must specify a name";
+      _.bindAll(this, "add_handler", "edit_handler", "filter_handler", "reset_filter_handler");
+      if (this.filterConfig) _.extend(this.components[0][0], this.filterConfig);
+      if (this.gridConfig) _.extend(this.components[0][1], this.gridConfig);
+      if (this.editorConfig) _.extend(this.components[1][0], this.editorConfig);
+      return this.bind("after:card:switch", function() {
+        if (_this.activeCard === 0) _this.trigger("activation:search", _this);
+        if (_this.activeCard === 1) {
+          return _this.trigger("activation:editor", _this);
+        }
+      });
+    },
+    components: [
+      {
+        ctype: 'split_view',
+        relayFirstActivation: true,
+        components: [
+          {
+            ctype: 'form_view'
+          }, {
+            ctype: 'grid_view'
+          }
+        ]
+      }, {
+        ctype: 'form_view'
+      }
+    ],
+    getSearch: function(activate, reset) {
+      if (activate == null) activate = false;
+      if (reset == null) reset = true;
+      if (activate === true) this.activate(0);
+      if (reset === true) this.getEditor().clear();
+      return _.first(this.components);
+    },
+    getFilter: function() {
+      return _.first(this.getSearch().components);
+    },
+    getGrid: function() {
+      return _.last(this.getSearch().components);
+    },
+    getCollection: function() {
+      return this.getGrid().collection;
+    },
+    getEditor: function(activate, reset) {
+      var _this = this;
+      if (activate == null) activate = false;
+      if (reset == null) reset = false;
+      if (activate === true) {
+        this.activate(1, function(activator, previous, current) {
+          return current.reset();
+        });
+      }
+      return _.last(this.components);
+    },
+    beforeRender: function() {
+      var _ref;
+      this.$el.addClass("" + this.resource + "-manager");
+      if ((_ref = Luca.containers.CardView.prototype.beforeRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.$el.addClass("" + this.resource + " record-manager");
+      this.$el.data('resource', this.resource);
+      $(this.getGrid().el).addClass("" + this.resource + " record-manager-grid");
+      $(this.getFilter().el).addClass("" + this.resource + " record-manager-filter");
+      return $(this.getEditor().el).addClass("" + this.resource + " record-manager-editor");
+    },
+    afterRender: function() {
+      var collection, editor, filter, grid, manager, _ref,
+        _this = this;
+      if ((_ref = Luca.containers.CardView.prototype.afterRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      manager = this;
+      grid = this.getGrid();
+      filter = this.getFilter();
+      editor = this.getEditor();
+      collection = this.getCollection();
+      grid.bind("row:double:click", function(grid, model, index) {
+        manager.getEditor(true);
+        return editor.loadModel(model);
+      });
+      editor.bind("before:submit", function() {
+        $('.form-view-flash-container', _this.el).html('');
+        return $('.form-view-body', _this.el).spin("large");
+      });
+      editor.bind("after:submit", function() {
+        return $('.form-view-body', _this.el).spin(false);
+      });
+      editor.bind("after:submit:fatal_error", function() {
+        $('.form-view-flash-container', _this.el).append("<li class='error'>There was an internal server error saving this record.  Please contact developers@benchprep.com to report this error.</li>");
+        return $('.form-view-body', _this.el).spin(false);
+      });
+      editor.bind("after:submit:error", function(form, model, response) {
+        return _(response.errors).each(function(error) {
+          return $('.form-view-flash-container', _this.el).append("<li class='error'>" + error + "</li>");
+        });
+      });
+      editor.bind("after:submit:success", function(form, model, response) {
+        $('.form-view-flash-container', _this.el).append("<li class='success'>Successfully Saved Record</li>");
+        model.set(response.result);
+        form.loadModel(model);
+        grid.refresh();
+        return _.delay(function() {
+          $('.form-view-flash-container li.success', _this.el).fadeOut(1000);
+          return $('.form-view-flash-container', _this.el).html('');
+        }, 4000);
+      });
+      return filter.eachComponent(function(component) {
+        try {
+          return component.bind("on:change", _this.filter_handler);
+        } catch (e) {
+          return;
+        }
+      });
+    },
+    firstActivation: function() {
+      this.getGrid().trigger("first:activation", this, this.getGrid());
+      return this.getFilter().trigger("first:activation", this, this.getGrid());
+    },
+    reload: function() {
+      var editor, filter, grid, manager;
+      manager = this;
+      grid = this.getGrid();
+      filter = this.getFilter();
+      editor = this.getEditor();
+      filter.clear();
+      return grid.applyFilter();
+    },
+    manageRecord: function(record_id) {
+      var model,
+        _this = this;
+      model = this.getCollection().get(record_id);
+      if (model) return this.loadModel(model);
+      console.log("Could Not Find Model, building and fetching");
+      model = this.buildModel();
+      model.set({
+        id: record_id
+      }, {
+        silent: true
+      });
+      return model.fetch({
+        success: function(model, response) {
+          return _this.loadModel(model);
+        }
+      });
+    },
+    loadModel: function(current_model) {
+      this.current_model = current_model;
+      this.getEditor(true).loadModel(this.current_model);
+      return this.trigger("model:loaded", this.current_model);
+    },
+    currentModel: function() {
+      return this.getEditor(false).currentModel();
+    },
+    buildModel: function() {
+      var collection, editor, model;
+      editor = this.getEditor(false);
+      collection = this.getCollection();
+      collection.add([{}], {
+        silent: true,
+        at: 0
+      });
+      return model = collection.at(0);
+    },
+    createModel: function() {
+      return this.loadModel(this.buildModel());
+    },
+    reset_filter_handler: function(e) {
+      this.getFilter().clear();
+      return this.getGrid().applyFilter(this.getFilter().getValues());
+    },
+    filter_handler: function(e) {
+      return this.getGrid().applyFilter(this.getFilter().getValues());
+    },
+    edit_handler: function(e) {
+      var me, model, my, record_id;
+      me = my = $(e.currentTarget);
+      record_id = my.parents('tr').data('record-id');
+      if (record_id) model = this.getGrid().collection.get(record_id);
+      return model || (model = this.getGrid().collection.at(row_index));
+    },
+    add_handler: function(e) {
+      var me, my, resource;
+      me = my = $(e.currentTarget);
+      return resource = my.parents('.record-manager').eq(0).data('resource');
+    },
+    destroy_handler: function(e) {},
+    back_to_search_handler: function() {}
+  });
+
+}).call(this);