Mercurial > repos > saskia-hiltemann > ireport
comparison DataTables-1.9.4/media/src/core/core.columns.js @ 0:ac5f9272033b draft
first upload
author | saskia-hiltemann |
---|---|
date | Tue, 01 Jul 2014 11:42:23 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:ac5f9272033b |
---|---|
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 |