|
1
|
/**
|
|
2
|
* Change the order of the table
|
|
3
|
* @param {object} oSettings dataTables settings object
|
|
4
|
* @param {bool} bApplyClasses optional - should we apply classes or not
|
|
5
|
* @memberof DataTable#oApi
|
|
6
|
*/
|
|
7
|
function _fnSort ( oSettings, bApplyClasses )
|
|
8
|
{
|
|
9
|
var
|
|
10
|
i, iLen, j, jLen, k, kLen,
|
|
11
|
sDataType, nTh,
|
|
12
|
aaSort = [],
|
|
13
|
aiOrig = [],
|
|
14
|
oSort = DataTable.ext.oSort,
|
|
15
|
aoData = oSettings.aoData,
|
|
16
|
aoColumns = oSettings.aoColumns,
|
|
17
|
oAria = oSettings.oLanguage.oAria;
|
|
18
|
|
|
19
|
/* No sorting required if server-side or no sorting array */
|
|
20
|
if ( !oSettings.oFeatures.bServerSide &&
|
|
21
|
(oSettings.aaSorting.length !== 0 || oSettings.aaSortingFixed !== null) )
|
|
22
|
{
|
|
23
|
aaSort = ( oSettings.aaSortingFixed !== null ) ?
|
|
24
|
oSettings.aaSortingFixed.concat( oSettings.aaSorting ) :
|
|
25
|
oSettings.aaSorting.slice();
|
|
26
|
|
|
27
|
/* If there is a sorting data type, and a function belonging to it, then we need to
|
|
28
|
* get the data from the developer's function and apply it for this column
|
|
29
|
*/
|
|
30
|
for ( i=0 ; i<aaSort.length ; i++ )
|
|
31
|
{
|
|
32
|
var iColumn = aaSort[i][0];
|
|
33
|
var iVisColumn = _fnColumnIndexToVisible( oSettings, iColumn );
|
|
34
|
sDataType = oSettings.aoColumns[ iColumn ].sSortDataType;
|
|
35
|
if ( DataTable.ext.afnSortData[sDataType] )
|
|
36
|
{
|
|
37
|
var aData = DataTable.ext.afnSortData[sDataType].call(
|
|
38
|
oSettings.oInstance, oSettings, iColumn, iVisColumn
|
|
39
|
);
|
|
40
|
if ( aData.length === aoData.length )
|
|
41
|
{
|
|
42
|
for ( j=0, jLen=aoData.length ; j<jLen ; j++ )
|
|
43
|
{
|
|
44
|
_fnSetCellData( oSettings, j, iColumn, aData[j] );
|
|
45
|
}
|
|
46
|
}
|
|
47
|
else
|
|
48
|
{
|
|
49
|
_fnLog( oSettings, 0, "Returned data sort array (col "+iColumn+") is the wrong length" );
|
|
50
|
}
|
|
51
|
}
|
|
52
|
}
|
|
53
|
|
|
54
|
/* Create a value - key array of the current row positions such that we can use their
|
|
55
|
* current position during the sort, if values match, in order to perform stable sorting
|
|
56
|
*/
|
|
57
|
for ( i=0, iLen=oSettings.aiDisplayMaster.length ; i<iLen ; i++ )
|
|
58
|
{
|
|
59
|
aiOrig[ oSettings.aiDisplayMaster[i] ] = i;
|
|
60
|
}
|
|
61
|
|
|
62
|
/* Build an internal data array which is specific to the sort, so we can get and prep
|
|
63
|
* the data to be sorted only once, rather than needing to do it every time the sorting
|
|
64
|
* function runs. This make the sorting function a very simple comparison
|
|
65
|
*/
|
|
66
|
var iSortLen = aaSort.length;
|
|
67
|
var fnSortFormat, aDataSort;
|
|
68
|
for ( i=0, iLen=aoData.length ; i<iLen ; i++ )
|
|
69
|
{
|
|
70
|
for ( j=0 ; j<iSortLen ; j++ )
|
|
71
|
{
|
|
72
|
aDataSort = aoColumns[ aaSort[j][0] ].aDataSort;
|
|
73
|
|
|
74
|
for ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )
|
|
75
|
{
|
|
76
|
sDataType = aoColumns[ aDataSort[k] ].sType;
|
|
77
|
fnSortFormat = oSort[ (sDataType ? sDataType : 'string')+"-pre" ];
|
|
78
|
|
|
79
|
aoData[i]._aSortData[ aDataSort[k] ] = fnSortFormat ?
|
|
80
|
fnSortFormat( _fnGetCellData( oSettings, i, aDataSort[k], 'sort' ) ) :
|
|
81
|
_fnGetCellData( oSettings, i, aDataSort[k], 'sort' );
|
|
82
|
}
|
|
83
|
}
|
|
84
|
}
|
|
85
|
|
|
86
|
/* Do the sort - here we want multi-column sorting based on a given data source (column)
|
|
87
|
* and sorting function (from oSort) in a certain direction. It's reasonably complex to
|
|
88
|
* follow on it's own, but this is what we want (example two column sorting):
|
|
89
|
* fnLocalSorting = function(a,b){
|
|
90
|
* var iTest;
|
|
91
|
* iTest = oSort['string-asc']('data11', 'data12');
|
|
92
|
* if (iTest !== 0)
|
|
93
|
* return iTest;
|
|
94
|
* iTest = oSort['numeric-desc']('data21', 'data22');
|
|
95
|
* if (iTest !== 0)
|
|
96
|
* return iTest;
|
|
97
|
* return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
|
|
98
|
* }
|
|
99
|
* Basically we have a test for each sorting column, if the data in that column is equal,
|
|
100
|
* test the next column. If all columns match, then we use a numeric sort on the row
|
|
101
|
* positions in the original data array to provide a stable sort.
|
|
102
|
*/
|
|
103
|
oSettings.aiDisplayMaster.sort( function ( a, b ) {
|
|
104
|
var k, l, lLen, iTest, aDataSort, sDataType;
|
|
105
|
for ( k=0 ; k<iSortLen ; k++ )
|
|
106
|
{
|
|
107
|
aDataSort = aoColumns[ aaSort[k][0] ].aDataSort;
|
|
108
|
|
|
109
|
for ( l=0, lLen=aDataSort.length ; l<lLen ; l++ )
|
|
110
|
{
|
|
111
|
sDataType = aoColumns[ aDataSort[l] ].sType;
|
|
112
|
|
|
113
|
iTest = oSort[ (sDataType ? sDataType : 'string')+"-"+aaSort[k][1] ](
|
|
114
|
aoData[a]._aSortData[ aDataSort[l] ],
|
|
115
|
aoData[b]._aSortData[ aDataSort[l] ]
|
|
116
|
);
|
|
117
|
|
|
118
|
if ( iTest !== 0 )
|
|
119
|
{
|
|
120
|
return iTest;
|
|
121
|
}
|
|
122
|
}
|
|
123
|
}
|
|
124
|
|
|
125
|
return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
|
|
126
|
} );
|
|
127
|
}
|
|
128
|
|
|
129
|
/* Alter the sorting classes to take account of the changes */
|
|
130
|
if ( (bApplyClasses === undefined || bApplyClasses) && !oSettings.oFeatures.bDeferRender )
|
|
131
|
{
|
|
132
|
_fnSortingClasses( oSettings );
|
|
133
|
}
|
|
134
|
|
|
135
|
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
|
|
136
|
{
|
|
137
|
var sTitle = aoColumns[i].sTitle.replace( /<.*?>/g, "" );
|
|
138
|
nTh = aoColumns[i].nTh;
|
|
139
|
nTh.removeAttribute('aria-sort');
|
|
140
|
nTh.removeAttribute('aria-label');
|
|
141
|
|
|
142
|
/* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */
|
|
143
|
if ( aoColumns[i].bSortable )
|
|
144
|
{
|
|
145
|
if ( aaSort.length > 0 && aaSort[0][0] == i )
|
|
146
|
{
|
|
147
|
nTh.setAttribute('aria-sort', aaSort[0][1]=="asc" ? "ascending" : "descending" );
|
|
148
|
|
|
149
|
var nextSort = (aoColumns[i].asSorting[ aaSort[0][2]+1 ]) ?
|
|
150
|
aoColumns[i].asSorting[ aaSort[0][2]+1 ] : aoColumns[i].asSorting[0];
|
|
151
|
nTh.setAttribute('aria-label', sTitle+
|
|
152
|
(nextSort=="asc" ? oAria.sSortAscending : oAria.sSortDescending) );
|
|
153
|
}
|
|
154
|
else
|
|
155
|
{
|
|
156
|
nTh.setAttribute('aria-label', sTitle+
|
|
157
|
(aoColumns[i].asSorting[0]=="asc" ? oAria.sSortAscending : oAria.sSortDescending) );
|
|
158
|
}
|
|
159
|
}
|
|
160
|
else
|
|
161
|
{
|
|
162
|
nTh.setAttribute('aria-label', sTitle);
|
|
163
|
}
|
|
164
|
}
|
|
165
|
|
|
166
|
/* Tell the draw function that we have sorted the data */
|
|
167
|
oSettings.bSorted = true;
|
|
168
|
$(oSettings.oInstance).trigger('sort', oSettings);
|
|
169
|
|
|
170
|
/* Copy the master data into the draw array and re-draw */
|
|
171
|
if ( oSettings.oFeatures.bFilter )
|
|
172
|
{
|
|
173
|
/* _fnFilter() will redraw the table for us */
|
|
174
|
_fnFilterComplete( oSettings, oSettings.oPreviousSearch, 1 );
|
|
175
|
}
|
|
176
|
else
|
|
177
|
{
|
|
178
|
oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
|
|
179
|
oSettings._iDisplayStart = 0; /* reset display back to page 0 */
|
|
180
|
_fnCalculateEnd( oSettings );
|
|
181
|
_fnDraw( oSettings );
|
|
182
|
}
|
|
183
|
}
|
|
184
|
|
|
185
|
|
|
186
|
/**
|
|
187
|
* Attach a sort handler (click) to a node
|
|
188
|
* @param {object} oSettings dataTables settings object
|
|
189
|
* @param {node} nNode node to attach the handler to
|
|
190
|
* @param {int} iDataIndex column sorting index
|
|
191
|
* @param {function} [fnCallback] callback function
|
|
192
|
* @memberof DataTable#oApi
|
|
193
|
*/
|
|
194
|
function _fnSortAttachListener ( oSettings, nNode, iDataIndex, fnCallback )
|
|
195
|
{
|
|
196
|
_fnBindAction( nNode, {}, function (e) {
|
|
197
|
/* If the column is not sortable - don't to anything */
|
|
198
|
if ( oSettings.aoColumns[iDataIndex].bSortable === false )
|
|
199
|
{
|
|
200
|
return;
|
|
201
|
}
|
|
202
|
|
|
203
|
/*
|
|
204
|
* This is a little bit odd I admit... I declare a temporary function inside the scope of
|
|
205
|
* _fnBuildHead and the click handler in order that the code presented here can be used
|
|
206
|
* twice - once for when bProcessing is enabled, and another time for when it is
|
|
207
|
* disabled, as we need to perform slightly different actions.
|
|
208
|
* Basically the issue here is that the Javascript engine in modern browsers don't
|
|
209
|
* appear to allow the rendering engine to update the display while it is still executing
|
|
210
|
* it's thread (well - it does but only after long intervals). This means that the
|
|
211
|
* 'processing' display doesn't appear for a table sort. To break the js thread up a bit
|
|
212
|
* I force an execution break by using setTimeout - but this breaks the expected
|
|
213
|
* thread continuation for the end-developer's point of view (their code would execute
|
|
214
|
* too early), so we only do it when we absolutely have to.
|
|
215
|
*/
|
|
216
|
var fnInnerSorting = function () {
|
|
217
|
var iColumn, iNextSort;
|
|
218
|
|
|
219
|
/* If the shift key is pressed then we are multiple column sorting */
|
|
220
|
if ( e.shiftKey )
|
|
221
|
{
|
|
222
|
/* Are we already doing some kind of sort on this column? */
|
|
223
|
var bFound = false;
|
|
224
|
for ( var i=0 ; i<oSettings.aaSorting.length ; i++ )
|
|
225
|
{
|
|
226
|
if ( oSettings.aaSorting[i][0] == iDataIndex )
|
|
227
|
{
|
|
228
|
bFound = true;
|
|
229
|
iColumn = oSettings.aaSorting[i][0];
|
|
230
|
iNextSort = oSettings.aaSorting[i][2]+1;
|
|
231
|
|
|
232
|
if ( !oSettings.aoColumns[iColumn].asSorting[iNextSort] )
|
|
233
|
{
|
|
234
|
/* Reached the end of the sorting options, remove from multi-col sort */
|
|
235
|
oSettings.aaSorting.splice( i, 1 );
|
|
236
|
}
|
|
237
|
else
|
|
238
|
{
|
|
239
|
/* Move onto next sorting direction */
|
|
240
|
oSettings.aaSorting[i][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
|
|
241
|
oSettings.aaSorting[i][2] = iNextSort;
|
|
242
|
}
|
|
243
|
break;
|
|
244
|
}
|
|
245
|
}
|
|
246
|
|
|
247
|
/* No sort yet - add it in */
|
|
248
|
if ( bFound === false )
|
|
249
|
{
|
|
250
|
oSettings.aaSorting.push( [ iDataIndex,
|
|
251
|
oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
|
|
252
|
}
|
|
253
|
}
|
|
254
|
else
|
|
255
|
{
|
|
256
|
/* If no shift key then single column sort */
|
|
257
|
if ( oSettings.aaSorting.length == 1 && oSettings.aaSorting[0][0] == iDataIndex )
|
|
258
|
{
|
|
259
|
iColumn = oSettings.aaSorting[0][0];
|
|
260
|
iNextSort = oSettings.aaSorting[0][2]+1;
|
|
261
|
if ( !oSettings.aoColumns[iColumn].asSorting[iNextSort] )
|
|
262
|
{
|
|
263
|
iNextSort = 0;
|
|
264
|
}
|
|
265
|
oSettings.aaSorting[0][1] = oSettings.aoColumns[iColumn].asSorting[iNextSort];
|
|
266
|
oSettings.aaSorting[0][2] = iNextSort;
|
|
267
|
}
|
|
268
|
else
|
|
269
|
{
|
|
270
|
oSettings.aaSorting.splice( 0, oSettings.aaSorting.length );
|
|
271
|
oSettings.aaSorting.push( [ iDataIndex,
|
|
272
|
oSettings.aoColumns[iDataIndex].asSorting[0], 0 ] );
|
|
273
|
}
|
|
274
|
}
|
|
275
|
|
|
276
|
/* Run the sort */
|
|
277
|
_fnSort( oSettings );
|
|
278
|
}; /* /fnInnerSorting */
|
|
279
|
|
|
280
|
if ( !oSettings.oFeatures.bProcessing )
|
|
281
|
{
|
|
282
|
fnInnerSorting();
|
|
283
|
}
|
|
284
|
else
|
|
285
|
{
|
|
286
|
_fnProcessingDisplay( oSettings, true );
|
|
287
|
setTimeout( function() {
|
|
288
|
fnInnerSorting();
|
|
289
|
if ( !oSettings.oFeatures.bServerSide )
|
|
290
|
{
|
|
291
|
_fnProcessingDisplay( oSettings, false );
|
|
292
|
}
|
|
293
|
}, 0 );
|
|
294
|
}
|
|
295
|
|
|
296
|
/* Call the user specified callback function - used for async user interaction */
|
|
297
|
if ( typeof fnCallback == 'function' )
|
|
298
|
{
|
|
299
|
fnCallback( oSettings );
|
|
300
|
}
|
|
301
|
} );
|
|
302
|
}
|
|
303
|
|
|
304
|
|
|
305
|
/**
|
|
306
|
* Set the sorting classes on the header, Note: it is safe to call this function
|
|
307
|
* when bSort and bSortClasses are false
|
|
308
|
* @param {object} oSettings dataTables settings object
|
|
309
|
* @memberof DataTable#oApi
|
|
310
|
*/
|
|
311
|
function _fnSortingClasses( oSettings )
|
|
312
|
{
|
|
313
|
var i, iLen, j, jLen, iFound;
|
|
314
|
var aaSort, sClass;
|
|
315
|
var iColumns = oSettings.aoColumns.length;
|
|
316
|
var oClasses = oSettings.oClasses;
|
|
317
|
|
|
318
|
for ( i=0 ; i<iColumns ; i++ )
|
|
319
|
{
|
|
320
|
if ( oSettings.aoColumns[i].bSortable )
|
|
321
|
{
|
|
322
|
$(oSettings.aoColumns[i].nTh).removeClass( oClasses.sSortAsc +" "+ oClasses.sSortDesc +
|
|
323
|
" "+ oSettings.aoColumns[i].sSortingClass );
|
|
324
|
}
|
|
325
|
}
|
|
326
|
|
|
327
|
if ( oSettings.aaSortingFixed !== null )
|
|
328
|
{
|
|
329
|
aaSort = oSettings.aaSortingFixed.concat( oSettings.aaSorting );
|
|
330
|
}
|
|
331
|
else
|
|
332
|
{
|
|
333
|
aaSort = oSettings.aaSorting.slice();
|
|
334
|
}
|
|
335
|
|
|
336
|
/* Apply the required classes to the header */
|
|
337
|
for ( i=0 ; i<oSettings.aoColumns.length ; i++ )
|
|
338
|
{
|
|
339
|
if ( oSettings.aoColumns[i].bSortable )
|
|
340
|
{
|
|
341
|
sClass = oSettings.aoColumns[i].sSortingClass;
|
|
342
|
iFound = -1;
|
|
343
|
for ( j=0 ; j<aaSort.length ; j++ )
|
|
344
|
{
|
|
345
|
if ( aaSort[j][0] == i )
|
|
346
|
{
|
|
347
|
sClass = ( aaSort[j][1] == "asc" ) ?
|
|
348
|
oClasses.sSortAsc : oClasses.sSortDesc;
|
|
349
|
iFound = j;
|
|
350
|
break;
|
|
351
|
}
|
|
352
|
}
|
|
353
|
$(oSettings.aoColumns[i].nTh).addClass( sClass );
|
|
354
|
|
|
355
|
if ( oSettings.bJUI )
|
|
356
|
{
|
|
357
|
/* jQuery UI uses extra markup */
|
|
358
|
var jqSpan = $("span."+oClasses.sSortIcon, oSettings.aoColumns[i].nTh);
|
|
359
|
jqSpan.removeClass(oClasses.sSortJUIAsc +" "+ oClasses.sSortJUIDesc +" "+
|
|
360
|
oClasses.sSortJUI +" "+ oClasses.sSortJUIAscAllowed +" "+ oClasses.sSortJUIDescAllowed );
|
|
361
|
|
|
362
|
var sSpanClass;
|
|
363
|
if ( iFound == -1 )
|
|
364
|
{
|
|
365
|
sSpanClass = oSettings.aoColumns[i].sSortingClassJUI;
|
|
366
|
}
|
|
367
|
else if ( aaSort[iFound][1] == "asc" )
|
|
368
|
{
|
|
369
|
sSpanClass = oClasses.sSortJUIAsc;
|
|
370
|
}
|
|
371
|
else
|
|
372
|
{
|
|
373
|
sSpanClass = oClasses.sSortJUIDesc;
|
|
374
|
}
|
|
375
|
|
|
376
|
jqSpan.addClass( sSpanClass );
|
|
377
|
}
|
|
378
|
}
|
|
379
|
else
|
|
380
|
{
|
|
381
|
/* No sorting on this column, so add the base class. This will have been assigned by
|
|
382
|
* _fnAddColumn
|
|
383
|
*/
|
|
384
|
$(oSettings.aoColumns[i].nTh).addClass( oSettings.aoColumns[i].sSortingClass );
|
|
385
|
}
|
|
386
|
}
|
|
387
|
|
|
388
|
/*
|
|
389
|
* Apply the required classes to the table body
|
|
390
|
* Note that this is given as a feature switch since it can significantly slow down a sort
|
|
391
|
* on large data sets (adding and removing of classes is always slow at the best of times..)
|
|
392
|
* Further to this, note that this code is admittedly fairly ugly. It could be made a lot
|
|
393
|
* simpler using jQuery selectors and add/removeClass, but that is significantly slower
|
|
394
|
* (on the order of 5 times slower) - hence the direct DOM manipulation here.
|
|
395
|
* Note that for deferred drawing we do use jQuery - the reason being that taking the first
|
|
396
|
* row found to see if the whole column needs processed can miss classes since the first
|
|
397
|
* column might be new.
|
|
398
|
*/
|
|
399
|
sClass = oClasses.sSortColumn;
|
|
400
|
|
|
401
|
if ( oSettings.oFeatures.bSort && oSettings.oFeatures.bSortClasses )
|
|
402
|
{
|
|
403
|
var nTds = _fnGetTdNodes( oSettings );
|
|
404
|
|
|
405
|
/* Determine what the sorting class for each column should be */
|
|
406
|
var iClass, iTargetCol;
|
|
407
|
var asClasses = [];
|
|
408
|
for (i = 0; i < iColumns; i++)
|
|
409
|
{
|
|
410
|
asClasses.push("");
|
|
411
|
}
|
|
412
|
for (i = 0, iClass = 1; i < aaSort.length; i++)
|
|
413
|
{
|
|
414
|
iTargetCol = parseInt( aaSort[i][0], 10 );
|
|
415
|
asClasses[iTargetCol] = sClass + iClass;
|
|
416
|
|
|
417
|
if ( iClass < 3 )
|
|
418
|
{
|
|
419
|
iClass++;
|
|
420
|
}
|
|
421
|
}
|
|
422
|
|
|
423
|
/* Make changes to the classes for each cell as needed */
|
|
424
|
var reClass = new RegExp(sClass + "[123]");
|
|
425
|
var sTmpClass, sCurrentClass, sNewClass;
|
|
426
|
for ( i=0, iLen=nTds.length; i<iLen; i++ )
|
|
427
|
{
|
|
428
|
/* Determine which column we're looking at */
|
|
429
|
iTargetCol = i % iColumns;
|
|
430
|
|
|
431
|
/* What is the full list of classes now */
|
|
432
|
sCurrentClass = nTds[i].className;
|
|
433
|
/* What sorting class should be applied? */
|
|
434
|
sNewClass = asClasses[iTargetCol];
|
|
435
|
/* What would the new full list be if we did a replacement? */
|
|
436
|
sTmpClass = sCurrentClass.replace(reClass, sNewClass);
|
|
437
|
|
|
438
|
if ( sTmpClass != sCurrentClass )
|
|
439
|
{
|
|
440
|
/* We changed something */
|
|
441
|
nTds[i].className = $.trim( sTmpClass );
|
|
442
|
}
|
|
443
|
else if ( sNewClass.length > 0 && sCurrentClass.indexOf(sNewClass) == -1 )
|
|
444
|
{
|
|
445
|
/* We need to add a class */
|
|
446
|
nTds[i].className = sCurrentClass + " " + sNewClass;
|
|
447
|
}
|
|
448
|
}
|
|
449
|
}
|
|
450
|
}
|
|
451
|
|