Current File : /home/riacommer/public_html/admin/vendor/backgrid/src/column.js
/*
backgrid
http://github.com/wyuenho/backgrid
Copyright (c) 2013 Jimmy Yuen Ho Wong and contributors
Licensed under the MIT license.
*/
/**
A Column is a placeholder for column metadata.
You usually don't need to create an instance of this class yourself as a
collection of column instances will be created for you from a list of column
attributes in the Backgrid.js view class constructors.
@class Backgrid.Column
@extends Backbone.Model
*/
var Column = Backgrid.Column = Backbone.Model.extend({
/**
@cfg {Object} defaults Column defaults. To override any of these default
values, you can either change the prototype directly to override
Column.defaults globally or extend Column and supply the custom class to
Backgrid.Grid:
// Override Column defaults globally
Column.prototype.defaults.sortable = false;
// Override Column defaults locally
var MyColumn = Column.extend({
defaults: _.defaults({
editable: false
}, Column.prototype.defaults)
});
var grid = new Backgrid.Grid(columns: new Columns([{...}, {...}], {
model: MyColumn
}));
@cfg {string} [defaults.name] The default name of the model attribute.
@cfg {string} [defaults.label] The default label to show in the header.
@cfg {string|Backgrid.Cell} [defaults.cell] The default cell type. If this
is a string, the capitalized form will be used to look up a cell class in
Backbone, i.e.: string => StringCell. If a Cell subclass is supplied, it is
initialized with a hash of parameters. If a Cell instance is supplied, it
is used directly.
@cfg {string|Backgrid.HeaderCell} [defaults.headerCell] The default header
cell type.
@cfg {boolean|string|function(): boolean} [defaults.sortable=true] Whether
this column is sortable. If the value is a string, a method will the same
name will be looked up from the column instance to determine whether the
column should be sortable. The method's signature must be `function
(Backgrid.Column, Backbone.Model): boolean`.
@cfg {boolean|string|function(): boolean} [defaults.editable=true] Whether
this column is editable. If the value is a string, a method will the same
name will be looked up from the column instance to determine whether the
column should be editable. The method's signature must be `function
(Backgrid.Column, Backbone.Model): boolean`.
@cfg {boolean|string|function(): boolean} [defaults.renderable=true]
Whether this column is renderable. If the value is a string, a method will
the same name will be looked up from the column instance to determine
whether the column should be renderable. The method's signature must be
`function (Backrid.Column, Backbone.Model): boolean`.
@cfg {Backgrid.CellFormatter | Object | string} [defaults.formatter] The
formatter to use to convert between raw model values and user input.
@cfg {"toggle"|"cycle"} [defaults.sortType="cycle"] Whether sorting will
toggle between ascending and descending order, or cycle between insertion
order, ascending and descending order.
@cfg {(function(Backbone.Model, string): *) | string} [defaults.sortValue]
The function to use to extract a value from the model for comparison during
sorting. If this value is a string, a method with the same name will be
looked up from the column instance.
@cfg {"ascending"|"descending"|null} [defaults.direction=null] The initial
sorting direction for this column. The default is ordered by
Backbone.Model.cid, which usually means the collection is ordered by
insertion order.
*/
defaults: {
name: undefined,
label: undefined,
sortable: true,
editable: true,
renderable: true,
formatter: undefined,
sortType: "cycle",
sortValue: undefined,
direction: null,
cell: undefined,
headerCell: undefined
},
/**
Initializes this Column instance.
@param {Object} attrs
@param {string} attrs.name The model attribute this column is responsible
for.
@param {string|Backgrid.Cell} attrs.cell The cell type to use to render
this column.
@param {string} [attrs.label]
@param {string|Backgrid.HeaderCell} [attrs.headerCell]
@param {boolean|string|function(): boolean} [attrs.sortable=true]
@param {boolean|string|function(): boolean} [attrs.editable=true]
@param {boolean|string|function(): boolean} [attrs.renderable=true]
@param {Backgrid.CellFormatter | Object | string} [attrs.formatter]
@param {"toggle"|"cycle"} [attrs.sortType="cycle"]
@param {(function(Backbone.Model, string): *) | string} [attrs.sortValue]
@throws {TypeError} If attrs.cell or attrs.options are not supplied.
@throws {ReferenceError} If formatter is a string but a formatter class of
said name cannot be found in the Backgrid module.
See:
- Backgrid.Column.defaults
- Backgrid.Cell
- Backgrid.CellFormatter
*/
initialize: function () {
if (!this.has("label")) {
this.set({ label: this.get("name") }, { silent: true });
}
var headerCell = Backgrid.resolveNameToClass(this.get("headerCell"), "HeaderCell");
var cell = Backgrid.resolveNameToClass(this.get("cell"), "Cell");
this.set({cell: cell, headerCell: headerCell}, { silent: true });
},
/**
Returns an appropriate value extraction function from a model for sorting.
If the column model contains an attribute `sortValue`, if it is a string, a
method from the column instance identifified by the `sortValue` string is
returned. If it is a function, it it returned as is. If `sortValue` isn't
found from the column model's attributes, a default value extraction
function is returned which will compare according to the natural order of
the value's type.
@return {function(Backbone.Model, string): *}
*/
sortValue: function () {
var sortValue = this.get("sortValue");
if (_.isString(sortValue)) return this[sortValue];
else if (_.isFunction(sortValue)) return sortValue;
return function (model, colName) {
return model.get(colName);
};
}
/**
@member Backgrid.Column
@protected
@method sortable
@return {function(Backgrid.Column, Backbone.Model): boolean | boolean}
*/
/**
@member Backgrid.Column
@protected
@method editable
@return {function(Backgrid.Column, Backbone.Model): boolean | boolean}
*/
/**
@member Backgrid.Column
@protected
@method renderable
@return {function(Backgrid.Column, Backbone.Model): boolean | boolean}
*/
});
_.each(["sortable", "renderable", "editable"], function (key) {
Column.prototype[key] = function () {
var value = this.get(key);
if (_.isString(value)) return this[value];
else if (_.isFunction(value)) return value;
return !!value;
};
});
/**
A Backbone collection of Column instances.
@class Backgrid.Columns
@extends Backbone.Collection
*/
var Columns = Backgrid.Columns = Backbone.Collection.extend({
/**
@property {Backgrid.Column} model
*/
model: Column
});
Mini Shell