Mercurial > repos > saskia-hiltemann > ireport
comparison DataTables-1.9.4/media/src/core/core.support.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 * Return the settings object for a particular table | |
4 * @param {node} nTable table we are using as a dataTable | |
5 * @returns {object} Settings object - or null if not found | |
6 * @memberof DataTable#oApi | |
7 */ | |
8 function _fnSettingsFromNode ( nTable ) | |
9 { | |
10 for ( var i=0 ; i<DataTable.settings.length ; i++ ) | |
11 { | |
12 if ( DataTable.settings[i].nTable === nTable ) | |
13 { | |
14 return DataTable.settings[i]; | |
15 } | |
16 } | |
17 | |
18 return null; | |
19 } | |
20 | |
21 | |
22 /** | |
23 * Return an array with the TR nodes for the table | |
24 * @param {object} oSettings dataTables settings object | |
25 * @returns {array} TR array | |
26 * @memberof DataTable#oApi | |
27 */ | |
28 function _fnGetTrNodes ( oSettings ) | |
29 { | |
30 var aNodes = []; | |
31 var aoData = oSettings.aoData; | |
32 for ( var i=0, iLen=aoData.length ; i<iLen ; i++ ) | |
33 { | |
34 if ( aoData[i].nTr !== null ) | |
35 { | |
36 aNodes.push( aoData[i].nTr ); | |
37 } | |
38 } | |
39 return aNodes; | |
40 } | |
41 | |
42 | |
43 /** | |
44 * Return an flat array with all TD nodes for the table, or row | |
45 * @param {object} oSettings dataTables settings object | |
46 * @param {int} [iIndividualRow] aoData index to get the nodes for - optional | |
47 * if not given then the return array will contain all nodes for the table | |
48 * @returns {array} TD array | |
49 * @memberof DataTable#oApi | |
50 */ | |
51 function _fnGetTdNodes ( oSettings, iIndividualRow ) | |
52 { | |
53 var anReturn = []; | |
54 var iCorrector; | |
55 var anTds, nTd; | |
56 var iRow, iRows=oSettings.aoData.length, | |
57 iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows; | |
58 | |
59 /* Allow the collection to be limited to just one row */ | |
60 if ( iIndividualRow !== undefined ) | |
61 { | |
62 iStart = iIndividualRow; | |
63 iEnd = iIndividualRow+1; | |
64 } | |
65 | |
66 for ( iRow=iStart ; iRow<iEnd ; iRow++ ) | |
67 { | |
68 oData = oSettings.aoData[iRow]; | |
69 if ( oData.nTr !== null ) | |
70 { | |
71 /* get the TD child nodes - taking into account text etc nodes */ | |
72 anTds = []; | |
73 nTd = oData.nTr.firstChild; | |
74 while ( nTd ) | |
75 { | |
76 sNodeName = nTd.nodeName.toLowerCase(); | |
77 if ( sNodeName == 'td' || sNodeName == 'th' ) | |
78 { | |
79 anTds.push( nTd ); | |
80 } | |
81 nTd = nTd.nextSibling; | |
82 } | |
83 | |
84 iCorrector = 0; | |
85 for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ ) | |
86 { | |
87 if ( oSettings.aoColumns[iColumn].bVisible ) | |
88 { | |
89 anReturn.push( anTds[iColumn-iCorrector] ); | |
90 } | |
91 else | |
92 { | |
93 anReturn.push( oData._anHidden[iColumn] ); | |
94 iCorrector++; | |
95 } | |
96 } | |
97 } | |
98 } | |
99 | |
100 return anReturn; | |
101 } | |
102 | |
103 | |
104 /** | |
105 * Log an error message | |
106 * @param {object} oSettings dataTables settings object | |
107 * @param {int} iLevel log error messages, or display them to the user | |
108 * @param {string} sMesg error message | |
109 * @memberof DataTable#oApi | |
110 */ | |
111 function _fnLog( oSettings, iLevel, sMesg ) | |
112 { | |
113 var sAlert = (oSettings===null) ? | |
114 "DataTables warning: "+sMesg : | |
115 "DataTables warning (table id = '"+oSettings.sTableId+"'): "+sMesg; | |
116 | |
117 if ( iLevel === 0 ) | |
118 { | |
119 if ( DataTable.ext.sErrMode == 'alert' ) | |
120 { | |
121 alert( sAlert ); | |
122 } | |
123 else | |
124 { | |
125 throw new Error(sAlert); | |
126 } | |
127 return; | |
128 } | |
129 else if ( window.console && console.log ) | |
130 { | |
131 console.log( sAlert ); | |
132 } | |
133 } | |
134 | |
135 | |
136 /** | |
137 * See if a property is defined on one object, if so assign it to the other object | |
138 * @param {object} oRet target object | |
139 * @param {object} oSrc source object | |
140 * @param {string} sName property | |
141 * @param {string} [sMappedName] name to map too - optional, sName used if not given | |
142 * @memberof DataTable#oApi | |
143 */ | |
144 function _fnMap( oRet, oSrc, sName, sMappedName ) | |
145 { | |
146 if ( sMappedName === undefined ) | |
147 { | |
148 sMappedName = sName; | |
149 } | |
150 if ( oSrc[sName] !== undefined ) | |
151 { | |
152 oRet[sMappedName] = oSrc[sName]; | |
153 } | |
154 } | |
155 | |
156 | |
157 /** | |
158 * Extend objects - very similar to jQuery.extend, but deep copy objects, and shallow | |
159 * copy arrays. The reason we need to do this, is that we don't want to deep copy array | |
160 * init values (such as aaSorting) since the dev wouldn't be able to override them, but | |
161 * we do want to deep copy arrays. | |
162 * @param {object} oOut Object to extend | |
163 * @param {object} oExtender Object from which the properties will be applied to oOut | |
164 * @returns {object} oOut Reference, just for convenience - oOut === the return. | |
165 * @memberof DataTable#oApi | |
166 * @todo This doesn't take account of arrays inside the deep copied objects. | |
167 */ | |
168 function _fnExtend( oOut, oExtender ) | |
169 { | |
170 var val; | |
171 | |
172 for ( var prop in oExtender ) | |
173 { | |
174 if ( oExtender.hasOwnProperty(prop) ) | |
175 { | |
176 val = oExtender[prop]; | |
177 | |
178 if ( typeof oInit[prop] === 'object' && val !== null && $.isArray(val) === false ) | |
179 { | |
180 $.extend( true, oOut[prop], val ); | |
181 } | |
182 else | |
183 { | |
184 oOut[prop] = val; | |
185 } | |
186 } | |
187 } | |
188 | |
189 return oOut; | |
190 } | |
191 | |
192 | |
193 /** | |
194 * Bind an event handers to allow a click or return key to activate the callback. | |
195 * This is good for accessibility since a return on the keyboard will have the | |
196 * same effect as a click, if the element has focus. | |
197 * @param {element} n Element to bind the action to | |
198 * @param {object} oData Data object to pass to the triggered function | |
199 * @param {function} fn Callback function for when the event is triggered | |
200 * @memberof DataTable#oApi | |
201 */ | |
202 function _fnBindAction( n, oData, fn ) | |
203 { | |
204 $(n) | |
205 .bind( 'click.DT', oData, function (e) { | |
206 n.blur(); // Remove focus outline for mouse users | |
207 fn(e); | |
208 } ) | |
209 .bind( 'keypress.DT', oData, function (e){ | |
210 if ( e.which === 13 ) { | |
211 fn(e); | |
212 } } ) | |
213 .bind( 'selectstart.DT', function () { | |
214 /* Take the brutal approach to cancelling text selection */ | |
215 return false; | |
216 } ); | |
217 } | |
218 | |
219 | |
220 /** | |
221 * Register a callback function. Easily allows a callback function to be added to | |
222 * an array store of callback functions that can then all be called together. | |
223 * @param {object} oSettings dataTables settings object | |
224 * @param {string} sStore Name of the array storage for the callbacks in oSettings | |
225 * @param {function} fn Function to be called back | |
226 * @param {string} sName Identifying name for the callback (i.e. a label) | |
227 * @memberof DataTable#oApi | |
228 */ | |
229 function _fnCallbackReg( oSettings, sStore, fn, sName ) | |
230 { | |
231 if ( fn ) | |
232 { | |
233 oSettings[sStore].push( { | |
234 "fn": fn, | |
235 "sName": sName | |
236 } ); | |
237 } | |
238 } | |
239 | |
240 | |
241 /** | |
242 * Fire callback functions and trigger events. Note that the loop over the callback | |
243 * array store is done backwards! Further note that you do not want to fire off triggers | |
244 * in time sensitive applications (for example cell creation) as its slow. | |
245 * @param {object} oSettings dataTables settings object | |
246 * @param {string} sStore Name of the array storage for the callbacks in oSettings | |
247 * @param {string} sTrigger Name of the jQuery custom event to trigger. If null no trigger | |
248 * is fired | |
249 * @param {array} aArgs Array of arguments to pass to the callback function / trigger | |
250 * @memberof DataTable#oApi | |
251 */ | |
252 function _fnCallbackFire( oSettings, sStore, sTrigger, aArgs ) | |
253 { | |
254 var aoStore = oSettings[sStore]; | |
255 var aRet =[]; | |
256 | |
257 for ( var i=aoStore.length-1 ; i>=0 ; i-- ) | |
258 { | |
259 aRet.push( aoStore[i].fn.apply( oSettings.oInstance, aArgs ) ); | |
260 } | |
261 | |
262 if ( sTrigger !== null ) | |
263 { | |
264 $(oSettings.oInstance).trigger(sTrigger, aArgs); | |
265 } | |
266 | |
267 return aRet; | |
268 } | |
269 | |
270 | |
271 /** | |
272 * JSON stringify. If JSON.stringify it provided by the browser, json2.js or any other | |
273 * library, then we use that as it is fast, safe and accurate. If the function isn't | |
274 * available then we need to built it ourselves - the inspiration for this function comes | |
275 * from Craig Buckler ( http://www.sitepoint.com/javascript-json-serialization/ ). It is | |
276 * not perfect and absolutely should not be used as a replacement to json2.js - but it does | |
277 * do what we need, without requiring a dependency for DataTables. | |
278 * @param {object} o JSON object to be converted | |
279 * @returns {string} JSON string | |
280 * @memberof DataTable#oApi | |
281 */ | |
282 var _fnJsonString = (window.JSON) ? JSON.stringify : function( o ) | |
283 { | |
284 /* Not an object or array */ | |
285 var sType = typeof o; | |
286 if (sType !== "object" || o === null) | |
287 { | |
288 // simple data type | |
289 if (sType === "string") | |
290 { | |
291 o = '"'+o+'"'; | |
292 } | |
293 return o+""; | |
294 } | |
295 | |
296 /* If object or array, need to recurse over it */ | |
297 var | |
298 sProp, mValue, | |
299 json = [], | |
300 bArr = $.isArray(o); | |
301 | |
302 for (sProp in o) | |
303 { | |
304 mValue = o[sProp]; | |
305 sType = typeof mValue; | |
306 | |
307 if (sType === "string") | |
308 { | |
309 mValue = '"'+mValue+'"'; | |
310 } | |
311 else if (sType === "object" && mValue !== null) | |
312 { | |
313 mValue = _fnJsonString(mValue); | |
314 } | |
315 | |
316 json.push((bArr ? "" : '"'+sProp+'":') + mValue); | |
317 } | |
318 | |
319 return (bArr ? "[" : "{") + json + (bArr ? "]" : "}"); | |
320 }; | |
321 | |
322 | |
323 /** | |
324 * From some browsers (specifically IE6/7) we need special handling to work around browser | |
325 * bugs - this function is used to detect when these workarounds are needed. | |
326 * @param {object} oSettings dataTables settings object | |
327 * @memberof DataTable#oApi | |
328 */ | |
329 function _fnBrowserDetect( oSettings ) | |
330 { | |
331 /* IE6/7 will oversize a width 100% element inside a scrolling element, to include the | |
332 * width of the scrollbar, while other browsers ensure the inner element is contained | |
333 * without forcing scrolling | |
334 */ | |
335 var n = $( | |
336 '<div style="position:absolute; top:0; left:0; height:1px; width:1px; overflow:hidden">'+ | |
337 '<div style="position:absolute; top:1px; left:1px; width:100px; overflow:scroll;">'+ | |
338 '<div id="DT_BrowserTest" style="width:100%; height:10px;"></div>'+ | |
339 '</div>'+ | |
340 '</div>')[0]; | |
341 | |
342 document.body.appendChild( n ); | |
343 oSettings.oBrowser.bScrollOversize = $('#DT_BrowserTest', n)[0].offsetWidth === 100 ? true : false; | |
344 document.body.removeChild( n ); | |
345 } | |
346 |