jquery-datatables 1.10.18 → 1.10.20

data/app/assets/javascripts/datatables/plugins/pagination/scrolling.js

@@ -0,0 +1,130 @@
+/**
+ * This modification of DataTables' standard two button pagination controls
+ * adds a little animation effect to the paging action by redrawing the table
+ * multiple times for each event, each draw progressing by one row until the
+ * required point in the table is reached.
+ *
+ *  @name Scrolling navigation
+ *  @summary Show page changes as a redraw of the table, scrolling records.
+ *  @author [Allan Jardine](http://sprymedia.co.uk)
+ *
+ *  @example
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "sPaginationType": "scrolling"
+ *        } );
+ *    } );
+ */
+
+
+/* Time between each scrolling frame */
+$.fn.dataTableExt.oPagination.iTweenTime = 100;
+
+$.fn.dataTableExt.oPagination.scrolling = {
+	"fnInit": function ( oSettings, nPaging, fnCallbackDraw )
+	{
+		var oLang = oSettings.oLanguage.oPaginate;
+		var oClasses = oSettings.oClasses;
+		var fnClickHandler = function ( e ) {
+			if ( oSettings.oApi._fnPageChange( oSettings, e.data.action ) )
+			{
+				fnCallbackDraw( oSettings );
+			}
+		};
+
+		var sAppend = (!oSettings.bJUI) ?
+			'<a class="'+oSettings.oClasses.sPagePrevDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button">'+oLang.sPrevious+'</a>'+
+			'<a class="'+oSettings.oClasses.sPageNextDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button">'+oLang.sNext+'</a>'
+			:
+			'<a class="'+oSettings.oClasses.sPagePrevDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button"><span class="'+oSettings.oClasses.sPageJUIPrev+'"></span></a>'+
+			'<a class="'+oSettings.oClasses.sPageNextDisabled+'" tabindex="'+oSettings.iTabIndex+'" role="button"><span class="'+oSettings.oClasses.sPageJUINext+'"></span></a>';
+		$(nPaging).append( sAppend );
+
+		var els = $('a', nPaging);
+		var nPrevious = els[0],
+			nNext = els[1];
+
+		oSettings.oApi._fnBindAction( nPrevious, {action: "previous"}, function() {
+			/* Disallow paging event during a current paging event */
+			if ( typeof oSettings.iPagingLoopStart != 'undefined' && oSettings.iPagingLoopStart != -1 )
+			{
+				return;
+			}
+
+			oSettings.iPagingLoopStart = oSettings._iDisplayStart;
+			oSettings.iPagingEnd = oSettings._iDisplayStart - oSettings._iDisplayLength;
+
+			/* Correct for underrun */
+			if ( oSettings.iPagingEnd < 0 )
+			{
+				oSettings.iPagingEnd = 0;
+			}
+
+			var iTween = $.fn.dataTableExt.oPagination.iTweenTime;
+			var innerLoop = function () {
+				if ( oSettings.iPagingLoopStart > oSettings.iPagingEnd ) {
+					oSettings.iPagingLoopStart--;
+					oSettings._iDisplayStart = oSettings.iPagingLoopStart;
+					fnCallbackDraw( oSettings );
+					setTimeout( function() { innerLoop(); }, iTween );
+				} else {
+					oSettings.iPagingLoopStart = -1;
+				}
+			};
+			innerLoop();
+		} );
+
+		oSettings.oApi._fnBindAction( nNext, {action: "next"}, function() {
+			/* Disallow paging event during a current paging event */
+			if ( typeof oSettings.iPagingLoopStart != 'undefined' && oSettings.iPagingLoopStart != -1 )
+			{
+				return;
+			}
+
+			oSettings.iPagingLoopStart = oSettings._iDisplayStart;
+
+			/* Make sure we are not over running the display array */
+			if ( oSettings._iDisplayStart + oSettings._iDisplayLength < oSettings.fnRecordsDisplay() )
+			{
+				oSettings.iPagingEnd = oSettings._iDisplayStart + oSettings._iDisplayLength;
+			}
+
+			var iTween = $.fn.dataTableExt.oPagination.iTweenTime;
+			var innerLoop = function () {
+				if ( oSettings.iPagingLoopStart < oSettings.iPagingEnd ) {
+					oSettings.iPagingLoopStart++;
+					oSettings._iDisplayStart = oSettings.iPagingLoopStart;
+					fnCallbackDraw( oSettings );
+					setTimeout( function() { innerLoop(); }, iTween );
+				} else {
+					oSettings.iPagingLoopStart = -1;
+				}
+			};
+			innerLoop();
+		} );
+	},
+
+	"fnUpdate": function ( oSettings, fnCallbackDraw )
+	{
+		if ( !oSettings.aanFeatures.p )
+		{
+			return;
+		}
+
+		/* Loop over each instance of the pager */
+		var an = oSettings.aanFeatures.p;
+		for ( var i=0, iLen=an.length ; i<iLen ; i++ )
+		{
+			if ( an[i].childNodes.length !== 0 )
+			{
+				an[i].childNodes[0].className =
+					( oSettings._iDisplayStart === 0 ) ?
+					oSettings.oClasses.sPagePrevDisabled : oSettings.oClasses.sPagePrevEnabled;
+
+				an[i].childNodes[1].className =
+					( oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay() ) ?
+					oSettings.oClasses.sPageNextDisabled : oSettings.oClasses.sPageNextEnabled;
+			}
+		}
+	}
+};

