1 |
|
2 |
|
3 |
/** |
4 |
* Column options that can be given to DataTables at initialisation time. |
5 |
* @namespace |
6 |
*/ |
7 |
DataTable.defaults.columns = { |
8 |
/** |
9 |
* Allows a column's sorting to take multiple columns into account when |
10 |
* doing a sort. For example first name / last name columns make sense to |
11 |
* do a multi-column sort over the two columns. |
12 |
* @type array |
13 |
* @default null <i>Takes the value of the column index automatically</i> |
14 |
* @dtopt Columns |
15 |
* |
16 |
* @example |
17 |
* // Using aoColumnDefs |
18 |
* $(document).ready( function() { |
19 |
* $('#example').dataTable( { |
20 |
* "aoColumnDefs": [ |
21 |
* { "aDataSort": [ 0, 1 ], "aTargets": [ 0 ] }, |
22 |
* { "aDataSort": [ 1, 0 ], "aTargets": [ 1 ] }, |
23 |
* { "aDataSort": [ 2, 3, 4 ], "aTargets": [ 2 ] } |
24 |
* ] |
25 |
* } ); |
26 |
* } ); |
27 |
* |
28 |
* @example |
29 |
* // Using aoColumns |
30 |
* $(document).ready( function() { |
31 |
* $('#example').dataTable( { |
32 |
* "aoColumns": [ |
33 |
* { "aDataSort": [ 0, 1 ] }, |
34 |
* { "aDataSort": [ 1, 0 ] }, |
35 |
* { "aDataSort": [ 2, 3, 4 ] }, |
36 |
* null, |
37 |
* null |
38 |
* ] |
39 |
* } ); |
40 |
* } ); |
41 |
*/ |
42 |
"aDataSort": null, |
43 |
|
44 |
|
45 |
/** |
46 |
* You can control the default sorting direction, and even alter the behaviour |
47 |
* of the sort handler (i.e. only allow ascending sorting etc) using this |
48 |
* parameter. |
49 |
* @type array |
50 |
* @default [ 'asc', 'desc' ] |
51 |
* @dtopt Columns |
52 |
* |
53 |
* @example |
54 |
* // Using aoColumnDefs |
55 |
* $(document).ready( function() { |
56 |
* $('#example').dataTable( { |
57 |
* "aoColumnDefs": [ |
58 |
* { "asSorting": [ "asc" ], "aTargets": [ 1 ] }, |
59 |
* { "asSorting": [ "desc", "asc", "asc" ], "aTargets": [ 2 ] }, |
60 |
* { "asSorting": [ "desc" ], "aTargets": [ 3 ] } |
61 |
* ] |
62 |
* } ); |
63 |
* } ); |
64 |
* |
65 |
* @example |
66 |
* // Using aoColumns |
67 |
* $(document).ready( function() { |
68 |
* $('#example').dataTable( { |
69 |
* "aoColumns": [ |
70 |
* null, |
71 |
* { "asSorting": [ "asc" ] }, |
72 |
* { "asSorting": [ "desc", "asc", "asc" ] }, |
73 |
* { "asSorting": [ "desc" ] }, |
74 |
* null |
75 |
* ] |
76 |
* } ); |
77 |
* } ); |
78 |
*/ |
79 |
"asSorting": [ 'asc', 'desc' ], |
80 |
|
81 |
|
82 |
/** |
83 |
* Enable or disable filtering on the data in this column. |
84 |
* @type boolean |
85 |
* @default true |
86 |
* @dtopt Columns |
87 |
* |
88 |
* @example |
89 |
* // Using aoColumnDefs |
90 |
* $(document).ready( function() { |
91 |
* $('#example').dataTable( { |
92 |
* "aoColumnDefs": [ |
93 |
* { "bSearchable": false, "aTargets": [ 0 ] } |
94 |
* ] } ); |
95 |
* } ); |
96 |
* |
97 |
* @example |
98 |
* // Using aoColumns |
99 |
* $(document).ready( function() { |
100 |
* $('#example').dataTable( { |
101 |
* "aoColumns": [ |
102 |
* { "bSearchable": false }, |
103 |
* null, |
104 |
* null, |
105 |
* null, |
106 |
* null |
107 |
* ] } ); |
108 |
* } ); |
109 |
*/ |
110 |
"bSearchable": true, |
111 |
|
112 |
|
113 |
/** |
114 |
* Enable or disable sorting on this column. |
115 |
* @type boolean |
116 |
* @default true |
117 |
* @dtopt Columns |
118 |
* |
119 |
* @example |
120 |
* // Using aoColumnDefs |
121 |
* $(document).ready( function() { |
122 |
* $('#example').dataTable( { |
123 |
* "aoColumnDefs": [ |
124 |
* { "bSortable": false, "aTargets": [ 0 ] } |
125 |
* ] } ); |
126 |
* } ); |
127 |
* |
128 |
* @example |
129 |
* // Using aoColumns |
130 |
* $(document).ready( function() { |
131 |
* $('#example').dataTable( { |
132 |
* "aoColumns": [ |
133 |
* { "bSortable": false }, |
134 |
* null, |
135 |
* null, |
136 |
* null, |
137 |
* null |
138 |
* ] } ); |
139 |
* } ); |
140 |
*/ |
141 |
"bSortable": true, |
142 |
|
143 |
|
144 |
/** |
145 |
* <code>Deprecated</code> When using fnRender() for a column, you may wish |
146 |
* to use the original data (before rendering) for sorting and filtering |
147 |
* (the default is to used the rendered data that the user can see). This |
148 |
* may be useful for dates etc. |
149 |
* |
150 |
* Please note that this option has now been deprecated and will be removed |
151 |
* in the next version of DataTables. Please use mRender / mData rather than |
152 |
* fnRender. |
153 |
* @type boolean |
154 |
* @default true |
155 |
* @dtopt Columns |
156 |
* @deprecated |
157 |
*/ |
158 |
"bUseRendered": true, |
159 |
|
160 |
|
161 |
/** |
162 |
* Enable or disable the display of this column. |
163 |
* @type boolean |
164 |
* @default true |
165 |
* @dtopt Columns |
166 |
* |
167 |
* @example |
168 |
* // Using aoColumnDefs |
169 |
* $(document).ready( function() { |
170 |
* $('#example').dataTable( { |
171 |
* "aoColumnDefs": [ |
172 |
* { "bVisible": false, "aTargets": [ 0 ] } |
173 |
* ] } ); |
174 |
* } ); |
175 |
* |
176 |
* @example |
177 |
* // Using aoColumns |
178 |
* $(document).ready( function() { |
179 |
* $('#example').dataTable( { |
180 |
* "aoColumns": [ |
181 |
* { "bVisible": false }, |
182 |
* null, |
183 |
* null, |
184 |
* null, |
185 |
* null |
186 |
* ] } ); |
187 |
* } ); |
188 |
*/ |
189 |
"bVisible": true, |
190 |
|
191 |
|
192 |
/** |
193 |
* Developer definable function that is called whenever a cell is created (Ajax source, |
194 |
* etc) or processed for input (DOM source). This can be used as a compliment to mRender |
195 |
* allowing you to modify the DOM element (add background colour for example) when the |
196 |
* element is available. |
197 |
* @type function |
198 |
* @param {element} nTd The TD node that has been created |
199 |
* @param {*} sData The Data for the cell |
200 |
* @param {array|object} oData The data for the whole row |
201 |
* @param {int} iRow The row index for the aoData data store |
202 |
* @param {int} iCol The column index for aoColumns |
203 |
* @dtopt Columns |
204 |
* |
205 |
* @example |
206 |
* $(document).ready( function() { |
207 |
* $('#example').dataTable( { |
208 |
* "aoColumnDefs": [ { |
209 |
* "aTargets": [3], |
210 |
* "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) { |
211 |
* if ( sData == "1.7" ) { |
212 |
* $(nTd).css('color', 'blue') |
213 |
* } |
214 |
* } |
215 |
* } ] |
216 |
* }); |
217 |
* } ); |
218 |
*/ |
219 |
"fnCreatedCell": null, |
220 |
|
221 |
|
222 |
/** |
223 |
* <code>Deprecated</code> Custom display function that will be called for the |
224 |
* display of each cell in this column. |
225 |
* |
226 |
* Please note that this option has now been deprecated and will be removed |
227 |
* in the next version of DataTables. Please use mRender / mData rather than |
228 |
* fnRender. |
229 |
* @type function |
230 |
* @param {object} o Object with the following parameters: |
231 |
* @param {int} o.iDataRow The row in aoData |
232 |
* @param {int} o.iDataColumn The column in question |
233 |
* @param {array} o.aData The data for the row in question |
234 |
* @param {object} o.oSettings The settings object for this DataTables instance |
235 |
* @param {object} o.mDataProp The data property used for this column |
236 |
* @param {*} val The current cell value |
237 |
* @returns {string} The string you which to use in the display |
238 |
* @dtopt Columns |
239 |
* @deprecated |
240 |
*/ |
241 |
"fnRender": null, |
242 |
|
243 |
|
244 |
/** |
245 |
* The column index (starting from 0!) that you wish a sort to be performed |
246 |
* upon when this column is selected for sorting. This can be used for sorting |
247 |
* on hidden columns for example. |
248 |
* @type int |
249 |
* @default -1 <i>Use automatically calculated column index</i> |
250 |
* @dtopt Columns |
251 |
* |
252 |
* @example |
253 |
* // Using aoColumnDefs |
254 |
* $(document).ready( function() { |
255 |
* $('#example').dataTable( { |
256 |
* "aoColumnDefs": [ |
257 |
* { "iDataSort": 1, "aTargets": [ 0 ] } |
258 |
* ] |
259 |
* } ); |
260 |
* } ); |
261 |
* |
262 |
* @example |
263 |
* // Using aoColumns |
264 |
* $(document).ready( function() { |
265 |
* $('#example').dataTable( { |
266 |
* "aoColumns": [ |
267 |
* { "iDataSort": 1 }, |
268 |
* null, |
269 |
* null, |
270 |
* null, |
271 |
* null |
272 |
* ] |
273 |
* } ); |
274 |
* } ); |
275 |
*/ |
276 |
"iDataSort": -1, |
277 |
|
278 |
|
279 |
/** |
280 |
* This parameter has been replaced by mData in DataTables to ensure naming |
281 |
* consistency. mDataProp can still be used, as there is backwards compatibility |
282 |
* in DataTables for this option, but it is strongly recommended that you use |
283 |
* mData in preference to mDataProp. |
284 |
* @name DataTable.defaults.columns.mDataProp |
285 |
*/ |
286 |
|
287 |
|
288 |
/** |
289 |
* This property can be used to read data from any JSON data source property, |
290 |
* including deeply nested objects / properties. mData can be given in a |
291 |
* number of different ways which effect its behaviour: |
292 |
* <ul> |
293 |
* <li>integer - treated as an array index for the data source. This is the |
294 |
* default that DataTables uses (incrementally increased for each column).</li> |
295 |
* <li>string - read an object property from the data source. Note that you can |
296 |
* use Javascript dotted notation to read deep properties / arrays from the |
297 |
* data source.</li> |
298 |
* <li>null - the sDefaultContent option will be used for the cell (null |
299 |
* by default, so you will need to specify the default content you want - |
300 |
* typically an empty string). This can be useful on generated columns such |
301 |
* as edit / delete action columns.</li> |
302 |
* <li>function - the function given will be executed whenever DataTables |
303 |
* needs to set or get the data for a cell in the column. The function |
304 |
* takes three parameters: |
305 |
* <ul> |
306 |
* <li>{array|object} The data source for the row</li> |
307 |
* <li>{string} The type call data requested - this will be 'set' when |
308 |
* setting data or 'filter', 'display', 'type', 'sort' or undefined when |
309 |
* gathering data. Note that when <i>undefined</i> is given for the type |
310 |
* DataTables expects to get the raw data for the object back</li> |
311 |
* <li>{*} Data to set when the second parameter is 'set'.</li> |
312 |
* </ul> |
313 |
* The return value from the function is not required when 'set' is the type |
314 |
* of call, but otherwise the return is what will be used for the data |
315 |
* requested.</li> |
316 |
* </ul> |
317 |
* |
318 |
* Note that prior to DataTables 1.9.2 mData was called mDataProp. The name change |
319 |
* reflects the flexibility of this property and is consistent with the naming of |
320 |
* mRender. If 'mDataProp' is given, then it will still be used by DataTables, as |
321 |
* it automatically maps the old name to the new if required. |
322 |
* @type string|int|function|null |
323 |
* @default null <i>Use automatically calculated column index</i> |
324 |
* @dtopt Columns |
325 |
* |
326 |
* @example |
327 |
* // Read table data from objects |
328 |
* $(document).ready( function() { |
329 |
* var oTable = $('#example').dataTable( { |
330 |
* "sAjaxSource": "sources/deep.txt", |
331 |
* "aoColumns": [ |
332 |
* { "mData": "engine" }, |
333 |
* { "mData": "browser" }, |
334 |
* { "mData": "platform.inner" }, |
335 |
* { "mData": "platform.details.0" }, |
336 |
* { "mData": "platform.details.1" } |
337 |
* ] |
338 |
* } ); |
339 |
* } ); |
340 |
* |
341 |
* @example |
342 |
* // Using mData as a function to provide different information for |
343 |
* // sorting, filtering and display. In this case, currency (price) |
344 |
* $(document).ready( function() { |
345 |
* var oTable = $('#example').dataTable( { |
346 |
* "aoColumnDefs": [ { |
347 |
* "aTargets": [ 0 ], |
348 |
* "mData": function ( source, type, val ) { |
349 |
* if (type === 'set') { |
350 |
* source.price = val; |
351 |
* // Store the computed dislay and filter values for efficiency |
352 |
* source.price_display = val=="" ? "" : "$"+numberFormat(val); |
353 |
* source.price_filter = val=="" ? "" : "$"+numberFormat(val)+" "+val; |
354 |
* return; |
355 |
* } |
356 |
* else if (type === 'display') { |
357 |
* return source.price_display; |
358 |
* } |
359 |
* else if (type === 'filter') { |
360 |
* return source.price_filter; |
361 |
* } |
362 |
* // 'sort', 'type' and undefined all just use the integer |
363 |
* return source.price; |
364 |
* } |
365 |
* } ] |
366 |
* } ); |
367 |
* } ); |
368 |
*/ |
369 |
"mData": null, |
370 |
|
371 |
|
372 |
/** |
373 |
* This property is the rendering partner to mData and it is suggested that |
374 |
* when you want to manipulate data for display (including filtering, sorting etc) |
375 |
* but not altering the underlying data for the table, use this property. mData |
376 |
* can actually do everything this property can and more, but this parameter is |
377 |
* easier to use since there is no 'set' option. Like mData is can be given |
378 |
* in a number of different ways to effect its behaviour, with the addition of |
379 |
* supporting array syntax for easy outputting of arrays (including arrays of |
380 |
* objects): |
381 |
* <ul> |
382 |
* <li>integer - treated as an array index for the data source. This is the |
383 |
* default that DataTables uses (incrementally increased for each column).</li> |
384 |
* <li>string - read an object property from the data source. Note that you can |
385 |
* use Javascript dotted notation to read deep properties / arrays from the |
386 |
* data source and also array brackets to indicate that the data reader should |
387 |
* loop over the data source array. When characters are given between the array |
388 |
* brackets, these characters are used to join the data source array together. |
389 |
* For example: "accounts[, ].name" would result in a comma separated list with |
390 |
* the 'name' value from the 'accounts' array of objects.</li> |
391 |
* <li>function - the function given will be executed whenever DataTables |
392 |
* needs to set or get the data for a cell in the column. The function |
393 |
* takes three parameters: |
394 |
* <ul> |
395 |
* <li>{array|object} The data source for the row (based on mData)</li> |
396 |
* <li>{string} The type call data requested - this will be 'filter', 'display', |
397 |
* 'type' or 'sort'.</li> |
398 |
* <li>{array|object} The full data source for the row (not based on mData)</li> |
399 |
* </ul> |
400 |
* The return value from the function is what will be used for the data |
401 |
* requested.</li> |
402 |
* </ul> |
403 |
* @type string|int|function|null |
404 |
* @default null <i>Use mData</i> |
405 |
* @dtopt Columns |
406 |
* |
407 |
* @example |
408 |
* // Create a comma separated list from an array of objects |
409 |
* $(document).ready( function() { |
410 |
* var oTable = $('#example').dataTable( { |
411 |
* "sAjaxSource": "sources/deep.txt", |
412 |
* "aoColumns": [ |
413 |
* { "mData": "engine" }, |
414 |
* { "mData": "browser" }, |
415 |
* { |
416 |
* "mData": "platform", |
417 |
* "mRender": "[, ].name" |
418 |
* } |
419 |
* ] |
420 |
* } ); |
421 |
* } ); |
422 |
* |
423 |
* @example |
424 |
* // Use as a function to create a link from the data source |
425 |
* $(document).ready( function() { |
426 |
* var oTable = $('#example').dataTable( { |
427 |
* "aoColumnDefs": [ |
428 |
* { |
429 |
* "aTargets": [ 0 ], |
430 |
* "mData": "download_link", |
431 |
* "mRender": function ( data, type, full ) { |
432 |
* return '<a href="'+data+'">Download</a>'; |
433 |
* } |
434 |
* ] |
435 |
* } ); |
436 |
* } ); |
437 |
*/ |
438 |
"mRender": null, |
439 |
|
440 |
|
441 |
/** |
442 |
* Change the cell type created for the column - either TD cells or TH cells. This |
443 |
* can be useful as TH cells have semantic meaning in the table body, allowing them |
444 |
* to act as a header for a row (you may wish to add scope='row' to the TH elements). |
445 |
* @type string |
446 |
* @default td |
447 |
* @dtopt Columns |
448 |
* |
449 |
* @example |
450 |
* // Make the first column use TH cells |
451 |
* $(document).ready( function() { |
452 |
* var oTable = $('#example').dataTable( { |
453 |
* "aoColumnDefs": [ { |
454 |
* "aTargets": [ 0 ], |
455 |
* "sCellType": "th" |
456 |
* } ] |
457 |
* } ); |
458 |
* } ); |
459 |
*/ |
460 |
"sCellType": "td", |
461 |
|
462 |
|
463 |
/** |
464 |
* Class to give to each cell in this column. |
465 |
* @type string |
466 |
* @default <i>Empty string</i> |
467 |
* @dtopt Columns |
468 |
* |
469 |
* @example |
470 |
* // Using aoColumnDefs |
471 |
* $(document).ready( function() { |
472 |
* $('#example').dataTable( { |
473 |
* "aoColumnDefs": [ |
474 |
* { "sClass": "my_class", "aTargets": [ 0 ] } |
475 |
* ] |
476 |
* } ); |
477 |
* } ); |
478 |
* |
479 |
* @example |
480 |
* // Using aoColumns |
481 |
* $(document).ready( function() { |
482 |
* $('#example').dataTable( { |
483 |
* "aoColumns": [ |
484 |
* { "sClass": "my_class" }, |
485 |
* null, |
486 |
* null, |
487 |
* null, |
488 |
* null |
489 |
* ] |
490 |
* } ); |
491 |
* } ); |
492 |
*/ |
493 |
"sClass": "", |
494 |
|
495 |
/** |
496 |
* When DataTables calculates the column widths to assign to each column, |
497 |
* it finds the longest string in each column and then constructs a |
498 |
* temporary table and reads the widths from that. The problem with this |
499 |
* is that "mmm" is much wider then "iiii", but the latter is a longer |
500 |
* string - thus the calculation can go wrong (doing it properly and putting |
501 |
* it into an DOM object and measuring that is horribly(!) slow). Thus as |
502 |
* a "work around" we provide this option. It will append its value to the |
503 |
* text that is found to be the longest string for the column - i.e. padding. |
504 |
* Generally you shouldn't need this, and it is not documented on the |
505 |
* general DataTables.net documentation |
506 |
* @type string |
507 |
* @default <i>Empty string<i> |
508 |
* @dtopt Columns |
509 |
* |
510 |
* @example |
511 |
* // Using aoColumns |
512 |
* $(document).ready( function() { |
513 |
* $('#example').dataTable( { |
514 |
* "aoColumns": [ |
515 |
* null, |
516 |
* null, |
517 |
* null, |
518 |
* { |
519 |
* "sContentPadding": "mmm" |
520 |
* } |
521 |
* ] |
522 |
* } ); |
523 |
* } ); |
524 |
*/ |
525 |
"sContentPadding": "", |
526 |
|
527 |
|
528 |
/** |
529 |
* Allows a default value to be given for a column's data, and will be used |
530 |
* whenever a null data source is encountered (this can be because mData |
531 |
* is set to null, or because the data source itself is null). |
532 |
* @type string |
533 |
* @default null |
534 |
* @dtopt Columns |
535 |
* |
536 |
* @example |
537 |
* // Using aoColumnDefs |
538 |
* $(document).ready( function() { |
539 |
* $('#example').dataTable( { |
540 |
* "aoColumnDefs": [ |
541 |
* { |
542 |
* "mData": null, |
543 |
* "sDefaultContent": "Edit", |
544 |
* "aTargets": [ -1 ] |
545 |
* } |
546 |
* ] |
547 |
* } ); |
548 |
* } ); |
549 |
* |
550 |
* @example |
551 |
* // Using aoColumns |
552 |
* $(document).ready( function() { |
553 |
* $('#example').dataTable( { |
554 |
* "aoColumns": [ |
555 |
* null, |
556 |
* null, |
557 |
* null, |
558 |
* { |
559 |
* "mData": null, |
560 |
* "sDefaultContent": "Edit" |
561 |
* } |
562 |
* ] |
563 |
* } ); |
564 |
* } ); |
565 |
*/ |
566 |
"sDefaultContent": null, |
567 |
|
568 |
|
569 |
/** |
570 |
* This parameter is only used in DataTables' server-side processing. It can |
571 |
* be exceptionally useful to know what columns are being displayed on the |
572 |
* client side, and to map these to database fields. When defined, the names |
573 |
* also allow DataTables to reorder information from the server if it comes |
574 |
* back in an unexpected order (i.e. if you switch your columns around on the |
575 |
* client-side, your server-side code does not also need updating). |
576 |
* @type string |
577 |
* @default <i>Empty string</i> |
578 |
* @dtopt Columns |
579 |
* |
580 |
* @example |
581 |
* // Using aoColumnDefs |
582 |
* $(document).ready( function() { |
583 |
* $('#example').dataTable( { |
584 |
* "aoColumnDefs": [ |
585 |
* { "sName": "engine", "aTargets": [ 0 ] }, |
586 |
* { "sName": "browser", "aTargets": [ 1 ] }, |
587 |
* { "sName": "platform", "aTargets": [ 2 ] }, |
588 |
* { "sName": "version", "aTargets": [ 3 ] }, |
589 |
* { "sName": "grade", "aTargets": [ 4 ] } |
590 |
* ] |
591 |
* } ); |
592 |
* } ); |
593 |
* |
594 |
* @example |
595 |
* // Using aoColumns |
596 |
* $(document).ready( function() { |
597 |
* $('#example').dataTable( { |
598 |
* "aoColumns": [ |
599 |
* { "sName": "engine" }, |
600 |
* { "sName": "browser" }, |
601 |
* { "sName": "platform" }, |
602 |
* { "sName": "version" }, |
603 |
* { "sName": "grade" } |
604 |
* ] |
605 |
* } ); |
606 |
* } ); |
607 |
*/ |
608 |
"sName": "", |
609 |
|
610 |
|
611 |
/** |
612 |
* Defines a data source type for the sorting which can be used to read |
613 |
* real-time information from the table (updating the internally cached |
614 |
* version) prior to sorting. This allows sorting to occur on user editable |
615 |
* elements such as form inputs. |
616 |
* @type string |
617 |
* @default std |
618 |
* @dtopt Columns |
619 |
* |
620 |
* @example |
621 |
* // Using aoColumnDefs |
622 |
* $(document).ready( function() { |
623 |
* $('#example').dataTable( { |
624 |
* "aoColumnDefs": [ |
625 |
* { "sSortDataType": "dom-text", "aTargets": [ 2, 3 ] }, |
626 |
* { "sType": "numeric", "aTargets": [ 3 ] }, |
627 |
* { "sSortDataType": "dom-select", "aTargets": [ 4 ] }, |
628 |
* { "sSortDataType": "dom-checkbox", "aTargets": [ 5 ] } |
629 |
* ] |
630 |
* } ); |
631 |
* } ); |
632 |
* |
633 |
* @example |
634 |
* // Using aoColumns |
635 |
* $(document).ready( function() { |
636 |
* $('#example').dataTable( { |
637 |
* "aoColumns": [ |
638 |
* null, |
639 |
* null, |
640 |
* { "sSortDataType": "dom-text" }, |
641 |
* { "sSortDataType": "dom-text", "sType": "numeric" }, |
642 |
* { "sSortDataType": "dom-select" }, |
643 |
* { "sSortDataType": "dom-checkbox" } |
644 |
* ] |
645 |
* } ); |
646 |
* } ); |
647 |
*/ |
648 |
"sSortDataType": "std", |
649 |
|
650 |
|
651 |
/** |
652 |
* The title of this column. |
653 |
* @type string |
654 |
* @default null <i>Derived from the 'TH' value for this column in the |
655 |
* original HTML table.</i> |
656 |
* @dtopt Columns |
657 |
* |
658 |
* @example |
659 |
* // Using aoColumnDefs |
660 |
* $(document).ready( function() { |
661 |
* $('#example').dataTable( { |
662 |
* "aoColumnDefs": [ |
663 |
* { "sTitle": "My column title", "aTargets": [ 0 ] } |
664 |
* ] |
665 |
* } ); |
666 |
* } ); |
667 |
* |
668 |
* @example |
669 |
* // Using aoColumns |
670 |
* $(document).ready( function() { |
671 |
* $('#example').dataTable( { |
672 |
* "aoColumns": [ |
673 |
* { "sTitle": "My column title" }, |
674 |
* null, |
675 |
* null, |
676 |
* null, |
677 |
* null |
678 |
* ] |
679 |
* } ); |
680 |
* } ); |
681 |
*/ |
682 |
"sTitle": null, |
683 |
|
684 |
|
685 |
/** |
686 |
* The type allows you to specify how the data for this column will be sorted. |
687 |
* Four types (string, numeric, date and html (which will strip HTML tags |
688 |
* before sorting)) are currently available. Note that only date formats |
689 |
* understood by Javascript's Date() object will be accepted as type date. For |
690 |
* example: "Mar 26, 2008 5:03 PM". May take the values: 'string', 'numeric', |
691 |
* 'date' or 'html' (by default). Further types can be adding through |
692 |
* plug-ins. |
693 |
* @type string |
694 |
* @default null <i>Auto-detected from raw data</i> |
695 |
* @dtopt Columns |
696 |
* |
697 |
* @example |
698 |
* // Using aoColumnDefs |
699 |
* $(document).ready( function() { |
700 |
* $('#example').dataTable( { |
701 |
* "aoColumnDefs": [ |
702 |
* { "sType": "html", "aTargets": [ 0 ] } |
703 |
* ] |
704 |
* } ); |
705 |
* } ); |
706 |
* |
707 |
* @example |
708 |
* // Using aoColumns |
709 |
* $(document).ready( function() { |
710 |
* $('#example').dataTable( { |
711 |
* "aoColumns": [ |
712 |
* { "sType": "html" }, |
713 |
* null, |
714 |
* null, |
715 |
* null, |
716 |
* null |
717 |
* ] |
718 |
* } ); |
719 |
* } ); |
720 |
*/ |
721 |
"sType": null, |
722 |
|
723 |
|
724 |
/** |
725 |
* Defining the width of the column, this parameter may take any CSS value |
726 |
* (3em, 20px etc). DataTables apples 'smart' widths to columns which have not |
727 |
* been given a specific width through this interface ensuring that the table |
728 |
* remains readable. |
729 |
* @type string |
730 |
* @default null <i>Automatic</i> |
731 |
* @dtopt Columns |
732 |
* |
733 |
* @example |
734 |
* // Using aoColumnDefs |
735 |
* $(document).ready( function() { |
736 |
* $('#example').dataTable( { |
737 |
* "aoColumnDefs": [ |
738 |
* { "sWidth": "20%", "aTargets": [ 0 ] } |
739 |
* ] |
740 |
* } ); |
741 |
* } ); |
742 |
* |
743 |
* @example |
744 |
* // Using aoColumns |
745 |
* $(document).ready( function() { |
746 |
* $('#example').dataTable( { |
747 |
* "aoColumns": [ |
748 |
* { "sWidth": "20%" }, |
749 |
* null, |
750 |
* null, |
751 |
* null, |
752 |
* null |
753 |
* ] |
754 |
* } ); |
755 |
* } ); |
756 |
*/ |
757 |
"sWidth": null |
758 |
}; |