/**
Adds support for paging through data in the DataTable.
@module datatable
@submodule datatable-paginator
@since 3.11.0
*/
var Model,
View,
PaginatorTemplates = Y.DataTable.Templates.Paginator,
sub = Y.Lang.sub,
getClassName = Y.ClassNameManager.getClassName,
CLASS_DISABLED = getClassName(NAME, 'control-disabled'),
EVENT_UI = 'paginator:ui';
/**
@class DataTable.Paginator.Model
@extends Model
@since 3.11.0
*/
Model = Y.Base.create('dt-pg-model', Y.Model, [Y.Paginator.Core]),
/**
@class DataTable.Paginator.View
@extends View
@since 3.11.0
*/
View = Y.Base.create('dt-pg-view', Y.View, [], {
/**
Array of event handles to keep track of what should be destroyed later
@protected
@property _eventHandles
@type {Array}
@since 3.11.0
*/
_eventHandles: [],
/**
Template for this view's container.
@property containerTemplate
@type {String}
@default '<div class="yui3-datatable-paginator"/>'
@since 3.11.0
*/
containerTemplate: '<div class="{paginator}"/>',
/**
Template for content. Helps maintain order of controls.
@property contentTemplate
@type {String}
@default '{buttons}{goto}{perPage}'
@since 3.11.0
*/
contentTemplate: '{buttons}{goto}{perPage}',
/**
Disables ad-hoc ATTRS for our view.
@protected
@property _allowAdHocAttrs
@type {Boolean}
@default false
@since 3.11.0
*/
_allowAdHocAttrs: false,
/**
Sets classnames on the templates and bind events
@method initializer
@since 3.11.0
*/
initializer: function () {
this.containerTemplate = sub(this.containerTemplate, {
paginator: getClassName(NAME)
});
this._initStrings();
this._initClassNames();
this.attachEvents();
},
/**
@method render
@chainable
@since 3.11.0
*/
render: function () {
var model = this.get('model'),
content = sub(this.contentTemplate, {
'buttons': this._buildButtonsGroup(),
'goto': this._buildGotoGroup(),
'perPage': this._buildPerPageGroup()
});
this.get('container').append(content);
this.attachEvents();
this._rendered = true;
this._updateControlsUI(model.get('page'));
this._updateItemsPerPageUI(model.get('itemsPerPage'));
return this;
},
/**
@method attachEvents
@since 3.11.0
*/
attachEvents: function () {
View.superclass.attachEvents.apply(this, arguments);
var container = this.get('container');
if (!this.classNames) {
this._initClassNames();
}
this._attachedViewEvents.push(
container.delegate('click', this._controlClick, '.' + this.classNames.control, this),
this.get('model').after('change', this._modelChange, this)
);
container.all('form').each(Y.bind(function (frm) {
this._attachedViewEvents.push(
frm.after('submit', this._controlSubmit, this)
);
}, this));
container.all('select').each(Y.bind(function (sel) {
this._attachedViewEvents.push(
sel.after('change', this._controlChange, this)
);
}, this));
},
/**
Returns a string built from the button and buttons templates.
@protected
@method _buildButtonsGroup
@return {String}
@since 3.11.0
*/
_buildButtonsGroup: function () {
var strings = this.get('strings'),
classNames = this.classNames,
buttons;
buttons = PaginatorTemplates.button({
type: 'first', label: strings.first, classNames: classNames
}) +
PaginatorTemplates.button({
type: 'prev', label: strings.prev, classNames: classNames
}) +
PaginatorTemplates.button({
type: 'next', label: strings.next, classNames: classNames
}) +
PaginatorTemplates.button({
type: 'last', label: strings.last, classNames: classNames
});
return PaginatorTemplates.buttons({
classNames: classNames,
buttons: buttons
});
},
/**
Returns a string built from the gotoPage template.
@protected
@method _buildGotoGroup
@return {String}
@since 3.11.0
*/
_buildGotoGroup: function () {
return PaginatorTemplates.gotoPage({
classNames: this.classNames,
strings: this.get('strings'),
page: this.get('model').get('page')
});
},
/**
Returns a string built from the perPage template
@protected
@method _buildPerPageGroup
@return {String}
@since 3.11.0
*/
_buildPerPageGroup: function () {
var options = this.get('pageSizes'),
rowsPerPage = this.get('model').get('rowsPerPage'),
option,
len,
i;
for (i = 0, len = options.length; i < len; i++ ) {
option = options[i];
if (typeof option !== 'object') {
option = {
value: option,
label: option
};
}
option.selected = (option.value === rowsPerPage) ? ' selected' : '';
}
return PaginatorTemplates.perPage({
classNames: this.classNames,
strings: this.get('strings'),
options: this.get('pageSizes')
});
},
/**
Update the UI after the model has changed.
@protected
@method _modelChange
@param {EventFacade} e
@since 3.11.0
*/
_modelChange: function (e) {
var changed = e.changed,
page = (changed && changed.page),
itemsPerPage = (changed && changed.itemsPerPage);
if (page) {
this._updateControlsUI(page.newVal);
}
if (itemsPerPage) {
this._updateItemsPerPageUI(itemsPerPage.newVal);
if (!page) {
this._updateControlsUI(e.target.get('page'));
}
}
},
/**
Updates the button controls and the gotoPage form
@protected
@method _updateControlsUI
@param {Number} val Page number to set the UI input to
@since 3.11.0
*/
_updateControlsUI: function (val) {
if (!this._rendered) {
return;
}
var model = this.get('model'),
controlClass = '.' + this.classNames.control,
container = this.get('container'),
hasPrev = model.hasPrevPage(),
hasNext = model.hasNextPage();
container.one(controlClass + '-first')
.toggleClass(CLASS_DISABLED, !hasPrev)
.set('disabled', !hasPrev);
container.one(controlClass + '-prev')
.toggleClass(CLASS_DISABLED, !hasPrev)
.set('disabled', !hasPrev);
container.one(controlClass + '-next')
.toggleClass(CLASS_DISABLED, !hasNext)
.set('disabled', !hasNext);
container.one(controlClass + '-last')
.toggleClass(CLASS_DISABLED, !hasNext)
.set('disabled', !hasNext);
container.one('form input').set('value', val);
},
/**
Updates the drop down select for items per page
@protected
@method _updateItemsPerPageUI
@param {Number} val Number of items to display per page
@since 3.11.0
*/
_updateItemsPerPageUI: function (val) {
if (!this._rendered) {
return;
}
this.get('container').one('select').set('value', val);
},
/**
Fire EVENT_UI when an enabled control button is clicked
@protected
@method _controlClick
@param {EventFacade} e
@since 3.11.0
*/
_controlClick: function (e) { // buttons
e.preventDefault();
var control = e.currentTarget;
// register click events from the four control buttons
if (control.hasClass(CLASS_DISABLED)) {
return;
}
this.fire(EVENT_UI, {
type: control.getData('type'),
val: control.getData('page') || null
});
},
/**
Fire EVENT_UI with `type:perPage` after the select drop down changes
@protected
@method _controlChange
@param {EventFacade} e
@since 3.11.0
*/
_controlChange: function (e) {
// register change events from the perPage select
if ( e.target.hasClass(CLASS_DISABLED) ) {
return;
}
val = e.target.get('value');
this.fire(EVENT_UI, { type: 'perPage', val: parseInt(val, 10) });
},
/**
Fire EVENT_UI with `type:page` after form is submitted
@protected
@method _controlSubmit
@param {EventFacade} e
@since 3.11.0
*/
_controlSubmit: function (e) {
if ( e.target.hasClass(CLASS_DISABLED) ) {
return;
}
// the only form we have is the go to page form
e.preventDefault();
input = e.target.one('input');
// Note: Convert input's value into a number.
this.fire(EVENT_UI, { type: 'page', val: +input.get('value') });
},
/**
Initializes classnames to be used with the templates
@protected
@method _initClassNames
@since 3.11.0
*/
_initClassNames: function () {
this.classNames = {
control: getClassName(NAME, 'control'),
controls: getClassName(NAME, 'controls'),
group: getClassName(NAME, 'group'),
perPage: getClassName(NAME, 'per-page')
};
},
/**
Initializes strings used for internationalization
@protected
@method _initStrings
@since 3.11.0
*/
_initStrings: function () {
// Not a valueFn because other class extensions may want to add to it
this.set('strings', Y.mix((this.get('strings') || {}),
Y.Intl.get('datatable-paginator')));
},
/**
Returns an Array with default values for the Rows Per Page select option.
We had to use a valueFn to enable language string replacement.
@protected
@method _defPageSizeVal
@since 3.13.0
*/
_defPageSizeVal: function () {
this._initStrings();
var str = this.get('strings');
return [10, 50, 100, { label: str.showAll, value: -1 }]
}
}, {
ATTRS: {
/**
Array of values used to populate the drop down for items per page
@attribute pageSizes
@type {Array}
@default [ 10, 50, 100, { label: 'Show All', value: -1 } ]
@since 3.11.0
*/
pageSizes: {
valueFn: '_defPageSizeVal'
},
/**
Model used for this view
@attribute model
@type {Model}
@default null
@since 3.11.0
*/
model: {}
}
});
/**
@class DataTable.Paginator
@since 3.11.0
*/
function Controller () {}
Controller.ATTRS = {
/**
A model instance or a configuration object for the Model.
@attribute paginatorModel
@type {Model|Object}
@default null
@since 3.11.0
*/
paginatorModel: {
setter: '_setPaginatorModel',
value: null,
writeOnce: 'initOnly'
},
/**
A pointer to a Model object to be instantiated, or a String off of the
`Y` namespace.
This is only used if the `paginatorModel` is a configuration object or
is null.
@attribute paginatorModelType
@type {Model|String}
@default 'DataTable.Paginator.Model'
@since 3.11.0
*/
paginatorModelType: {
getter: '_getConstructor',
value: 'DataTable.Paginator.Model',
writeOnce: 'initOnly'
},
/**
A pointer to a `Y.View` object to be instantiated. A new view will be
created for each location provided. Each view created will be given the
same model instance.
@attribute paginatorView
@type {View|String}
@default 'DataTable.Paginator.View'
@since 3.11.0
*/
paginatorView: {
getter: '_getConstructor',
value: 'DataTable.Paginator.View',
writeOnce: 'initOnly'
},
// PAGINATOR CONFIGS
/**
Array of values used to populate the values in the Paginator UI allowing
the end user to select the number of items to display per page.
@attribute pageSizes
@type {Array}
@default [10, 50, 100, { label: 'Show All', value: -1 }]
@since 3.11.0
*/
pageSizes: {
setter: '_setPageSizesFn',
valueFn: '_defPageSizeVal'
},
paginatorStrings: {},
/**
Number of rows to display per page. As the UI changes the number of pages
to display, this will update to reflect the value selected in the UI
@attribute rowsPerPage
@type {Number | null}
@default null
@since 3.11.0
*/
rowsPerPage: {
value: null
},
/**
String of `footer` or `header`, a Y.Node, or an Array or any combination
of those values.
@attribute paginatorLocation
@type {String|Array|Node}
@default footer
@since 3.11.0
*/
paginatorLocation: {
value: 'footer'
}
};
Y.mix(Controller.prototype, {
/**
Sets the `paginatorModel` to the first page.
@method firstPage
@chainable
@since 3.11.0
*/
firstPage: function () {
this.get('paginatorModel').set('page', 1);
return this;
},
/**
Sets the `paginatorModel` to the last page.
@method lastPage
@chainable
@since 3.11.0
*/
lastPage: function () {
var model = this.get('paginatorModel');
model.set('page', model.get('totalPages'));
return this;
},
/**
Sets the `paginatorModel` to the previous page.
@method previousPage
@chainable
@since 3.11.0
*/
previousPage: function () {
this.get('paginatorModel').prevPage();
return this;
},
/**
Sets the `paginatorModel` to the next page.
@method nextPage
@chainable
@since 3.11.0
*/
nextPage: function () {
this.get('paginatorModel').nextPage();
return this;
},
/// Init and protected
/**
Constructor logic
@protected
@method initializer
@since 3.11.0
*/
initializer: function () {
// allow DT to use paged data
this._initPaginatorStrings();
this._augmentData();
if (!this._eventHandles.paginatorRender) {
this._eventHandles.paginatorRender = Y.Do.after(this._paginatorRender, this, 'render');
}
},
/**
Renders the paginator into locations and attaches events.
@protected
@method _paginatorRender
@since 3.11.0
*/
_paginatorRender: function () {
var model = this.get('paginatorModel');
this._paginatorRenderUI();
model.after('change', this._afterPaginatorModelChange, this);
this.after('dataChange', this._afterDataChangeWithPaginator, this);
this.after('rowsPerPageChange', this._afterRowsPerPageChange, this);
this.data.after(['add', 'remove', 'change'], this._afterDataUpdatesWithPaginator, this);
// ensure our model has the correct totalItems set
model.set('itemsPerPage', this.get('rowsPerPage'));
model.set('totalItems', this.get('data').size());
},
/**
After the data changes, we ensure we are on the first page and the data
is augmented
@protected
@method _afterDataChangeWithPaginator
@since 3.11.0
*/
_afterDataChangeWithPaginator: function () {
var data = this.get('data'),
model = this.get('paginatorModel');
model.set('totalItems', data.size());
if (model.get('page') !== 1) {
this.firstPage();
} else {
this._augmentData();
data.fire.call(data, 'reset', {
src: 'reset',
models: data._items.concat()
});
}
},
/**
After data has changed due to a model being added, removed, or changed,
update paginator model totalItems to reflect the changes.
@protected
@method _afterDataUpdatesWithPaginator
@param {EventFacade} e
@since 3.13.0
*/
_afterDataUpdatesWithPaginator: function () {
var model = this.get('paginatorModel'),
data = this.get('data');
model.set('totalItems', data.size());
},
/**
After the rowsPerPage changes, update the UI to reflect the new number of
rows to be displayed. If the new value is `null`, destroy all instances
of the paginators.
@protected
@method _afterRowsPerPageChange
@param {EventFacade} e
@since 3.11.0
*/
_afterRowsPerPageChange: function (e) {
var data = this.get('data'),
model = this.get('paginatorModel'),
view;
if (e.newVal !== null) {
// turning on
this._paginatorRenderUI();
if (!(data._paged)) {
this._augmentData();
}
data._paged.index = (model.get('page') - 1) * model.get('itemsPerPage');
data._paged.length = model.get('itemsPerPage');
} else { // e.newVal === null
// destroy!
while(this._pgViews.length) {
view = this._pgViews.shift();
view.destroy({ remove: true });
view._rendered = null;
}
data._paged.index = 0;
data._paged.length = null;
}
this.get('paginatorModel').set('itemsPerPage', parseInt(e.newVal, 10));
},
/**
Parse each location and render a new view into each area.
@protected
@method _paginatorRenderUI
@since 3.11.0
*/
_paginatorRenderUI: function () {
if (!this.get('rowsPerPage')) {
return;
}
var views = this._pgViews,
ViewClass = this.get('paginatorView'),
viewConfig = {
pageSizes: this.get('pageSizes'),
model: this.get('paginatorModel')
},
locations = this.get('paginatorLocation');
if (!Y.Lang.isArray(locations)) {
locations = [locations];
}
if (!views) { // set up initial rendering of views
views = this._pgViews = [];
}
// for each placement area, push to views
Y.Array.each(locations, function (location) {
var view = new ViewClass(viewConfig),
container = view.render().get('container'),
row;
view.after('*:ui', this._uiPgHandler, this);
views.push(view);
if (location._node) { // assume Y.Node
location.append(container);
// remove this container row if the view is ever destroyed
this.after('destroy', function (/* e */) {
view.destroy({ remove: true });
});
} else if (location === 'footer') { // DT Footer
// Render a table footer if there isn't one
if (!this.foot) {
this.foot = new Y.DataTable.FooterView({ host: this });
this.foot.render();
this.fire('renderFooter', { view: this.foot });
}
// create a row for the paginator to sit in
row = Y.Node.create(PaginatorTemplates.rowWrapper({
wrapperClass: getClassName(NAME, 'wrapper'),
numOfCols: this.get('columns').length
}));
row.one('td').append(container);
this.foot.tfootNode.append(row);
// remove this container row if the view is ever destroyed
view.after('destroy', function (/* e */) {
row.remove(true);
});
} else if (location === 'header') {
// 'header' means insert before the table
// placement with the caption may need to be addressed
if (this.view && this.view.tableNode) {
this.view.tableNode.insert(container, 'before');
} else {
this.get('contentBox').prepend(container);
}
}
}, this);
},
/**
Handles the paginator's UI event into a single location. Updates the
`paginatorModel` according to what type is provided.
@protected
@method _uiPgHandler
@param {EventFacade} e
@since 3.11.0
*/
_uiPgHandler: function (e) {
// e.type = control type (first|prev|next|last|page|perPage)
// e.val = value based on the control type to pass to the model
var model = this.get('paginatorModel');
switch (e.type) {
case 'first':
model.set('page', 1);
break;
case 'last':
model.set('page', model.get('totalPages'));
break;
case 'prev':
case 'next': // overflow intentional
model[e.type + 'Page']();
break;
case 'page':
model.set('page', e.val);
break;
case 'perPage':
model.set('itemsPerPage', e.val);
model.set('page', 1);
break;
}
},
/**
Augments the model list with a paged structure, or updates the paged
data. Then fires reset on the model list.
@protected
@method _afterPaginatorModelChange
@param {EventFacade} [e]
@since 3.11.0
*/
_afterPaginatorModelChange: function () {
var model = this.get('paginatorModel'),
data = this.get('data');
if (!data._paged) {
this._augmentData();
} else {
data._paged.index = (model.get('page') - 1) * model.get('itemsPerPage');
data._paged.length = model.get('itemsPerPage');
}
data.fire.call(data, 'reset', {
src: 'reset',
models: data._items.concat()
});
},
/**
Augments the model list data structure with paged implementations.
The model list will contain a method for `getPage` that will return the
given number of items listed within the range.
`each` will also loop over the items in the page
@protected
@method _augmentData
@since 3.11.0
*/
_augmentData: function () {
var model = this.get('paginatorModel');
if (this.get('rowsPerPage') === null) {
return;
}
Y.mix(this.get('data'), {
_paged: {
index: (model.get('page') - 1) * model.get('itemsPerPage'),
length: model.get('itemsPerPage')
},
getPage: function () {
var _pg = this._paged,
min = _pg.index;
// IE LTE 8 doesn't allow "undefined" as a second param - gh890
return (_pg.length >= 0) ?
this._items.slice(min, min + _pg.length) :
this._items.slice(min);
},
size: function (paged) {
return (paged && this._paged.length >=0 ) ?
this._paged.length :
this._items.length;
},
each: function () {
var args = Array.prototype.slice.call(arguments);
args.unshift(this.getPage());
Y.Array.each.apply(null, args);
return this;
}
}, true);
},
/**
Ensures `pageSizes` value is an array of objects to be used in the
paginator view.
@protected
@method _setPageSizesFn
@param {Array} val
@return Array
@since 3.11.0
*/
_setPageSizesFn: function (val) {
var i,
len = val.length,
label,
value;
if (!Y.Lang.isArray(val)) {
val = [val];
len = val.length;
}
for ( i = 0; i < len; i++ ) {
if (typeof val[i] !== 'object') {
label = val[i];
value = val[i];
// We want to check to see if we have a number or a string
// of a number. If we do not, we want the value to be -1 to
// indicate "all rows"
/*jshint eqeqeq:false */
if (parseInt(value, 10) != value) {
value = -1;
}
/*jshint eqeqeq:true */
val[i] = { label: label, value: value };
}
}
return val;
},
/**
Ensures the object provided is an instance of a `Y.Model`. If it is not,
it assumes it is the configuration of a model, and gets the new model
type from `paginatorModelType`.
@protected
@method _setPaginatorModel
@param {Model|Object} model
@return Y.Model instance
@since 3.11.0
*/
_setPaginatorModel: function (model) {
if (!(model && model._isYUIModel)) {
var ModelConstructor = this.get('paginatorModelType');
model = new ModelConstructor(model);
}
return model;
},
/**
Returns a pointer to an object to be instantiated if the provided type is
a string
@protected
@method _getConstructor
@param {Object | String} type Type of Object to contruct. If `type` is a
String, we assume it is a namespace off the Y object
@return
@since 3.11.0
*/
_getConstructor: function (type) {
return typeof type === 'string' ?
Y.Object.getValue(Y, type.split('.')) :
type;
},
/**
Initializes paginatorStrings used for internationalization
@protected
@method _initPaginatorStrings
@since 3.13.0
*/
_initPaginatorStrings: function () {
// Not a valueFn because other class extensions may want to add to it
this.set('paginatorStrings', Y.mix((this.get('paginatorStrings') || {}),
Y.Intl.get('datatable-paginator')));
},
/**
Returns an Array with default values for the Rows Per Page select option.
We had to use a valueFn to enable language string replacement.
@protected
@method _defPageSizeVal
@since 3.13.0
*/
_defPageSizeVal: function () {
this._initPaginatorStrings();
var str = this.get('paginatorStrings');
return [10, 50, 100, { label: str.showAll, value: -1 }]
}
}, true);
Y.DataTable.Paginator = Controller;
Y.DataTable.Paginator.Model = Model;
Y.DataTable.Paginator.View = View;
Y.Base.mix(Y.DataTable, [Y.DataTable.Paginator]);