data/app/assets/javascripts/datatables/plugins/pagination/select.js

@@ -0,0 +1,97 @@
+/**
+ * This pagination plug-in provides a `dt-tag select` menu with the list of the page
+ * numbers that are available for viewing.
+ *
+ *  @name Select list
+ *  @summary Show a `dt-tag select` list of pages the user can pick from.
+ *  @author _jneilliii_
+ *
+ *  @example
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "sPaginationType": "listbox"
+ *        } );
+ *    } );
+ */
+
+$.fn.dataTableExt.oPagination.listbox = {
+	/*
+	 * Function: oPagination.listbox.fnInit
+	 * Purpose:  Initalise dom elements required for pagination with listbox input
+	 * Returns:  -
+	 * Inputs:   object:oSettings - dataTables settings object
+	 *             node:nPaging - the DIV which contains this pagination control
+	 *             function:fnCallbackDraw - draw function which must be called on update
+	 */
+	"fnInit": function (oSettings, nPaging, fnCallbackDraw) {
+		var nInput = document.createElement('select');
+		var nPage = document.createElement('span');
+		var nOf = document.createElement('span');
+		nOf.className = "paginate_of";
+		nPage.className = "paginate_page";
+		if (oSettings.sTableId !== '') {
+			nPaging.setAttribute('id', oSettings.sTableId + '_paginate');
+		}
+		nInput.style.display = "inline";
+		nPage.innerHTML = "Page ";
+		nPaging.appendChild(nPage);
+		nPaging.appendChild(nInput);
+		nPaging.appendChild(nOf);
+		$(nInput).change(function (e) { // Set DataTables page property and redraw the grid on listbox change event.
+			window.scroll(0,0); //scroll to top of page
+			if (this.value === "" || this.value.match(/[^0-9]/)) { /* Nothing entered or non-numeric character */
+				return;
+			}
+			var iNewStart = oSettings._iDisplayLength * (this.value - 1);
+			if (iNewStart > oSettings.fnRecordsDisplay()) { /* Display overrun */
+				oSettings._iDisplayStart = (Math.ceil((oSettings.fnRecordsDisplay() - 1) / oSettings._iDisplayLength) - 1) * oSettings._iDisplayLength;
+				fnCallbackDraw(oSettings);
+				return;
+			}
+			oSettings._iDisplayStart = iNewStart;
+			fnCallbackDraw(oSettings);
+		}); /* Take the brutal approach to cancelling text selection */
+		$('span', nPaging).bind('mousedown', function () {
+			return false;
+		});
+		$('span', nPaging).bind('selectstart', function () {
+			return false;
+		});
+	},
+	 
+	/*
+	 * Function: oPagination.listbox.fnUpdate
+	 * Purpose:  Update the listbox element
+	 * Returns:  -
+	 * Inputs:   object:oSettings - dataTables settings object
+	 *             function:fnCallbackDraw - draw function which must be called on update
+	 */
+	"fnUpdate": function (oSettings, fnCallbackDraw) {
+		if (!oSettings.aanFeatures.p) {
+			return;
+		}
+		var iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength);
+		var iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1; /* Loop over each instance of the pager */
+		var an = oSettings.aanFeatures.p;
+		for (var i = 0, iLen = an.length; i < iLen; i++) {
+			var spans = an[i].getElementsByTagName('span');
+			var inputs = an[i].getElementsByTagName('select');
+			var elSel = inputs[0];
+			if(elSel.options.length != iPages) {
+				elSel.options.length = 0; //clear the listbox contents
+				for (var j = 0; j < iPages; j++) { //add the pages
+					var oOption = document.createElement('option');
+					oOption.text = j + 1;
+					oOption.value = j + 1;
+					try {
+						elSel.add(oOption, null); // standards compliant; doesn't work in IE
+					} catch (ex) {
+						elSel.add(oOption); // IE only
+					}
+				}
+				spans[1].innerHTML = "&nbsp;of&nbsp;" + iPages;
+			}
+		  elSel.value = iCurrentPage;
+		}
+	}
+};

