|
0
|
1
|
|
|
2
|
|
|
3 /**
|
|
|
4 * Add a column to the list used for the table with default values
|
|
|
5 * @param {object} oSettings dataTables settings object
|
|
|
6 * @param {node} nTh The th element for this column
|
|
|
7 * @memberof DataTable#oApi
|
|
|
8 */
|
|
|
9 function _fnAddColumn( oSettings, nTh )
|
|
|
10 {
|
|
|
11 var oDefaults = DataTable.defaults.columns;
|
|
|
12 var iCol = oSettings.aoColumns.length;
|
|
|
13 var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
|
|
|
14 "sSortingClass": oSettings.oClasses.sSortable,
|
|
|
15 "sSortingClassJUI": oSettings.oClasses.sSortJUI,
|
|
|
16 "nTh": nTh ? nTh : document.createElement('th'),
|
|
|
17 "sTitle": oDefaults.sTitle ? oDefaults.sTitle : nTh ? nTh.innerHTML : '',
|
|
|
18 "aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
|
|
|
19 "mData": oDefaults.mData ? oDefaults.oDefaults : iCol
|
|
|
20 } );
|
|
|
21 oSettings.aoColumns.push( oCol );
|
|
|
22
|
|
|
23 /* Add a column specific filter */
|
|
|
24 if ( oSettings.aoPreSearchCols[ iCol ] === undefined || oSettings.aoPreSearchCols[ iCol ] === null )
|
|
|
25 {
|
|
|
26 oSettings.aoPreSearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch );
|
|
|
27 }
|
|
|
28 else
|
|
|
29 {
|
|
|
30 var oPre = oSettings.aoPreSearchCols[ iCol ];
|
|
|
31
|
|
|
32 /* Don't require that the user must specify bRegex, bSmart or bCaseInsensitive */
|
|
|
33 if ( oPre.bRegex === undefined )
|
|
|
34 {
|
|
|
35 oPre.bRegex = true;
|
|
|
36 }
|
|
|
37
|
|
|
38 if ( oPre.bSmart === undefined )
|
|
|
39 {
|
|
|
40 oPre.bSmart = true;
|
|
|
41 }
|
|
|
42
|
|
|
43 if ( oPre.bCaseInsensitive === undefined )
|
|
|
44 {
|
|
|
45 oPre.bCaseInsensitive = true;
|
|
|
46 }
|
|
|
47 }
|
|
|
48
|
|
|
49 /* Use the column options function to initialise classes etc */
|
|
|
50 _fnColumnOptions( oSettings, iCol, null );
|
|
|
51 }
|
|
|
52
|
|
|
53
|
|
|
54 /**
|
|
|
55 * Apply options for a column
|
|
|
56 * @param {object} oSettings dataTables settings object
|
|
|
57 * @param {int} iCol column index to consider
|
|
|
58 * @param {object} oOptions object with sType, bVisible and bSearchable etc
|
|
|
59 * @memberof DataTable#oApi
|
|
|
60 */
|
|
|
61 function _fnColumnOptions( oSettings, iCol, oOptions )
|
|
|
62 {
|
|
|
63 var oCol = oSettings.aoColumns[ iCol ];
|
|
|
64
|
|
|
65 /* User specified column options */
|
|
|
66 if ( oOptions !== undefined && oOptions !== null )
|
|
|
67 {
|
|
|
68 /* Backwards compatibility for mDataProp */
|
|
|
69 if ( oOptions.mDataProp && !oOptions.mData )
|
|
|
70 {
|
|
|
71 oOptions.mData = oOptions.mDataProp;
|
|
|
72 }
|
|
|
73
|
|
|
74 if ( oOptions.sType !== undefined )
|
|
|
75 {
|
|
|
76 oCol.sType = oOptions.sType;
|
|
|
77 oCol._bAutoType = false;
|
|
|
78 }
|
|
|
79
|
|
|
80 $.extend( oCol, oOptions );
|
|
|
81 _fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
|
|
|
82
|
|
|
83 /* iDataSort to be applied (backwards compatibility), but aDataSort will take
|
|
|
84 * priority if defined
|
|
|
85 */
|
|
|
86 if ( oOptions.iDataSort !== undefined )
|
|
|
87 {
|
|
|
88 oCol.aDataSort = [ oOptions.iDataSort ];
|
|
|
89 }
|
|
|
90 _fnMap( oCol, oOptions, "aDataSort" );
|
|
|
91 }
|
|
|
92
|
|
|
93 /* Cache the data get and set functions for speed */
|
|
|
94 var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
|
|
|
95 var mData = _fnGetObjectDataFn( oCol.mData );
|
|
|
96
|
|
|
97 oCol.fnGetData = function (oData, sSpecific) {
|
|
|
98 var innerData = mData( oData, sSpecific );
|
|
|
99
|
|
|
100 if ( oCol.mRender && (sSpecific && sSpecific !== '') )
|
|
|
101 {
|
|
|
102 return mRender( innerData, sSpecific, oData );
|
|
|
103 }
|
|
|
104 return innerData;
|
|
|
105 };
|
|
|
106 oCol.fnSetData = _fnSetObjectDataFn( oCol.mData );
|
|
|
107
|
|
|
108 /* Feature sorting overrides column specific when off */
|
|
|
109 if ( !oSettings.oFeatures.bSort )
|
|
|
110 {
|
|
|
111 oCol.bSortable = false;
|
|
|
112 }
|
|
|
113
|
|
|
114 /* Check that the class assignment is correct for sorting */
|
|
|
115 if ( !oCol.bSortable ||
|
|
|
116 ($.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1) )
|
|
|
117 {
|
|
|
118 oCol.sSortingClass = oSettings.oClasses.sSortableNone;
|
|
|
119 oCol.sSortingClassJUI = "";
|
|
|
120 }
|
|
|
121 else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) == -1 )
|
|
|
122 {
|
|
|
123 oCol.sSortingClass = oSettings.oClasses.sSortable;
|
|
|
124 oCol.sSortingClassJUI = oSettings.oClasses.sSortJUI;
|
|
|
125 }
|
|
|
126 else if ( $.inArray('asc', oCol.asSorting) != -1 && $.inArray('desc', oCol.asSorting) == -1 )
|
|
|
127 {
|
|
|
128 oCol.sSortingClass = oSettings.oClasses.sSortableAsc;
|
|
|
129 oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIAscAllowed;
|
|
|
130 }
|
|
|
131 else if ( $.inArray('asc', oCol.asSorting) == -1 && $.inArray('desc', oCol.asSorting) != -1 )
|
|
|
132 {
|
|
|
133 oCol.sSortingClass = oSettings.oClasses.sSortableDesc;
|
|
|
134 oCol.sSortingClassJUI = oSettings.oClasses.sSortJUIDescAllowed;
|
|
|
135 }
|
|
|
136 }
|
|
|
137
|
|
|
138
|
|
|
139 /**
|
|
|
140 * Adjust the table column widths for new data. Note: you would probably want to
|
|
|
141 * do a redraw after calling this function!
|
|
|
142 * @param {object} oSettings dataTables settings object
|
|
|
143 * @memberof DataTable#oApi
|
|
|
144 */
|
|
|
145 function _fnAdjustColumnSizing ( oSettings )
|
|
|
146 {
|
|
|
147 /* Not interested in doing column width calculation if auto-width is disabled */
|
|
|
148 if ( oSettings.oFeatures.bAutoWidth === false )
|
|
|
149 {
|
|
|
150 return false;
|
|
|
151 }
|
|
|
152
|
|
|
153 _fnCalculateColumnWidths( oSettings );
|
|
|
154 for ( var i=0 , iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
|
|
|
155 {
|
|
|
156 oSettings.aoColumns[i].nTh.style.width = oSettings.aoColumns[i].sWidth;
|
|
|
157 }
|
|
|
158 }
|
|
|
159
|
|
|
160
|
|
|
161 /**
|
|
|
162 * Covert the index of a visible column to the index in the data array (take account
|
|
|
163 * of hidden columns)
|
|
|
164 * @param {object} oSettings dataTables settings object
|
|
|
165 * @param {int} iMatch Visible column index to lookup
|
|
|
166 * @returns {int} i the data index
|
|
|
167 * @memberof DataTable#oApi
|
|
|
168 */
|
|
|
169 function _fnVisibleToColumnIndex( oSettings, iMatch )
|
|
|
170 {
|
|
|
171 var aiVis = _fnGetColumns( oSettings, 'bVisible' );
|
|
|
172
|
|
|
173 return typeof aiVis[iMatch] === 'number' ?
|
|
|
174 aiVis[iMatch] :
|
|
|
175 null;
|
|
|
176 }
|
|
|
177
|
|
|
178
|
|
|
179 /**
|
|
|
180 * Covert the index of an index in the data array and convert it to the visible
|
|
|
181 * column index (take account of hidden columns)
|
|
|
182 * @param {int} iMatch Column index to lookup
|
|
|
183 * @param {object} oSettings dataTables settings object
|
|
|
184 * @returns {int} i the data index
|
|
|
185 * @memberof DataTable#oApi
|
|
|
186 */
|
|
|
187 function _fnColumnIndexToVisible( oSettings, iMatch )
|
|
|
188 {
|
|
|
189 var aiVis = _fnGetColumns( oSettings, 'bVisible' );
|
|
|
190 var iPos = $.inArray( iMatch, aiVis );
|
|
|
191
|
|
|
192 return iPos !== -1 ? iPos : null;
|
|
|
193 }
|
|
|
194
|
|
|
195
|
|
|
196 /**
|
|
|
197 * Get the number of visible columns
|
|
|
198 * @param {object} oSettings dataTables settings object
|
|
|
199 * @returns {int} i the number of visible columns
|
|
|
200 * @memberof DataTable#oApi
|
|
|
201 */
|
|
|
202 function _fnVisbleColumns( oSettings )
|
|
|
203 {
|
|
|
204 return _fnGetColumns( oSettings, 'bVisible' ).length;
|
|
|
205 }
|
|
|
206
|
|
|
207
|
|
|
208 /**
|
|
|
209 * Get an array of column indexes that match a given property
|
|
|
210 * @param {object} oSettings dataTables settings object
|
|
|
211 * @param {string} sParam Parameter in aoColumns to look for - typically
|
|
|
212 * bVisible or bSearchable
|
|
|
213 * @returns {array} Array of indexes with matched properties
|
|
|
214 * @memberof DataTable#oApi
|
|
|
215 */
|
|
|
216 function _fnGetColumns( oSettings, sParam )
|
|
|
217 {
|
|
|
218 var a = [];
|
|
|
219
|
|
|
220 $.map( oSettings.aoColumns, function(val, i) {
|
|
|
221 if ( val[sParam] ) {
|
|
|
222 a.push( i );
|
|
|
223 }
|
|
|
224 } );
|
|
|
225
|
|
|
226 return a;
|
|
|
227 }
|
|
|
228
|
|
|
229
|
|
|
230 /**
|
|
|
231 * Get the sort type based on an input string
|
|
|
232 * @param {string} sData data we wish to know the type of
|
|
|
233 * @returns {string} type (defaults to 'string' if no type can be detected)
|
|
|
234 * @memberof DataTable#oApi
|
|
|
235 */
|
|
|
236 function _fnDetectType( sData )
|
|
|
237 {
|
|
|
238 var aTypes = DataTable.ext.aTypes;
|
|
|
239 var iLen = aTypes.length;
|
|
|
240
|
|
|
241 for ( var i=0 ; i<iLen ; i++ )
|
|
|
242 {
|
|
|
243 var sType = aTypes[i]( sData );
|
|
|
244 if ( sType !== null )
|
|
|
245 {
|
|
|
246 return sType;
|
|
|
247 }
|
|
|
248 }
|
|
|
249
|
|
|
250 return 'string';
|
|
|
251 }
|
|
|
252
|
|
|
253
|
|
|
254 /**
|
|
|
255 * Figure out how to reorder a display list
|
|
|
256 * @param {object} oSettings dataTables settings object
|
|
|
257 * @returns array {int} aiReturn index list for reordering
|
|
|
258 * @memberof DataTable#oApi
|
|
|
259 */
|
|
|
260 function _fnReOrderIndex ( oSettings, sColumns )
|
|
|
261 {
|
|
|
262 var aColumns = sColumns.split(',');
|
|
|
263 var aiReturn = [];
|
|
|
264
|
|
|
265 for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
|
|
|
266 {
|
|
|
267 for ( var j=0 ; j<iLen ; j++ )
|
|
|
268 {
|
|
|
269 if ( oSettings.aoColumns[i].sName == aColumns[j] )
|
|
|
270 {
|
|
|
271 aiReturn.push( j );
|
|
|
272 break;
|
|
|
273 }
|
|
|
274 }
|
|
|
275 }
|
|
|
276
|
|
|
277 return aiReturn;
|
|
|
278 }
|
|
|
279
|
|
|
280
|
|
|
281 /**
|
|
|
282 * Get the column ordering that DataTables expects
|
|
|
283 * @param {object} oSettings dataTables settings object
|
|
|
284 * @returns {string} comma separated list of names
|
|
|
285 * @memberof DataTable#oApi
|
|
|
286 */
|
|
|
287 function _fnColumnOrdering ( oSettings )
|
|
|
288 {
|
|
|
289 var sNames = '';
|
|
|
290 for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
|
|
|
291 {
|
|
|
292 sNames += oSettings.aoColumns[i].sName+',';
|
|
|
293 }
|
|
|
294 if ( sNames.length == iLen )
|
|
|
295 {
|
|
|
296 return "";
|
|
|
297 }
|
|
|
298 return sNames.slice(0, -1);
|
|
|
299 }
|
|
|
300
|
|
|
301
|
|
|
302 /**
|
|
|
303 * Take the column definitions and static columns arrays and calculate how
|
|
|
304 * they relate to column indexes. The callback function will then apply the
|
|
|
305 * definition found for a column to a suitable configuration object.
|
|
|
306 * @param {object} oSettings dataTables settings object
|
|
|
307 * @param {array} aoColDefs The aoColumnDefs array that is to be applied
|
|
|
308 * @param {array} aoCols The aoColumns array that defines columns individually
|
|
|
309 * @param {function} fn Callback function - takes two parameters, the calculated
|
|
|
310 * column index and the definition for that column.
|
|
|
311 * @memberof DataTable#oApi
|
|
|
312 */
|
|
|
313 function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
|
|
|
314 {
|
|
|
315 var i, iLen, j, jLen, k, kLen;
|
|
|
316
|
|
|
317 // Column definitions with aTargets
|
|
|
318 if ( aoColDefs )
|
|
|
319 {
|
|
|
320 /* Loop over the definitions array - loop in reverse so first instance has priority */
|
|
|
321 for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
|
|
|
322 {
|
|
|
323 /* Each definition can target multiple columns, as it is an array */
|
|
|
324 var aTargets = aoColDefs[i].aTargets;
|
|
|
325 if ( !$.isArray( aTargets ) )
|
|
|
326 {
|
|
|
327 _fnLog( oSettings, 1, 'aTargets must be an array of targets, not a '+(typeof aTargets) );
|
|
|
328 }
|
|
|
329
|
|
|
330 for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
|
|
|
331 {
|
|
|
332 if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
|
|
|
333 {
|
|
|
334 /* Add columns that we don't yet know about */
|
|
|
335 while( oSettings.aoColumns.length <= aTargets[j] )
|
|
|
336 {
|
|
|
337 _fnAddColumn( oSettings );
|
|
|
338 }
|
|
|
339
|
|
|
340 /* Integer, basic index */
|
|
|
341 fn( aTargets[j], aoColDefs[i] );
|
|
|
342 }
|
|
|
343 else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
|
|
|
344 {
|
|
|
345 /* Negative integer, right to left column counting */
|
|
|
346 fn( oSettings.aoColumns.length+aTargets[j], aoColDefs[i] );
|
|
|
347 }
|
|
|
348 else if ( typeof aTargets[j] === 'string' )
|
|
|
349 {
|
|
|
350 /* Class name matching on TH element */
|
|
|
351 for ( k=0, kLen=oSettings.aoColumns.length ; k<kLen ; k++ )
|
|
|
352 {
|
|
|
353 if ( aTargets[j] == "_all" ||
|
|
|
354 $(oSettings.aoColumns[k].nTh).hasClass( aTargets[j] ) )
|
|
|
355 {
|
|
|
356 fn( k, aoColDefs[i] );
|
|
|
357 }
|
|
|
358 }
|
|
|
359 }
|
|
|
360 }
|
|
|
361 }
|
|
|
362 }
|
|
|
363
|
|
|
364 // Statically defined columns array
|
|
|
365 if ( aoCols )
|
|
|
366 {
|
|
|
367 for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
|
|
|
368 {
|
|
|
369 fn( i, aoCols[i] );
|
|
|
370 }
|
|
|
371 }
|
|
|
372 }
|
|
|
373
|