data/app/assets/javascripts/datatables/plugins/pagination/simple_incremental_bootstrap.js

@@ -0,0 +1,154 @@
+/**
+ * This pagination style shows Previous/Next buttons, and page numbers only
+ * for "known" pages that are visited at least once time using [Next>] button.
+ * Initially only Prev/Next buttons are shown (Prev is initially disabled).
+ * 
+ * [<Previous] [Next>]
+ * 
+ * When user navigates through the pages using [Next>] button, navigation shows
+ * the numbers for the previous pages. As an example, when user reaches page 2,
+ * page numbers 1 and 2 are shown:
+ * 
+ * [<Previous] 1 2 [Next>]
+ * 
+ * When user reaches page 4, page numbers 1, 2, 3, and 4 are shown:
+ * 
+ * [<Previous] 1 2 3 4 [Next>]
+ * 
+ * When user navigates back, pagination will remember the last page number
+ * he reached and the numbesr up to the last known page are shown. As an example,
+ * when user returns to the page 2, page numbers 1, 2, 3, and 4 are still shown:
+ * 
+ * [<Previous] 1 2 3 4 [Next>]
+ * 
+ * This pagination style is designed for users who will not directly jump to
+ * the random page that they have not opened before. Assumption is that users
+ * will discover new pages using [Next>] button. This pagination enables users
+ * to easily go back and forth to any page that they discovered.
+ * 
+ * Key benefit: This pagination supports usual pagination pattern and does not
+ * require server to return total count of items just to calculate last page and
+ * all numbers. This migh be huge performance benefit because server does not
+ * need to execute two queries in server-side processing mode:
+ * - One to get the records that will be shown on the current page,
+ * - Second to get the total count just to calculate full pagination.
+ * 
+ * Without second query, page load time might be 2x faster, especially in cases
+ * when server can quickly get top 100 records, but it would need to scan entire
+ * database table just to calculate the total count and position of the last
+ * page. This pagination style is reasonable trade-off between simple and fullnumbers 
+ * pagination.
+ * 
+ *  @name Simple Incremental navigation (Bootstrap)
+ *  @summary Shows forward/back buttons and all known page numbers.
+ *  @author [Jovan Popovic](http://github.com/JocaPC)
+ *
+ *  @example
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "pagingType": "simple_incremental_bootstrap"
+ *        } );
+ *    } );
+ */
+
+$.fn.dataTableExt.oPagination.simple_incremental_bootstrap = {
+
+    "fnInit": function (oSettings, nPaging, fnCallbackDraw) {
+        $(nPaging).prepend($("<ul class=\"pagination\"></ul>"));
+        var ul = $("ul", $(nPaging));
+        nFirst = document.createElement('li');
+        nPrevious = document.createElement('li');
+        nNext = document.createElement('li');
+
+        $(nPrevious).append($('<span>' + (oSettings.oLanguage.oPaginate.sPrevious) + '</span>'));
+        $(nFirst).append($('<span>1</span>'));
+        $(nNext).append($('<span>' + (oSettings.oLanguage.oPaginate.sNext) + '</span>'));
+        
+        nFirst.className = "paginate_button first active";
+        nPrevious.className = "paginate_button previous";
+        nNext.className = "paginate_button next";
+        
+        ul.append(nPrevious);
+        ul.append(nFirst);
+        ul.append(nNext);
+
+        $(nFirst).click(function () {
+            oSettings.oApi._fnPageChange(oSettings, "first");
+            fnCallbackDraw(oSettings);
+        });
+
+        $(nPrevious).click(function () {
+            if (!(oSettings._iDisplayStart === 0)) {
+                oSettings.oApi._fnPageChange(oSettings, "previous");
+                fnCallbackDraw(oSettings);
+            }
+        });
+
+        $(nNext).click(function () {
+            if (!(oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay()
+                ||
+                oSettings.aiDisplay.length < oSettings._iDisplayLength)) {
+                oSettings.oApi._fnPageChange(oSettings, "next");
+                fnCallbackDraw(oSettings);
+            }
+        });
+
+        /* Disallow text selection */
+        $(nFirst).bind('selectstart', function () { return false; });
+        $(nPrevious).bind('selectstart', function () { return false; });
+        $(nNext).bind('selectstart', function () { return false; });
+
+        // Reset dynamically generated pages on length/filter change.
+        $(oSettings.nTable).DataTable().on('length.dt', function (e, settings, len) {
+            $("li.dynamic_page_item", nPaging).remove();
+        });
+
+        $(oSettings.nTable).DataTable().on('search.dt', function (e, settings, len) {
+            $("li.dynamic_page_item", nPaging).remove();
+        });
+    },
+
+    /*
+     * Function: oPagination.simple_incremental_bootstrap.fnUpdate
+     * Purpose:  Update the list of page buttons shows
+     * Inputs:   object:oSettings - dataTables settings object
+     *           function:fnCallbackDraw - draw function which must be called on update
+     */
+    "fnUpdate": function (oSettings, fnCallbackDraw) {
+        if (!oSettings.aanFeatures.p) {
+            return;
+        }
+
+        /* Loop over each instance of the pager */
+        var an = oSettings.aanFeatures.p;
+        for (var i = 0, iLen = an.length ; i < iLen ; i++) {
+            var buttons = an[i].getElementsByTagName('li');
+            $(buttons).removeClass("active");
+            
+            if (oSettings._iDisplayStart === 0) {
+                buttons[0].className = "paginate_buttons disabled previous";
+                buttons[buttons.length - 1].className = "paginate_button enabled next";
+            } else {
+                buttons[0].className = "paginate_buttons enabled previous";
+            }
+            
+            var page = Math.round(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
+            if (page == buttons.length-1 && oSettings.aiDisplay.length > 0) {
+                $new = $('<li class="dynamic_page_item active"><span>' + page + "</span></li>");
+                $(buttons[buttons.length - 1]).before($new);
+                $new.click(function () {
+                    $(oSettings.nTable).DataTable().page(page-1);
+                    
+                    fnCallbackDraw(oSettings);
+                });
+            } else
+                $(buttons[page]).addClass("active");
+            
+            if (oSettings.fnDisplayEnd() == oSettings.fnRecordsDisplay()
+                ||
+                oSettings.aiDisplay.length < oSettings._iDisplayLength) {
+                buttons[buttons.length - 1].className = "paginate_button disabled next";
+            }
+        }
+    }
+};

data/app/assets/javascripts/datatables/plugins/pagination/simple_numbers_no_ellipses.js

@@ -0,0 +1,59 @@
+/**
+ *  Plug-in offers the same functionality as `simple_numbers` pagination type 
+ *  (see `pagingType` option) but without ellipses.
+ *
+ *  See [example](http://www.gyrocode.com/articles/jquery-datatables-pagination-without-ellipses) for demonstration.
+ *
+ *  @name Simple Numbers - No Ellipses
+ *  @summary Same pagination as 'simple_numbers' but without ellipses
+ *  @author [Michael Ryvkin](http://www.gyrocode.com)
+ *
+ *  @example
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "pagingType": "simple_numbers_no_ellipses"
+ *        } );
+ *    } );
+ */
+
+$.fn.DataTable.ext.pager.simple_numbers_no_ellipses = function(page, pages){
+   var numbers = [];
+   var buttons = $.fn.DataTable.ext.pager.numbers_length;
+   var half = Math.floor( buttons / 2 );
+
+   var _range = function ( len, start ){
+      var end;
+   
+      if ( typeof start === "undefined" ){ 
+         start = 0;
+         end = len;
+
+      } else {
+         end = start;
+         start = len;
+      }
+
+      var out = []; 
+      for ( var i = start ; i < end; i++ ){ out.push(i); }
+   
+      return out;
+   };
+    
+
+   if ( pages <= buttons ) {
+      numbers = _range( 0, pages );
+
+   } else if ( page <= half ) {
+      numbers = _range( 0, buttons);
+
+   } else if ( page >= pages - 1 - half ) {
+      numbers = _range( pages - buttons, pages );
+
+   } else {
+      numbers = _range( page - half, page + half + 1);
+   }
+
+   numbers.DT_el = 'span';
+
+   return [ 'previous', numbers, 'next' ];
+};